diff --git a/docs/mdsource/doc-index.include.md b/docs/mdsource/doc-index.include.md
index c006baaf5..41747fd3f 100644
--- a/docs/mdsource/doc-index.include.md
+++ b/docs/mdsource/doc-index.include.md
@@ -35,6 +35,7 @@
   * [Custom Diff Tool](https://github.com/VerifyTests/DiffEngine/blob/master/docs/diff-tool.custom.md)
   * [Using anonymous types](/docs/anonymous-types.md)
   * [Verifying binary data](/docs/binary.md)
+  * [Newline tolerance](/docs/newline-tolerance.md)
   * [Exception Message Format](/docs/exception-message-format.md)
   * [Build server](/docs/build-server.md)
   * [Kill process locking file](/docs/kill-process-locking-file.md)
diff --git a/docs/mdsource/newline-tolerance.source.md b/docs/mdsource/newline-tolerance.source.md
new file mode 100644
index 000000000..2b968ead8
--- /dev/null
+++ b/docs/mdsource/newline-tolerance.source.md
@@ -0,0 +1,70 @@
+## Newline tolerance
+
+Text snapshots use line-feed newlines, and have no trailing newline. See [Text file settings](/readme.md#text-file-settings) for the source control and editor configuration that keeps them that way.
+
+The received side of a comparison always conforms, since Verify normalizes content to `\n` before comparing and writes the file itself. The verified side is whatever last wrote it, which is not always Verify. An editor saving with crlf, or a git checkout applying `core.autocrlf=true`, leaves carriage returns in a verified file, and a verified file containing a `\r` is rejected. An editor adding a final newline on save leaves the file one character longer than the content the test produces, and that fails as a mismatch.
+
+Two opt in settings make the comparison tolerant of those two cases. Both are global, and both throw if called after the first verify has run, so a module initializer is the only place to set them.
+
+**Neither setting is a replacement for the source control and editor settings.** Those keep the content on disk consistent for everyone working on a repository. The settings below only stop a local misconfiguration from failing the test run, and doing that has [side effects](#side-effects).
+
+
+### FixNewlinesOnRead
+
+snippet: FixNewlinesOnRead
+
+With this enabled, `\r\n` and `\r` in a verified file are treated as `\n` when comparing, so a verified file saved with crlf still matches. Normalizing happens in memory only. The file on disk is left as is until it is next written, at which point it is written with lf.
+
+
+### IgnoreTrailingNewline
+
+snippet: IgnoreTrailingNewline
+
+With this enabled, a verified file that ends in a single `\n`, where that newline accounts for the entire difference in length, matches the received content.
+
+The tolerance is deliberately narrow. Two trailing newlines, or any other change in content, still fails. Received files are not covered, since those are written by Verify rather than by an editor. As above, trimming happens in memory only.
+
+
+### Side effects
+
+
+#### Line endings on disk diverge between developers
+
+Accepting a snapshot through DiffEngineTray, or through the Rider or ReSharper plugins, moves the received file over the verified file. Received files are written by Verify, so the result is lf. Accepting by editing the verified file in a diff editor writes whatever that editor is configured to write, which on Windows is often crlf. With tolerance enabled both accepts pass, so the line endings of a snapshot file end up reflecting the workflow of whoever last accepted it rather than a single convention.
+
+Whether that flip is visible in a pending git diff depends on the repository. Where `.gitattributes` or `core.autocrlf` normalizes on commit, the crlf stays in the working tree and never reaches a blob. Where it does not, each flip is committed as a change to every line of the file. A one line snapshot change then arrives for review as a whole file diff, and `git blame` attributes every line to the flip rather than to the change that matters.
+
+
+#### IgnoreTrailingNewline can mask a lost trailing newline
+
+The two settings do not carry the same risk.
+
+Newline style is already normalized, on both sides. Content is converted to `\n` before it is compared or written, so a `\r` can never reach the received side, and a `\r` in a verified file is always an artifact of tooling rather than something a test produced. Treating it as `\n` cannot hide a change in behavior, since that difference cannot be asserted in the first place.
+
+A trailing newline is not style, it is content. `a` and `a\n` differ under any newline convention, and are compared exactly.
+
+The masking that results is narrow, and applies in one direction only. The tolerance fires when the verified file is the longer of the two, so output that starts emitting a trailing newline still fails. Output that stops emitting one, where the verified file has it, now passes. That needs a snapshot whose content genuinely ends in a newline, which serialized objects do not, but verified files and generated text can.
+
+
+#### The misconfiguration is no longer surfaced
+
+Rejecting a carriage return is the signal that a checkout, an editor, or a build agent working directory is misconfigured. With tolerance enabled the tests pass everywhere, including on CI, so nothing reports the problem.
+
+Nor does it correct itself. A verified file is only rewritten when a snapshot changes, so a file that has crlf keeps it until something else happens to that snapshot.
+
+
+#### Diff output during a real mismatch
+
+When a comparison genuinely fails, the received file is written with lf while the verified file keeps its crlf. A diff tool that treats line endings as significant then presents every line as changed, which buries the difference the test is reporting.
+
+
+#### Reported content is not the content on disk
+
+Normalizing and trimming happen in memory. The verified text passed to a [custom comparer](/docs/comparer.md), to `OnVerifyMismatch`, and into the `FileContent` section of the [exception message](/docs/exception-message-format.md) is the normalized text, not the bytes in the file. Tooling that consumes those and compares against the file on disk sees a difference.
+
+
+#### Performance
+
+For `FixNewlinesOnRead`, the scan for `\r` runs either way, since it is the same check that drives the rejection. Where a `\r` is found, normalizing allocates and copies the verified content twice, once per replacement. That cost is proportional to snapshot size and is paid for every affected file on every run. On a checkout where every verified file has crlf, that is the entire snapshot corpus copied twice per test run.
+
+For `IgnoreTrailingNewline`, the added length and character check on every text comparison is not measurable. The trim allocates one copy of the verified content, and only in the case being tolerated.
diff --git a/docs/mdsource/text-file-settings.include.md b/docs/mdsource/text-file-settings.include.md
index a685ab11a..d96cbef61 100644
--- a/docs/mdsource/text-file-settings.include.md
+++ b/docs/mdsource/text-file-settings.include.md
@@ -79,4 +79,9 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
\ No newline at end of file
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).
\ No newline at end of file
diff --git a/docs/newline-tolerance.md b/docs/newline-tolerance.md
new file mode 100644
index 000000000..8aac7a5dd
--- /dev/null
+++ b/docs/newline-tolerance.md
@@ -0,0 +1,99 @@
+<!--
+GENERATED FILE - DO NOT EDIT
+This file was generated by [MarkdownSnippets](https://github.com/SimonCropp/MarkdownSnippets).
+Source File: /docs/mdsource/newline-tolerance.source.md
+To change this file edit the source file and then run MarkdownSnippets.
+-->
+
+## Newline tolerance
+
+Text snapshots use line-feed newlines, and have no trailing newline. See [Text file settings](/readme.md#text-file-settings) for the source control and editor configuration that keeps them that way.
+
+The received side of a comparison always conforms, since Verify normalizes content to `\n` before comparing and writes the file itself. The verified side is whatever last wrote it, which is not always Verify. An editor saving with crlf, or a git checkout applying `core.autocrlf=true`, leaves carriage returns in a verified file, and a verified file containing a `\r` is rejected. An editor adding a final newline on save leaves the file one character longer than the content the test produces, and that fails as a mismatch.
+
+Two opt in settings make the comparison tolerant of those two cases. Both are global, and both throw if called after the first verify has run, so a module initializer is the only place to set them.
+
+**Neither setting is a replacement for the source control and editor settings.** Those keep the content on disk consistent for everyone working on a repository. The settings below only stop a local misconfiguration from failing the test run, and doing that has [side effects](#side-effects).
+
+
+### FixNewlinesOnRead
+
+<!-- snippet: FixNewlinesOnRead -->
+<a id='snippet-FixNewlinesOnRead'></a>
+```cs
+public static class ModuleInitializer
+{
+    [ModuleInitializer]
+    public static void Init() =>
+        VerifierSettings.FixNewlinesOnRead();
+}
+```
+<sup><a href='/src/ModuleInitDocs/FixNewlinesOnRead.cs#L3-L12' title='Snippet source file'>snippet source</a> | <a href='#snippet-FixNewlinesOnRead' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+With this enabled, `\r\n` and `\r` in a verified file are treated as `\n` when comparing, so a verified file saved with crlf still matches. Normalizing happens in memory only. The file on disk is left as is until it is next written, at which point it is written with lf.
+
+
+### IgnoreTrailingNewline
+
+<!-- snippet: IgnoreTrailingNewline -->
+<a id='snippet-IgnoreTrailingNewline'></a>
+```cs
+public static class ModuleInitializer
+{
+    [ModuleInitializer]
+    public static void Init() =>
+        VerifierSettings.IgnoreTrailingNewline();
+}
+```
+<sup><a href='/src/ModuleInitDocs/IgnoreTrailingNewline.cs#L3-L12' title='Snippet source file'>snippet source</a> | <a href='#snippet-IgnoreTrailingNewline' title='Start of snippet'>anchor</a></sup>
+<!-- endSnippet -->
+
+With this enabled, a verified file that ends in a single `\n`, where that newline accounts for the entire difference in length, matches the received content.
+
+The tolerance is deliberately narrow. Two trailing newlines, or any other change in content, still fails. Received files are not covered, since those are written by Verify rather than by an editor. As above, trimming happens in memory only.
+
+
+### Side effects
+
+
+#### Line endings on disk diverge between developers
+
+Accepting a snapshot through DiffEngineTray, or through the Rider or ReSharper plugins, moves the received file over the verified file. Received files are written by Verify, so the result is lf. Accepting by editing the verified file in a diff editor writes whatever that editor is configured to write, which on Windows is often crlf. With tolerance enabled both accepts pass, so the line endings of a snapshot file end up reflecting the workflow of whoever last accepted it rather than a single convention.
+
+Whether that flip is visible in a pending git diff depends on the repository. Where `.gitattributes` or `core.autocrlf` normalizes on commit, the crlf stays in the working tree and never reaches a blob. Where it does not, each flip is committed as a change to every line of the file. A one line snapshot change then arrives for review as a whole file diff, and `git blame` attributes every line to the flip rather than to the change that matters.
+
+
+#### IgnoreTrailingNewline can mask a lost trailing newline
+
+The two settings do not carry the same risk.
+
+Newline style is already normalized, on both sides. Content is converted to `\n` before it is compared or written, so a `\r` can never reach the received side, and a `\r` in a verified file is always an artifact of tooling rather than something a test produced. Treating it as `\n` cannot hide a change in behavior, since that difference cannot be asserted in the first place.
+
+A trailing newline is not style, it is content. `a` and `a\n` differ under any newline convention, and are compared exactly.
+
+The masking that results is narrow, and applies in one direction only. The tolerance fires when the verified file is the longer of the two, so output that starts emitting a trailing newline still fails. Output that stops emitting one, where the verified file has it, now passes. That needs a snapshot whose content genuinely ends in a newline, which serialized objects do not, but verified files and generated text can.
+
+
+#### The misconfiguration is no longer surfaced
+
+Rejecting a carriage return is the signal that a checkout, an editor, or a build agent working directory is misconfigured. With tolerance enabled the tests pass everywhere, including on CI, so nothing reports the problem.
+
+Nor does it correct itself. A verified file is only rewritten when a snapshot changes, so a file that has crlf keeps it until something else happens to that snapshot.
+
+
+#### Diff output during a real mismatch
+
+When a comparison genuinely fails, the received file is written with lf while the verified file keeps its crlf. A diff tool that treats line endings as significant then presents every line as changed, which buries the difference the test is reporting.
+
+
+#### Reported content is not the content on disk
+
+Normalizing and trimming happen in memory. The verified text passed to a [custom comparer](/docs/comparer.md), to `OnVerifyMismatch`, and into the `FileContent` section of the [exception message](/docs/exception-message-format.md) is the normalized text, not the bytes in the file. Tooling that consumes those and compares against the file on disk sees a difference.
+
+
+#### Performance
+
+For `FixNewlinesOnRead`, the scan for `\r` runs either way, since it is the same check that drives the rejection. Where a `\r` is found, normalizing allocates and copies the verified content twice, once per replacement. That cost is proportional to snapshot size and is paid for every affected file on every run. On a checkout where every verified file has crlf, that is the entire snapshot corpus copied twice per test run.
+
+For `IgnoreTrailingNewline`, the added length and character check on every text comparison is not measurable. The trim allocates one copy of the verified content, and only in the case being tolerated.
diff --git a/docs/readme.md b/docs/readme.md
index e03dd6fc0..a2a7c40e9 100644
--- a/docs/readme.md
+++ b/docs/readme.md
@@ -44,6 +44,7 @@ To change this file edit the source file and then run MarkdownSnippets.
   * [Custom Diff Tool](https://github.com/VerifyTests/DiffEngine/blob/master/docs/diff-tool.custom.md)
   * [Using anonymous types](/docs/anonymous-types.md)
   * [Verifying binary data](/docs/binary.md)
+  * [Newline tolerance](/docs/newline-tolerance.md)
   * [Exception Message Format](/docs/exception-message-format.md)
   * [Build server](/docs/build-server.md)
   * [Kill process locking file](/docs/kill-process-locking-file.md)
diff --git a/docs/wiz/Linux_Other_Cli_Expecto_AppVeyor.md b/docs/wiz/Linux_Other_Cli_Expecto_AppVeyor.md
index b632e4fba..a484e41f9 100644
--- a/docs/wiz/Linux_Other_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Expecto_AzureDevOps.md b/docs/wiz/Linux_Other_Cli_Expecto_AzureDevOps.md
index dc7b42829..e813db9cf 100644
--- a/docs/wiz/Linux_Other_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Expecto_GitHubActions.md b/docs/wiz/Linux_Other_Cli_Expecto_GitHubActions.md
index 40d60b921..a03754227 100644
--- a/docs/wiz/Linux_Other_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Expecto_None.md b/docs/wiz/Linux_Other_Cli_Expecto_None.md
index de49d7abd..988bb34ef 100644
--- a/docs/wiz/Linux_Other_Cli_Expecto_None.md
+++ b/docs/wiz/Linux_Other_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Fixie_AppVeyor.md b/docs/wiz/Linux_Other_Cli_Fixie_AppVeyor.md
index 79894c84a..dd011ddea 100644
--- a/docs/wiz/Linux_Other_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Fixie_AzureDevOps.md b/docs/wiz/Linux_Other_Cli_Fixie_AzureDevOps.md
index 045cb59e9..2476d8bc6 100644
--- a/docs/wiz/Linux_Other_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Fixie_GitHubActions.md b/docs/wiz/Linux_Other_Cli_Fixie_GitHubActions.md
index 6e19b6f84..4d3ce6076 100644
--- a/docs/wiz/Linux_Other_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_Fixie_None.md b/docs/wiz/Linux_Other_Cli_Fixie_None.md
index 7be0c993d..f54a6e7a4 100644
--- a/docs/wiz/Linux_Other_Cli_Fixie_None.md
+++ b/docs/wiz/Linux_Other_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_MSTest_AppVeyor.md b/docs/wiz/Linux_Other_Cli_MSTest_AppVeyor.md
index 184b450c0..13fec171b 100644
--- a/docs/wiz/Linux_Other_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_MSTest_AzureDevOps.md b/docs/wiz/Linux_Other_Cli_MSTest_AzureDevOps.md
index 509c5242e..923d05204 100644
--- a/docs/wiz/Linux_Other_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_MSTest_GitHubActions.md b/docs/wiz/Linux_Other_Cli_MSTest_GitHubActions.md
index 0d17f88b4..6e460aeb6 100644
--- a/docs/wiz/Linux_Other_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_MSTest_None.md b/docs/wiz/Linux_Other_Cli_MSTest_None.md
index 24df7cfd6..79587d28c 100644
--- a/docs/wiz/Linux_Other_Cli_MSTest_None.md
+++ b/docs/wiz/Linux_Other_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_NUnit_AppVeyor.md b/docs/wiz/Linux_Other_Cli_NUnit_AppVeyor.md
index 77c0f6cde..e9f4bfc86 100644
--- a/docs/wiz/Linux_Other_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_NUnit_AzureDevOps.md b/docs/wiz/Linux_Other_Cli_NUnit_AzureDevOps.md
index ecc645626..b49005987 100644
--- a/docs/wiz/Linux_Other_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_NUnit_GitHubActions.md b/docs/wiz/Linux_Other_Cli_NUnit_GitHubActions.md
index dcc0632d5..d74c0914f 100644
--- a/docs/wiz/Linux_Other_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_NUnit_None.md b/docs/wiz/Linux_Other_Cli_NUnit_None.md
index a1a08df94..be2e881d7 100644
--- a/docs/wiz/Linux_Other_Cli_NUnit_None.md
+++ b/docs/wiz/Linux_Other_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_TUnit_AppVeyor.md b/docs/wiz/Linux_Other_Cli_TUnit_AppVeyor.md
index ffbf7decb..4d8e3d0ed 100644
--- a/docs/wiz/Linux_Other_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_TUnit_AzureDevOps.md b/docs/wiz/Linux_Other_Cli_TUnit_AzureDevOps.md
index 57145fafb..d03ff613b 100644
--- a/docs/wiz/Linux_Other_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_TUnit_GitHubActions.md b/docs/wiz/Linux_Other_Cli_TUnit_GitHubActions.md
index fbd033279..94473b528 100644
--- a/docs/wiz/Linux_Other_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_TUnit_None.md b/docs/wiz/Linux_Other_Cli_TUnit_None.md
index 85a06183b..5fda0b0e4 100644
--- a/docs/wiz/Linux_Other_Cli_TUnit_None.md
+++ b/docs/wiz/Linux_Other_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_XunitV3_AppVeyor.md b/docs/wiz/Linux_Other_Cli_XunitV3_AppVeyor.md
index e7e4985f9..797737b94 100644
--- a/docs/wiz/Linux_Other_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_XunitV3_AzureDevOps.md b/docs/wiz/Linux_Other_Cli_XunitV3_AzureDevOps.md
index ee1635892..483e14fdc 100644
--- a/docs/wiz/Linux_Other_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_XunitV3_GitHubActions.md b/docs/wiz/Linux_Other_Cli_XunitV3_GitHubActions.md
index 0eef38101..1a10a7173 100644
--- a/docs/wiz/Linux_Other_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Cli_XunitV3_None.md b/docs/wiz/Linux_Other_Cli_XunitV3_None.md
index 929662741..b5f9af421 100644
--- a/docs/wiz/Linux_Other_Cli_XunitV3_None.md
+++ b/docs/wiz/Linux_Other_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Expecto_AppVeyor.md b/docs/wiz/Linux_Other_Gui_Expecto_AppVeyor.md
index 362458bac..dd59e5b24 100644
--- a/docs/wiz/Linux_Other_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Expecto_AzureDevOps.md b/docs/wiz/Linux_Other_Gui_Expecto_AzureDevOps.md
index 4a8f70cc0..d9ad79c72 100644
--- a/docs/wiz/Linux_Other_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Expecto_GitHubActions.md b/docs/wiz/Linux_Other_Gui_Expecto_GitHubActions.md
index 7e5263e32..916d38028 100644
--- a/docs/wiz/Linux_Other_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Expecto_None.md b/docs/wiz/Linux_Other_Gui_Expecto_None.md
index 9f4858a78..28712a729 100644
--- a/docs/wiz/Linux_Other_Gui_Expecto_None.md
+++ b/docs/wiz/Linux_Other_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Fixie_AppVeyor.md b/docs/wiz/Linux_Other_Gui_Fixie_AppVeyor.md
index 2fde652fa..1c85ddbb8 100644
--- a/docs/wiz/Linux_Other_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Fixie_AzureDevOps.md b/docs/wiz/Linux_Other_Gui_Fixie_AzureDevOps.md
index a5dd34c28..e0487d6d5 100644
--- a/docs/wiz/Linux_Other_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Fixie_GitHubActions.md b/docs/wiz/Linux_Other_Gui_Fixie_GitHubActions.md
index 1fde0efc5..f8b6ab6f5 100644
--- a/docs/wiz/Linux_Other_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_Fixie_None.md b/docs/wiz/Linux_Other_Gui_Fixie_None.md
index e40ec743e..fba5288a7 100644
--- a/docs/wiz/Linux_Other_Gui_Fixie_None.md
+++ b/docs/wiz/Linux_Other_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_MSTest_AppVeyor.md b/docs/wiz/Linux_Other_Gui_MSTest_AppVeyor.md
index a4d4e9377..301245650 100644
--- a/docs/wiz/Linux_Other_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_MSTest_AzureDevOps.md b/docs/wiz/Linux_Other_Gui_MSTest_AzureDevOps.md
index 7b4426fec..b31c9a140 100644
--- a/docs/wiz/Linux_Other_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_MSTest_GitHubActions.md b/docs/wiz/Linux_Other_Gui_MSTest_GitHubActions.md
index 3a5ccc0ae..55c5dcb55 100644
--- a/docs/wiz/Linux_Other_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_MSTest_None.md b/docs/wiz/Linux_Other_Gui_MSTest_None.md
index 5cc4fee41..104bb32c3 100644
--- a/docs/wiz/Linux_Other_Gui_MSTest_None.md
+++ b/docs/wiz/Linux_Other_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_NUnit_AppVeyor.md b/docs/wiz/Linux_Other_Gui_NUnit_AppVeyor.md
index 761d21b73..624b97a24 100644
--- a/docs/wiz/Linux_Other_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_NUnit_AzureDevOps.md b/docs/wiz/Linux_Other_Gui_NUnit_AzureDevOps.md
index 78b76f347..35a4bcf73 100644
--- a/docs/wiz/Linux_Other_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_NUnit_GitHubActions.md b/docs/wiz/Linux_Other_Gui_NUnit_GitHubActions.md
index 98cf34fcb..eaeb89337 100644
--- a/docs/wiz/Linux_Other_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_NUnit_None.md b/docs/wiz/Linux_Other_Gui_NUnit_None.md
index 3d3c5659e..2e23d7e95 100644
--- a/docs/wiz/Linux_Other_Gui_NUnit_None.md
+++ b/docs/wiz/Linux_Other_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_TUnit_AppVeyor.md b/docs/wiz/Linux_Other_Gui_TUnit_AppVeyor.md
index 67c895721..1baea2893 100644
--- a/docs/wiz/Linux_Other_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_TUnit_AzureDevOps.md b/docs/wiz/Linux_Other_Gui_TUnit_AzureDevOps.md
index b2e283a6a..d43486537 100644
--- a/docs/wiz/Linux_Other_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_TUnit_GitHubActions.md b/docs/wiz/Linux_Other_Gui_TUnit_GitHubActions.md
index 1cc241fab..87ffb7e3f 100644
--- a/docs/wiz/Linux_Other_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_TUnit_None.md b/docs/wiz/Linux_Other_Gui_TUnit_None.md
index d6bcd6f04..d173f5c9d 100644
--- a/docs/wiz/Linux_Other_Gui_TUnit_None.md
+++ b/docs/wiz/Linux_Other_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_XunitV3_AppVeyor.md b/docs/wiz/Linux_Other_Gui_XunitV3_AppVeyor.md
index 5a744b997..63a0a959f 100644
--- a/docs/wiz/Linux_Other_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/Linux_Other_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_XunitV3_AzureDevOps.md b/docs/wiz/Linux_Other_Gui_XunitV3_AzureDevOps.md
index 622c6a592..a6e3d8053 100644
--- a/docs/wiz/Linux_Other_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Linux_Other_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_XunitV3_GitHubActions.md b/docs/wiz/Linux_Other_Gui_XunitV3_GitHubActions.md
index 8e0b5cf69..ecc607726 100644
--- a/docs/wiz/Linux_Other_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/Linux_Other_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Other_Gui_XunitV3_None.md b/docs/wiz/Linux_Other_Gui_XunitV3_None.md
index 0863ae8ec..c1478f2b2 100644
--- a/docs/wiz/Linux_Other_Gui_XunitV3_None.md
+++ b/docs/wiz/Linux_Other_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Expecto_AppVeyor.md b/docs/wiz/Linux_Rider_Cli_Expecto_AppVeyor.md
index 3824b1820..776ee2700 100644
--- a/docs/wiz/Linux_Rider_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Expecto_AzureDevOps.md b/docs/wiz/Linux_Rider_Cli_Expecto_AzureDevOps.md
index 4b76117aa..4142b029e 100644
--- a/docs/wiz/Linux_Rider_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Expecto_GitHubActions.md b/docs/wiz/Linux_Rider_Cli_Expecto_GitHubActions.md
index 1c3a023d0..9fec5398e 100644
--- a/docs/wiz/Linux_Rider_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Expecto_None.md b/docs/wiz/Linux_Rider_Cli_Expecto_None.md
index 2372ebd4f..69205a12a 100644
--- a/docs/wiz/Linux_Rider_Cli_Expecto_None.md
+++ b/docs/wiz/Linux_Rider_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Fixie_AppVeyor.md b/docs/wiz/Linux_Rider_Cli_Fixie_AppVeyor.md
index c6ead5db4..d8d08bc1a 100644
--- a/docs/wiz/Linux_Rider_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Fixie_AzureDevOps.md b/docs/wiz/Linux_Rider_Cli_Fixie_AzureDevOps.md
index bb5de60b9..13fe6e4d0 100644
--- a/docs/wiz/Linux_Rider_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Fixie_GitHubActions.md b/docs/wiz/Linux_Rider_Cli_Fixie_GitHubActions.md
index b2f3dcacb..d80baf23e 100644
--- a/docs/wiz/Linux_Rider_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_Fixie_None.md b/docs/wiz/Linux_Rider_Cli_Fixie_None.md
index 3bd62ea1a..bb28ac14e 100644
--- a/docs/wiz/Linux_Rider_Cli_Fixie_None.md
+++ b/docs/wiz/Linux_Rider_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_MSTest_AppVeyor.md b/docs/wiz/Linux_Rider_Cli_MSTest_AppVeyor.md
index 39d60e523..bf45f544b 100644
--- a/docs/wiz/Linux_Rider_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_MSTest_AzureDevOps.md b/docs/wiz/Linux_Rider_Cli_MSTest_AzureDevOps.md
index fc1b6e108..889f8eab2 100644
--- a/docs/wiz/Linux_Rider_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_MSTest_GitHubActions.md b/docs/wiz/Linux_Rider_Cli_MSTest_GitHubActions.md
index 247819ad5..fb7f38e33 100644
--- a/docs/wiz/Linux_Rider_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_MSTest_None.md b/docs/wiz/Linux_Rider_Cli_MSTest_None.md
index 8ff1abd26..f561d8fde 100644
--- a/docs/wiz/Linux_Rider_Cli_MSTest_None.md
+++ b/docs/wiz/Linux_Rider_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_NUnit_AppVeyor.md b/docs/wiz/Linux_Rider_Cli_NUnit_AppVeyor.md
index 8c1c34908..43283fc7a 100644
--- a/docs/wiz/Linux_Rider_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_NUnit_AzureDevOps.md b/docs/wiz/Linux_Rider_Cli_NUnit_AzureDevOps.md
index 5ab471f96..bff33f7a6 100644
--- a/docs/wiz/Linux_Rider_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_NUnit_GitHubActions.md b/docs/wiz/Linux_Rider_Cli_NUnit_GitHubActions.md
index acc9fa5bb..080bf49ba 100644
--- a/docs/wiz/Linux_Rider_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_NUnit_None.md b/docs/wiz/Linux_Rider_Cli_NUnit_None.md
index f47ac46b8..43071675d 100644
--- a/docs/wiz/Linux_Rider_Cli_NUnit_None.md
+++ b/docs/wiz/Linux_Rider_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_TUnit_AppVeyor.md b/docs/wiz/Linux_Rider_Cli_TUnit_AppVeyor.md
index 194530853..fd0e0e6a9 100644
--- a/docs/wiz/Linux_Rider_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_TUnit_AzureDevOps.md b/docs/wiz/Linux_Rider_Cli_TUnit_AzureDevOps.md
index 3bee2c1ea..8bcd904c9 100644
--- a/docs/wiz/Linux_Rider_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_TUnit_GitHubActions.md b/docs/wiz/Linux_Rider_Cli_TUnit_GitHubActions.md
index 388c71a7c..d710401a6 100644
--- a/docs/wiz/Linux_Rider_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_TUnit_None.md b/docs/wiz/Linux_Rider_Cli_TUnit_None.md
index e42e5ab3b..c917c0eab 100644
--- a/docs/wiz/Linux_Rider_Cli_TUnit_None.md
+++ b/docs/wiz/Linux_Rider_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_XunitV3_AppVeyor.md b/docs/wiz/Linux_Rider_Cli_XunitV3_AppVeyor.md
index 8b5ea04b8..20ee23ec0 100644
--- a/docs/wiz/Linux_Rider_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_XunitV3_AzureDevOps.md b/docs/wiz/Linux_Rider_Cli_XunitV3_AzureDevOps.md
index f09aa3ebd..9e4757f86 100644
--- a/docs/wiz/Linux_Rider_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_XunitV3_GitHubActions.md b/docs/wiz/Linux_Rider_Cli_XunitV3_GitHubActions.md
index a61db64e8..13b1c7e3c 100644
--- a/docs/wiz/Linux_Rider_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Cli_XunitV3_None.md b/docs/wiz/Linux_Rider_Cli_XunitV3_None.md
index 2034710ae..69fb85b8d 100644
--- a/docs/wiz/Linux_Rider_Cli_XunitV3_None.md
+++ b/docs/wiz/Linux_Rider_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Expecto_AppVeyor.md b/docs/wiz/Linux_Rider_Gui_Expecto_AppVeyor.md
index 0bdf9aa02..47a774bae 100644
--- a/docs/wiz/Linux_Rider_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Expecto_AzureDevOps.md b/docs/wiz/Linux_Rider_Gui_Expecto_AzureDevOps.md
index 03136cd03..8a5e1d686 100644
--- a/docs/wiz/Linux_Rider_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Expecto_GitHubActions.md b/docs/wiz/Linux_Rider_Gui_Expecto_GitHubActions.md
index ad2288a1c..2d6fe4cef 100644
--- a/docs/wiz/Linux_Rider_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Expecto_None.md b/docs/wiz/Linux_Rider_Gui_Expecto_None.md
index f4f57414f..1fc53d374 100644
--- a/docs/wiz/Linux_Rider_Gui_Expecto_None.md
+++ b/docs/wiz/Linux_Rider_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Fixie_AppVeyor.md b/docs/wiz/Linux_Rider_Gui_Fixie_AppVeyor.md
index 2ba511414..b0e9b1275 100644
--- a/docs/wiz/Linux_Rider_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Fixie_AzureDevOps.md b/docs/wiz/Linux_Rider_Gui_Fixie_AzureDevOps.md
index eeaa03ce0..813d3a40b 100644
--- a/docs/wiz/Linux_Rider_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Fixie_GitHubActions.md b/docs/wiz/Linux_Rider_Gui_Fixie_GitHubActions.md
index 2def88923..0982d4a0e 100644
--- a/docs/wiz/Linux_Rider_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_Fixie_None.md b/docs/wiz/Linux_Rider_Gui_Fixie_None.md
index 14e086115..756edeaff 100644
--- a/docs/wiz/Linux_Rider_Gui_Fixie_None.md
+++ b/docs/wiz/Linux_Rider_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_MSTest_AppVeyor.md b/docs/wiz/Linux_Rider_Gui_MSTest_AppVeyor.md
index 76fd4803a..ace7d620e 100644
--- a/docs/wiz/Linux_Rider_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_MSTest_AzureDevOps.md b/docs/wiz/Linux_Rider_Gui_MSTest_AzureDevOps.md
index d1fe42075..6939044eb 100644
--- a/docs/wiz/Linux_Rider_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_MSTest_GitHubActions.md b/docs/wiz/Linux_Rider_Gui_MSTest_GitHubActions.md
index 218b8e5ae..04a0390f5 100644
--- a/docs/wiz/Linux_Rider_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_MSTest_None.md b/docs/wiz/Linux_Rider_Gui_MSTest_None.md
index 326aa984c..6673af3fa 100644
--- a/docs/wiz/Linux_Rider_Gui_MSTest_None.md
+++ b/docs/wiz/Linux_Rider_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_NUnit_AppVeyor.md b/docs/wiz/Linux_Rider_Gui_NUnit_AppVeyor.md
index 5eb70659c..e1658ed37 100644
--- a/docs/wiz/Linux_Rider_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_NUnit_AzureDevOps.md b/docs/wiz/Linux_Rider_Gui_NUnit_AzureDevOps.md
index 86fae80f2..53089c960 100644
--- a/docs/wiz/Linux_Rider_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_NUnit_GitHubActions.md b/docs/wiz/Linux_Rider_Gui_NUnit_GitHubActions.md
index a1db42b71..2e61cb6f9 100644
--- a/docs/wiz/Linux_Rider_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_NUnit_None.md b/docs/wiz/Linux_Rider_Gui_NUnit_None.md
index 60b55b8c5..eb3d4a0c2 100644
--- a/docs/wiz/Linux_Rider_Gui_NUnit_None.md
+++ b/docs/wiz/Linux_Rider_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_TUnit_AppVeyor.md b/docs/wiz/Linux_Rider_Gui_TUnit_AppVeyor.md
index 3a2cf4c67..ac8927009 100644
--- a/docs/wiz/Linux_Rider_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_TUnit_AzureDevOps.md b/docs/wiz/Linux_Rider_Gui_TUnit_AzureDevOps.md
index 32715247c..69ee49921 100644
--- a/docs/wiz/Linux_Rider_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_TUnit_GitHubActions.md b/docs/wiz/Linux_Rider_Gui_TUnit_GitHubActions.md
index 342aa954c..1e2be9241 100644
--- a/docs/wiz/Linux_Rider_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_TUnit_None.md b/docs/wiz/Linux_Rider_Gui_TUnit_None.md
index ef473865e..38b9e0bb0 100644
--- a/docs/wiz/Linux_Rider_Gui_TUnit_None.md
+++ b/docs/wiz/Linux_Rider_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_XunitV3_AppVeyor.md b/docs/wiz/Linux_Rider_Gui_XunitV3_AppVeyor.md
index 9311367fb..ff7b8e590 100644
--- a/docs/wiz/Linux_Rider_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/Linux_Rider_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_XunitV3_AzureDevOps.md b/docs/wiz/Linux_Rider_Gui_XunitV3_AzureDevOps.md
index 2353fa84d..d6829a29c 100644
--- a/docs/wiz/Linux_Rider_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Linux_Rider_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_XunitV3_GitHubActions.md b/docs/wiz/Linux_Rider_Gui_XunitV3_GitHubActions.md
index cb718c3bc..53a6576ca 100644
--- a/docs/wiz/Linux_Rider_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/Linux_Rider_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Linux_Rider_Gui_XunitV3_None.md b/docs/wiz/Linux_Rider_Gui_XunitV3_None.md
index 8e3541f18..d2b285265 100644
--- a/docs/wiz/Linux_Rider_Gui_XunitV3_None.md
+++ b/docs/wiz/Linux_Rider_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Expecto_AppVeyor.md b/docs/wiz/MacOS_Other_Cli_Expecto_AppVeyor.md
index eeb3c638c..053708f30 100644
--- a/docs/wiz/MacOS_Other_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Expecto_AzureDevOps.md b/docs/wiz/MacOS_Other_Cli_Expecto_AzureDevOps.md
index 518ed3d67..201e01766 100644
--- a/docs/wiz/MacOS_Other_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Expecto_GitHubActions.md b/docs/wiz/MacOS_Other_Cli_Expecto_GitHubActions.md
index d1a2d474b..4da044830 100644
--- a/docs/wiz/MacOS_Other_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Expecto_None.md b/docs/wiz/MacOS_Other_Cli_Expecto_None.md
index c2579b239..c32b537c9 100644
--- a/docs/wiz/MacOS_Other_Cli_Expecto_None.md
+++ b/docs/wiz/MacOS_Other_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Fixie_AppVeyor.md b/docs/wiz/MacOS_Other_Cli_Fixie_AppVeyor.md
index 16672d991..432a32741 100644
--- a/docs/wiz/MacOS_Other_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Fixie_AzureDevOps.md b/docs/wiz/MacOS_Other_Cli_Fixie_AzureDevOps.md
index 7f42bd0c3..d83859486 100644
--- a/docs/wiz/MacOS_Other_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Fixie_GitHubActions.md b/docs/wiz/MacOS_Other_Cli_Fixie_GitHubActions.md
index dd08fc9a8..aafeaf197 100644
--- a/docs/wiz/MacOS_Other_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_Fixie_None.md b/docs/wiz/MacOS_Other_Cli_Fixie_None.md
index ac9afc6c7..d510f5c25 100644
--- a/docs/wiz/MacOS_Other_Cli_Fixie_None.md
+++ b/docs/wiz/MacOS_Other_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_MSTest_AppVeyor.md b/docs/wiz/MacOS_Other_Cli_MSTest_AppVeyor.md
index 2a0ee7209..d72cf4460 100644
--- a/docs/wiz/MacOS_Other_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_MSTest_AzureDevOps.md b/docs/wiz/MacOS_Other_Cli_MSTest_AzureDevOps.md
index aba5757d7..6771c71f1 100644
--- a/docs/wiz/MacOS_Other_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_MSTest_GitHubActions.md b/docs/wiz/MacOS_Other_Cli_MSTest_GitHubActions.md
index 3ae3bb000..4e78eb26c 100644
--- a/docs/wiz/MacOS_Other_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_MSTest_None.md b/docs/wiz/MacOS_Other_Cli_MSTest_None.md
index 2ddb94159..df77bb3e0 100644
--- a/docs/wiz/MacOS_Other_Cli_MSTest_None.md
+++ b/docs/wiz/MacOS_Other_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_NUnit_AppVeyor.md b/docs/wiz/MacOS_Other_Cli_NUnit_AppVeyor.md
index 76b1e1380..05ae8669c 100644
--- a/docs/wiz/MacOS_Other_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_NUnit_AzureDevOps.md b/docs/wiz/MacOS_Other_Cli_NUnit_AzureDevOps.md
index c01b57363..ef4ab5b41 100644
--- a/docs/wiz/MacOS_Other_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_NUnit_GitHubActions.md b/docs/wiz/MacOS_Other_Cli_NUnit_GitHubActions.md
index f91d6030a..b9914ac0c 100644
--- a/docs/wiz/MacOS_Other_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_NUnit_None.md b/docs/wiz/MacOS_Other_Cli_NUnit_None.md
index 5f95d3523..13dce8ebb 100644
--- a/docs/wiz/MacOS_Other_Cli_NUnit_None.md
+++ b/docs/wiz/MacOS_Other_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_TUnit_AppVeyor.md b/docs/wiz/MacOS_Other_Cli_TUnit_AppVeyor.md
index 7591ab7f3..de44763b7 100644
--- a/docs/wiz/MacOS_Other_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_TUnit_AzureDevOps.md b/docs/wiz/MacOS_Other_Cli_TUnit_AzureDevOps.md
index 503072a15..fc797dd24 100644
--- a/docs/wiz/MacOS_Other_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_TUnit_GitHubActions.md b/docs/wiz/MacOS_Other_Cli_TUnit_GitHubActions.md
index 59d5209db..1abd07709 100644
--- a/docs/wiz/MacOS_Other_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_TUnit_None.md b/docs/wiz/MacOS_Other_Cli_TUnit_None.md
index f3f1e0f86..3cc933077 100644
--- a/docs/wiz/MacOS_Other_Cli_TUnit_None.md
+++ b/docs/wiz/MacOS_Other_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_XunitV3_AppVeyor.md b/docs/wiz/MacOS_Other_Cli_XunitV3_AppVeyor.md
index ae26100af..28869871e 100644
--- a/docs/wiz/MacOS_Other_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_XunitV3_AzureDevOps.md b/docs/wiz/MacOS_Other_Cli_XunitV3_AzureDevOps.md
index 9f5014b98..3cd6c6d40 100644
--- a/docs/wiz/MacOS_Other_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_XunitV3_GitHubActions.md b/docs/wiz/MacOS_Other_Cli_XunitV3_GitHubActions.md
index b3265ca21..db1871956 100644
--- a/docs/wiz/MacOS_Other_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Cli_XunitV3_None.md b/docs/wiz/MacOS_Other_Cli_XunitV3_None.md
index aa83ac01b..fe1374376 100644
--- a/docs/wiz/MacOS_Other_Cli_XunitV3_None.md
+++ b/docs/wiz/MacOS_Other_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Expecto_AppVeyor.md b/docs/wiz/MacOS_Other_Gui_Expecto_AppVeyor.md
index 818160d08..0af3966c5 100644
--- a/docs/wiz/MacOS_Other_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Expecto_AzureDevOps.md b/docs/wiz/MacOS_Other_Gui_Expecto_AzureDevOps.md
index 6abe85c93..5f5a8018d 100644
--- a/docs/wiz/MacOS_Other_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Expecto_GitHubActions.md b/docs/wiz/MacOS_Other_Gui_Expecto_GitHubActions.md
index 69029ec85..4274281c6 100644
--- a/docs/wiz/MacOS_Other_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Expecto_None.md b/docs/wiz/MacOS_Other_Gui_Expecto_None.md
index c5e87516c..4fb6cea4d 100644
--- a/docs/wiz/MacOS_Other_Gui_Expecto_None.md
+++ b/docs/wiz/MacOS_Other_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Fixie_AppVeyor.md b/docs/wiz/MacOS_Other_Gui_Fixie_AppVeyor.md
index d6bedbac6..8e6bc974f 100644
--- a/docs/wiz/MacOS_Other_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Fixie_AzureDevOps.md b/docs/wiz/MacOS_Other_Gui_Fixie_AzureDevOps.md
index 893e3df26..3eb822faa 100644
--- a/docs/wiz/MacOS_Other_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Fixie_GitHubActions.md b/docs/wiz/MacOS_Other_Gui_Fixie_GitHubActions.md
index e52534095..cd5b05a68 100644
--- a/docs/wiz/MacOS_Other_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_Fixie_None.md b/docs/wiz/MacOS_Other_Gui_Fixie_None.md
index 63da6931a..937f92bc8 100644
--- a/docs/wiz/MacOS_Other_Gui_Fixie_None.md
+++ b/docs/wiz/MacOS_Other_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_MSTest_AppVeyor.md b/docs/wiz/MacOS_Other_Gui_MSTest_AppVeyor.md
index c0b6c863c..e284a49f7 100644
--- a/docs/wiz/MacOS_Other_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_MSTest_AzureDevOps.md b/docs/wiz/MacOS_Other_Gui_MSTest_AzureDevOps.md
index 38bc1e5a2..aef509edf 100644
--- a/docs/wiz/MacOS_Other_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_MSTest_GitHubActions.md b/docs/wiz/MacOS_Other_Gui_MSTest_GitHubActions.md
index 7ec3fa1ad..561e975a2 100644
--- a/docs/wiz/MacOS_Other_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_MSTest_None.md b/docs/wiz/MacOS_Other_Gui_MSTest_None.md
index 05ae2e938..ea53330d1 100644
--- a/docs/wiz/MacOS_Other_Gui_MSTest_None.md
+++ b/docs/wiz/MacOS_Other_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_NUnit_AppVeyor.md b/docs/wiz/MacOS_Other_Gui_NUnit_AppVeyor.md
index 6585d7b78..c3c76ff11 100644
--- a/docs/wiz/MacOS_Other_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_NUnit_AzureDevOps.md b/docs/wiz/MacOS_Other_Gui_NUnit_AzureDevOps.md
index d0418e9e4..76d17ced2 100644
--- a/docs/wiz/MacOS_Other_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_NUnit_GitHubActions.md b/docs/wiz/MacOS_Other_Gui_NUnit_GitHubActions.md
index 2f5cbe3f7..c9f960744 100644
--- a/docs/wiz/MacOS_Other_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_NUnit_None.md b/docs/wiz/MacOS_Other_Gui_NUnit_None.md
index b7e392022..9fcd589bb 100644
--- a/docs/wiz/MacOS_Other_Gui_NUnit_None.md
+++ b/docs/wiz/MacOS_Other_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_TUnit_AppVeyor.md b/docs/wiz/MacOS_Other_Gui_TUnit_AppVeyor.md
index 5b5ebe65e..d1a89da94 100644
--- a/docs/wiz/MacOS_Other_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_TUnit_AzureDevOps.md b/docs/wiz/MacOS_Other_Gui_TUnit_AzureDevOps.md
index 317118f89..237ca0cb1 100644
--- a/docs/wiz/MacOS_Other_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_TUnit_GitHubActions.md b/docs/wiz/MacOS_Other_Gui_TUnit_GitHubActions.md
index d834f0eb6..d3b8dc16a 100644
--- a/docs/wiz/MacOS_Other_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_TUnit_None.md b/docs/wiz/MacOS_Other_Gui_TUnit_None.md
index b77788615..78023b33a 100644
--- a/docs/wiz/MacOS_Other_Gui_TUnit_None.md
+++ b/docs/wiz/MacOS_Other_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_XunitV3_AppVeyor.md b/docs/wiz/MacOS_Other_Gui_XunitV3_AppVeyor.md
index 5fa179186..312093dcd 100644
--- a/docs/wiz/MacOS_Other_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/MacOS_Other_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_XunitV3_AzureDevOps.md b/docs/wiz/MacOS_Other_Gui_XunitV3_AzureDevOps.md
index 379fc28e8..d2ce82c60 100644
--- a/docs/wiz/MacOS_Other_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/MacOS_Other_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_XunitV3_GitHubActions.md b/docs/wiz/MacOS_Other_Gui_XunitV3_GitHubActions.md
index 27c3df922..88526e07c 100644
--- a/docs/wiz/MacOS_Other_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/MacOS_Other_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Other_Gui_XunitV3_None.md b/docs/wiz/MacOS_Other_Gui_XunitV3_None.md
index 1a66451a3..333587659 100644
--- a/docs/wiz/MacOS_Other_Gui_XunitV3_None.md
+++ b/docs/wiz/MacOS_Other_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Expecto_AppVeyor.md b/docs/wiz/MacOS_Rider_Cli_Expecto_AppVeyor.md
index 826c96736..3680e82f0 100644
--- a/docs/wiz/MacOS_Rider_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Expecto_AzureDevOps.md b/docs/wiz/MacOS_Rider_Cli_Expecto_AzureDevOps.md
index e8ae36974..22b381163 100644
--- a/docs/wiz/MacOS_Rider_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Expecto_GitHubActions.md b/docs/wiz/MacOS_Rider_Cli_Expecto_GitHubActions.md
index 8de344a31..630edd5e0 100644
--- a/docs/wiz/MacOS_Rider_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Expecto_None.md b/docs/wiz/MacOS_Rider_Cli_Expecto_None.md
index 7a65dfb5e..8d1328f1a 100644
--- a/docs/wiz/MacOS_Rider_Cli_Expecto_None.md
+++ b/docs/wiz/MacOS_Rider_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Fixie_AppVeyor.md b/docs/wiz/MacOS_Rider_Cli_Fixie_AppVeyor.md
index a3e9a794f..d3e1a19bd 100644
--- a/docs/wiz/MacOS_Rider_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Fixie_AzureDevOps.md b/docs/wiz/MacOS_Rider_Cli_Fixie_AzureDevOps.md
index 8dbc57356..3bf28ef26 100644
--- a/docs/wiz/MacOS_Rider_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Fixie_GitHubActions.md b/docs/wiz/MacOS_Rider_Cli_Fixie_GitHubActions.md
index 45c96c4b3..6e7708a23 100644
--- a/docs/wiz/MacOS_Rider_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_Fixie_None.md b/docs/wiz/MacOS_Rider_Cli_Fixie_None.md
index 5218d7a25..e3f3416d9 100644
--- a/docs/wiz/MacOS_Rider_Cli_Fixie_None.md
+++ b/docs/wiz/MacOS_Rider_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_MSTest_AppVeyor.md b/docs/wiz/MacOS_Rider_Cli_MSTest_AppVeyor.md
index 285d44559..910e7e907 100644
--- a/docs/wiz/MacOS_Rider_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_MSTest_AzureDevOps.md b/docs/wiz/MacOS_Rider_Cli_MSTest_AzureDevOps.md
index 2abd10297..b25dd53ec 100644
--- a/docs/wiz/MacOS_Rider_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_MSTest_GitHubActions.md b/docs/wiz/MacOS_Rider_Cli_MSTest_GitHubActions.md
index 0050e5c61..0a34d0645 100644
--- a/docs/wiz/MacOS_Rider_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_MSTest_None.md b/docs/wiz/MacOS_Rider_Cli_MSTest_None.md
index e0e00bc86..3ce7eb924 100644
--- a/docs/wiz/MacOS_Rider_Cli_MSTest_None.md
+++ b/docs/wiz/MacOS_Rider_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_NUnit_AppVeyor.md b/docs/wiz/MacOS_Rider_Cli_NUnit_AppVeyor.md
index 87b82c512..2a47761c7 100644
--- a/docs/wiz/MacOS_Rider_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_NUnit_AzureDevOps.md b/docs/wiz/MacOS_Rider_Cli_NUnit_AzureDevOps.md
index 3350b8558..3302ff841 100644
--- a/docs/wiz/MacOS_Rider_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_NUnit_GitHubActions.md b/docs/wiz/MacOS_Rider_Cli_NUnit_GitHubActions.md
index 9d9087e66..a127c92a2 100644
--- a/docs/wiz/MacOS_Rider_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_NUnit_None.md b/docs/wiz/MacOS_Rider_Cli_NUnit_None.md
index b0a8ce8c2..762efeaa9 100644
--- a/docs/wiz/MacOS_Rider_Cli_NUnit_None.md
+++ b/docs/wiz/MacOS_Rider_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_TUnit_AppVeyor.md b/docs/wiz/MacOS_Rider_Cli_TUnit_AppVeyor.md
index d7b7bf252..4a47ddf47 100644
--- a/docs/wiz/MacOS_Rider_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_TUnit_AzureDevOps.md b/docs/wiz/MacOS_Rider_Cli_TUnit_AzureDevOps.md
index 83a2797bd..7ffe17b41 100644
--- a/docs/wiz/MacOS_Rider_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_TUnit_GitHubActions.md b/docs/wiz/MacOS_Rider_Cli_TUnit_GitHubActions.md
index 3c3eb8d8b..877d794cc 100644
--- a/docs/wiz/MacOS_Rider_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_TUnit_None.md b/docs/wiz/MacOS_Rider_Cli_TUnit_None.md
index 83a52fdde..ceb2ad217 100644
--- a/docs/wiz/MacOS_Rider_Cli_TUnit_None.md
+++ b/docs/wiz/MacOS_Rider_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_XunitV3_AppVeyor.md b/docs/wiz/MacOS_Rider_Cli_XunitV3_AppVeyor.md
index 14268be11..709183048 100644
--- a/docs/wiz/MacOS_Rider_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_XunitV3_AzureDevOps.md b/docs/wiz/MacOS_Rider_Cli_XunitV3_AzureDevOps.md
index c1228fd97..93ea5bb73 100644
--- a/docs/wiz/MacOS_Rider_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_XunitV3_GitHubActions.md b/docs/wiz/MacOS_Rider_Cli_XunitV3_GitHubActions.md
index e5941d28b..2de37b274 100644
--- a/docs/wiz/MacOS_Rider_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Cli_XunitV3_None.md b/docs/wiz/MacOS_Rider_Cli_XunitV3_None.md
index 0c78bef22..650c5721f 100644
--- a/docs/wiz/MacOS_Rider_Cli_XunitV3_None.md
+++ b/docs/wiz/MacOS_Rider_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Expecto_AppVeyor.md b/docs/wiz/MacOS_Rider_Gui_Expecto_AppVeyor.md
index 6db758256..d3872e52a 100644
--- a/docs/wiz/MacOS_Rider_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Expecto_AzureDevOps.md b/docs/wiz/MacOS_Rider_Gui_Expecto_AzureDevOps.md
index 27651820d..13ca80f4b 100644
--- a/docs/wiz/MacOS_Rider_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Expecto_GitHubActions.md b/docs/wiz/MacOS_Rider_Gui_Expecto_GitHubActions.md
index 299a53334..c86e8574e 100644
--- a/docs/wiz/MacOS_Rider_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Expecto_None.md b/docs/wiz/MacOS_Rider_Gui_Expecto_None.md
index 5ae283ba8..f9b6ef420 100644
--- a/docs/wiz/MacOS_Rider_Gui_Expecto_None.md
+++ b/docs/wiz/MacOS_Rider_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Fixie_AppVeyor.md b/docs/wiz/MacOS_Rider_Gui_Fixie_AppVeyor.md
index 87cbd285e..c26d2b79b 100644
--- a/docs/wiz/MacOS_Rider_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Fixie_AzureDevOps.md b/docs/wiz/MacOS_Rider_Gui_Fixie_AzureDevOps.md
index 97bf5d679..ce52bf27d 100644
--- a/docs/wiz/MacOS_Rider_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Fixie_GitHubActions.md b/docs/wiz/MacOS_Rider_Gui_Fixie_GitHubActions.md
index b5fa750d7..43b8fd751 100644
--- a/docs/wiz/MacOS_Rider_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_Fixie_None.md b/docs/wiz/MacOS_Rider_Gui_Fixie_None.md
index 9a20d8627..d2f624e5b 100644
--- a/docs/wiz/MacOS_Rider_Gui_Fixie_None.md
+++ b/docs/wiz/MacOS_Rider_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_MSTest_AppVeyor.md b/docs/wiz/MacOS_Rider_Gui_MSTest_AppVeyor.md
index 366d259b8..b7f6cd3c2 100644
--- a/docs/wiz/MacOS_Rider_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_MSTest_AzureDevOps.md b/docs/wiz/MacOS_Rider_Gui_MSTest_AzureDevOps.md
index ed86b1a97..2085a9f79 100644
--- a/docs/wiz/MacOS_Rider_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_MSTest_GitHubActions.md b/docs/wiz/MacOS_Rider_Gui_MSTest_GitHubActions.md
index 0ad38c612..810c1b27d 100644
--- a/docs/wiz/MacOS_Rider_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_MSTest_None.md b/docs/wiz/MacOS_Rider_Gui_MSTest_None.md
index 2864481bd..50d5f9c40 100644
--- a/docs/wiz/MacOS_Rider_Gui_MSTest_None.md
+++ b/docs/wiz/MacOS_Rider_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_NUnit_AppVeyor.md b/docs/wiz/MacOS_Rider_Gui_NUnit_AppVeyor.md
index 924c315a1..a23483dc5 100644
--- a/docs/wiz/MacOS_Rider_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_NUnit_AzureDevOps.md b/docs/wiz/MacOS_Rider_Gui_NUnit_AzureDevOps.md
index 6496fa296..d627c29cc 100644
--- a/docs/wiz/MacOS_Rider_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_NUnit_GitHubActions.md b/docs/wiz/MacOS_Rider_Gui_NUnit_GitHubActions.md
index 006fbbf53..66f303d79 100644
--- a/docs/wiz/MacOS_Rider_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_NUnit_None.md b/docs/wiz/MacOS_Rider_Gui_NUnit_None.md
index 6a699b89a..a0190f4db 100644
--- a/docs/wiz/MacOS_Rider_Gui_NUnit_None.md
+++ b/docs/wiz/MacOS_Rider_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_TUnit_AppVeyor.md b/docs/wiz/MacOS_Rider_Gui_TUnit_AppVeyor.md
index d11c80835..8d5d3bb4b 100644
--- a/docs/wiz/MacOS_Rider_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_TUnit_AzureDevOps.md b/docs/wiz/MacOS_Rider_Gui_TUnit_AzureDevOps.md
index b395170d4..3f7e633b2 100644
--- a/docs/wiz/MacOS_Rider_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_TUnit_GitHubActions.md b/docs/wiz/MacOS_Rider_Gui_TUnit_GitHubActions.md
index bfc025989..7dbb81b5f 100644
--- a/docs/wiz/MacOS_Rider_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_TUnit_None.md b/docs/wiz/MacOS_Rider_Gui_TUnit_None.md
index b3f33f4d5..ca9813101 100644
--- a/docs/wiz/MacOS_Rider_Gui_TUnit_None.md
+++ b/docs/wiz/MacOS_Rider_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_XunitV3_AppVeyor.md b/docs/wiz/MacOS_Rider_Gui_XunitV3_AppVeyor.md
index 6bce03480..baa5f6215 100644
--- a/docs/wiz/MacOS_Rider_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/MacOS_Rider_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_XunitV3_AzureDevOps.md b/docs/wiz/MacOS_Rider_Gui_XunitV3_AzureDevOps.md
index 6acb859b1..6297e2871 100644
--- a/docs/wiz/MacOS_Rider_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/MacOS_Rider_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_XunitV3_GitHubActions.md b/docs/wiz/MacOS_Rider_Gui_XunitV3_GitHubActions.md
index 064844433..18eed8f01 100644
--- a/docs/wiz/MacOS_Rider_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/MacOS_Rider_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/MacOS_Rider_Gui_XunitV3_None.md b/docs/wiz/MacOS_Rider_Gui_XunitV3_None.md
index 0f2f44444..cf5e80735 100644
--- a/docs/wiz/MacOS_Rider_Gui_XunitV3_None.md
+++ b/docs/wiz/MacOS_Rider_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Expecto_AppVeyor.md b/docs/wiz/Windows_Other_Cli_Expecto_AppVeyor.md
index aebe54a27..c0528eb6d 100644
--- a/docs/wiz/Windows_Other_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Expecto_AzureDevOps.md b/docs/wiz/Windows_Other_Cli_Expecto_AzureDevOps.md
index 3f4e0fbc2..b54de169f 100644
--- a/docs/wiz/Windows_Other_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Expecto_GitHubActions.md b/docs/wiz/Windows_Other_Cli_Expecto_GitHubActions.md
index 3b01fde6b..2d79de959 100644
--- a/docs/wiz/Windows_Other_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Expecto_None.md b/docs/wiz/Windows_Other_Cli_Expecto_None.md
index 7bc1a685f..587975d65 100644
--- a/docs/wiz/Windows_Other_Cli_Expecto_None.md
+++ b/docs/wiz/Windows_Other_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Fixie_AppVeyor.md b/docs/wiz/Windows_Other_Cli_Fixie_AppVeyor.md
index b4be07139..d4961ff91 100644
--- a/docs/wiz/Windows_Other_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Fixie_AzureDevOps.md b/docs/wiz/Windows_Other_Cli_Fixie_AzureDevOps.md
index c875ddb2a..3f5ae839d 100644
--- a/docs/wiz/Windows_Other_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Fixie_GitHubActions.md b/docs/wiz/Windows_Other_Cli_Fixie_GitHubActions.md
index 9cbeca73d..1ea185b82 100644
--- a/docs/wiz/Windows_Other_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_Fixie_None.md b/docs/wiz/Windows_Other_Cli_Fixie_None.md
index 4a770e5b9..b65213da5 100644
--- a/docs/wiz/Windows_Other_Cli_Fixie_None.md
+++ b/docs/wiz/Windows_Other_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_MSTest_AppVeyor.md b/docs/wiz/Windows_Other_Cli_MSTest_AppVeyor.md
index 1a07cc465..1e28b8652 100644
--- a/docs/wiz/Windows_Other_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_MSTest_AzureDevOps.md b/docs/wiz/Windows_Other_Cli_MSTest_AzureDevOps.md
index 049459cfb..2eebf0832 100644
--- a/docs/wiz/Windows_Other_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_MSTest_GitHubActions.md b/docs/wiz/Windows_Other_Cli_MSTest_GitHubActions.md
index 73fd1c8e0..263d350e2 100644
--- a/docs/wiz/Windows_Other_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_MSTest_None.md b/docs/wiz/Windows_Other_Cli_MSTest_None.md
index 158bdb984..bdb19441d 100644
--- a/docs/wiz/Windows_Other_Cli_MSTest_None.md
+++ b/docs/wiz/Windows_Other_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_NUnit_AppVeyor.md b/docs/wiz/Windows_Other_Cli_NUnit_AppVeyor.md
index a457307c2..b0c36d021 100644
--- a/docs/wiz/Windows_Other_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_NUnit_AzureDevOps.md b/docs/wiz/Windows_Other_Cli_NUnit_AzureDevOps.md
index 58e4ed72d..24eb6f6db 100644
--- a/docs/wiz/Windows_Other_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_NUnit_GitHubActions.md b/docs/wiz/Windows_Other_Cli_NUnit_GitHubActions.md
index 4a5f6bce7..397e67496 100644
--- a/docs/wiz/Windows_Other_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_NUnit_None.md b/docs/wiz/Windows_Other_Cli_NUnit_None.md
index f2738f1ea..790fe721e 100644
--- a/docs/wiz/Windows_Other_Cli_NUnit_None.md
+++ b/docs/wiz/Windows_Other_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_TUnit_AppVeyor.md b/docs/wiz/Windows_Other_Cli_TUnit_AppVeyor.md
index c0ca4528f..b3a02d59e 100644
--- a/docs/wiz/Windows_Other_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_TUnit_AzureDevOps.md b/docs/wiz/Windows_Other_Cli_TUnit_AzureDevOps.md
index 866540ded..daac17de0 100644
--- a/docs/wiz/Windows_Other_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_TUnit_GitHubActions.md b/docs/wiz/Windows_Other_Cli_TUnit_GitHubActions.md
index cbc3af040..4ee2da231 100644
--- a/docs/wiz/Windows_Other_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_TUnit_None.md b/docs/wiz/Windows_Other_Cli_TUnit_None.md
index ad8f91c57..78e0e7fc2 100644
--- a/docs/wiz/Windows_Other_Cli_TUnit_None.md
+++ b/docs/wiz/Windows_Other_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_XunitV3_AppVeyor.md b/docs/wiz/Windows_Other_Cli_XunitV3_AppVeyor.md
index 14ee1edac..3954b9c10 100644
--- a/docs/wiz/Windows_Other_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_XunitV3_AzureDevOps.md b/docs/wiz/Windows_Other_Cli_XunitV3_AzureDevOps.md
index 44662fac5..21b9994b5 100644
--- a/docs/wiz/Windows_Other_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_XunitV3_GitHubActions.md b/docs/wiz/Windows_Other_Cli_XunitV3_GitHubActions.md
index 384f5cee6..8644459ae 100644
--- a/docs/wiz/Windows_Other_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Cli_XunitV3_None.md b/docs/wiz/Windows_Other_Cli_XunitV3_None.md
index c8690cacf..34d3fc534 100644
--- a/docs/wiz/Windows_Other_Cli_XunitV3_None.md
+++ b/docs/wiz/Windows_Other_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Expecto_AppVeyor.md b/docs/wiz/Windows_Other_Gui_Expecto_AppVeyor.md
index 84afcc440..98057d669 100644
--- a/docs/wiz/Windows_Other_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Expecto_AzureDevOps.md b/docs/wiz/Windows_Other_Gui_Expecto_AzureDevOps.md
index 99be4da9a..2682878d4 100644
--- a/docs/wiz/Windows_Other_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Expecto_GitHubActions.md b/docs/wiz/Windows_Other_Gui_Expecto_GitHubActions.md
index 1f0bb7dd6..142be6ef4 100644
--- a/docs/wiz/Windows_Other_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Expecto_None.md b/docs/wiz/Windows_Other_Gui_Expecto_None.md
index 7628c97e6..b034cd232 100644
--- a/docs/wiz/Windows_Other_Gui_Expecto_None.md
+++ b/docs/wiz/Windows_Other_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Fixie_AppVeyor.md b/docs/wiz/Windows_Other_Gui_Fixie_AppVeyor.md
index d6a6805f7..7a4d74aab 100644
--- a/docs/wiz/Windows_Other_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Fixie_AzureDevOps.md b/docs/wiz/Windows_Other_Gui_Fixie_AzureDevOps.md
index 8117f9db9..0085cf11a 100644
--- a/docs/wiz/Windows_Other_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Fixie_GitHubActions.md b/docs/wiz/Windows_Other_Gui_Fixie_GitHubActions.md
index 2bb27c9ba..f842982c6 100644
--- a/docs/wiz/Windows_Other_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_Fixie_None.md b/docs/wiz/Windows_Other_Gui_Fixie_None.md
index a2f8b992a..3cc44e37e 100644
--- a/docs/wiz/Windows_Other_Gui_Fixie_None.md
+++ b/docs/wiz/Windows_Other_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_MSTest_AppVeyor.md b/docs/wiz/Windows_Other_Gui_MSTest_AppVeyor.md
index 1c3f11116..68971f92e 100644
--- a/docs/wiz/Windows_Other_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_MSTest_AzureDevOps.md b/docs/wiz/Windows_Other_Gui_MSTest_AzureDevOps.md
index 1ea29ad16..136ee468a 100644
--- a/docs/wiz/Windows_Other_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_MSTest_GitHubActions.md b/docs/wiz/Windows_Other_Gui_MSTest_GitHubActions.md
index f3fab8581..587015af9 100644
--- a/docs/wiz/Windows_Other_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_MSTest_None.md b/docs/wiz/Windows_Other_Gui_MSTest_None.md
index 3d2285bd1..72886e840 100644
--- a/docs/wiz/Windows_Other_Gui_MSTest_None.md
+++ b/docs/wiz/Windows_Other_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_NUnit_AppVeyor.md b/docs/wiz/Windows_Other_Gui_NUnit_AppVeyor.md
index 6222aa30b..746a600f9 100644
--- a/docs/wiz/Windows_Other_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_NUnit_AzureDevOps.md b/docs/wiz/Windows_Other_Gui_NUnit_AzureDevOps.md
index 112e825eb..bce0bd7b0 100644
--- a/docs/wiz/Windows_Other_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_NUnit_GitHubActions.md b/docs/wiz/Windows_Other_Gui_NUnit_GitHubActions.md
index d36178da6..05f9fd356 100644
--- a/docs/wiz/Windows_Other_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_NUnit_None.md b/docs/wiz/Windows_Other_Gui_NUnit_None.md
index 8eb9b1c58..034854c9a 100644
--- a/docs/wiz/Windows_Other_Gui_NUnit_None.md
+++ b/docs/wiz/Windows_Other_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_TUnit_AppVeyor.md b/docs/wiz/Windows_Other_Gui_TUnit_AppVeyor.md
index afad7ba9c..0b00d4a7e 100644
--- a/docs/wiz/Windows_Other_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_TUnit_AzureDevOps.md b/docs/wiz/Windows_Other_Gui_TUnit_AzureDevOps.md
index 59b27d971..5468eee25 100644
--- a/docs/wiz/Windows_Other_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_TUnit_GitHubActions.md b/docs/wiz/Windows_Other_Gui_TUnit_GitHubActions.md
index 1a5a72979..e9f6994e0 100644
--- a/docs/wiz/Windows_Other_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_TUnit_None.md b/docs/wiz/Windows_Other_Gui_TUnit_None.md
index 2d71d98e9..9ba87021a 100644
--- a/docs/wiz/Windows_Other_Gui_TUnit_None.md
+++ b/docs/wiz/Windows_Other_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_XunitV3_AppVeyor.md b/docs/wiz/Windows_Other_Gui_XunitV3_AppVeyor.md
index 3d0a1cc48..fbdd4ef7a 100644
--- a/docs/wiz/Windows_Other_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_Other_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_XunitV3_AzureDevOps.md b/docs/wiz/Windows_Other_Gui_XunitV3_AzureDevOps.md
index fb8a8ed1c..af7f6da5b 100644
--- a/docs/wiz/Windows_Other_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_Other_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_XunitV3_GitHubActions.md b/docs/wiz/Windows_Other_Gui_XunitV3_GitHubActions.md
index 83c762bc9..845569f50 100644
--- a/docs/wiz/Windows_Other_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_Other_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Other_Gui_XunitV3_None.md b/docs/wiz/Windows_Other_Gui_XunitV3_None.md
index ee4138264..9c8522e4b 100644
--- a/docs/wiz/Windows_Other_Gui_XunitV3_None.md
+++ b/docs/wiz/Windows_Other_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Expecto_AppVeyor.md b/docs/wiz/Windows_Rider_Cli_Expecto_AppVeyor.md
index 4b16d17ab..579ae36c8 100644
--- a/docs/wiz/Windows_Rider_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Expecto_AzureDevOps.md b/docs/wiz/Windows_Rider_Cli_Expecto_AzureDevOps.md
index 295c6f619..16b0ca1f3 100644
--- a/docs/wiz/Windows_Rider_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Expecto_GitHubActions.md b/docs/wiz/Windows_Rider_Cli_Expecto_GitHubActions.md
index d98b7124b..08b4ef9d8 100644
--- a/docs/wiz/Windows_Rider_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Expecto_None.md b/docs/wiz/Windows_Rider_Cli_Expecto_None.md
index f63dfe8b3..74eafaaca 100644
--- a/docs/wiz/Windows_Rider_Cli_Expecto_None.md
+++ b/docs/wiz/Windows_Rider_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Fixie_AppVeyor.md b/docs/wiz/Windows_Rider_Cli_Fixie_AppVeyor.md
index 339e5b913..1f4f9c7f0 100644
--- a/docs/wiz/Windows_Rider_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Fixie_AzureDevOps.md b/docs/wiz/Windows_Rider_Cli_Fixie_AzureDevOps.md
index 1efb54055..cc94fba3f 100644
--- a/docs/wiz/Windows_Rider_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Fixie_GitHubActions.md b/docs/wiz/Windows_Rider_Cli_Fixie_GitHubActions.md
index b89d3d206..bc6b87b05 100644
--- a/docs/wiz/Windows_Rider_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_Fixie_None.md b/docs/wiz/Windows_Rider_Cli_Fixie_None.md
index 63e17450f..86219a99e 100644
--- a/docs/wiz/Windows_Rider_Cli_Fixie_None.md
+++ b/docs/wiz/Windows_Rider_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_MSTest_AppVeyor.md b/docs/wiz/Windows_Rider_Cli_MSTest_AppVeyor.md
index 7614ed6ec..f08396a2b 100644
--- a/docs/wiz/Windows_Rider_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_MSTest_AzureDevOps.md b/docs/wiz/Windows_Rider_Cli_MSTest_AzureDevOps.md
index aa5c2cbff..5ec953731 100644
--- a/docs/wiz/Windows_Rider_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_MSTest_GitHubActions.md b/docs/wiz/Windows_Rider_Cli_MSTest_GitHubActions.md
index 7844db698..eacb21469 100644
--- a/docs/wiz/Windows_Rider_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_MSTest_None.md b/docs/wiz/Windows_Rider_Cli_MSTest_None.md
index 732feda40..bf4f89d1c 100644
--- a/docs/wiz/Windows_Rider_Cli_MSTest_None.md
+++ b/docs/wiz/Windows_Rider_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_NUnit_AppVeyor.md b/docs/wiz/Windows_Rider_Cli_NUnit_AppVeyor.md
index 1a6467b32..c93319ff9 100644
--- a/docs/wiz/Windows_Rider_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_NUnit_AzureDevOps.md b/docs/wiz/Windows_Rider_Cli_NUnit_AzureDevOps.md
index c2688ba07..1b98515c9 100644
--- a/docs/wiz/Windows_Rider_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_NUnit_GitHubActions.md b/docs/wiz/Windows_Rider_Cli_NUnit_GitHubActions.md
index faffa7b10..ad2b77a27 100644
--- a/docs/wiz/Windows_Rider_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_NUnit_None.md b/docs/wiz/Windows_Rider_Cli_NUnit_None.md
index 3a0e2e5fd..0f8d58697 100644
--- a/docs/wiz/Windows_Rider_Cli_NUnit_None.md
+++ b/docs/wiz/Windows_Rider_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_TUnit_AppVeyor.md b/docs/wiz/Windows_Rider_Cli_TUnit_AppVeyor.md
index 60c0a2aeb..68d48a3b9 100644
--- a/docs/wiz/Windows_Rider_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_TUnit_AzureDevOps.md b/docs/wiz/Windows_Rider_Cli_TUnit_AzureDevOps.md
index d61baa8f1..3171da04e 100644
--- a/docs/wiz/Windows_Rider_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_TUnit_GitHubActions.md b/docs/wiz/Windows_Rider_Cli_TUnit_GitHubActions.md
index 0b571ede0..70322e67d 100644
--- a/docs/wiz/Windows_Rider_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_TUnit_None.md b/docs/wiz/Windows_Rider_Cli_TUnit_None.md
index 00755dcae..a6f9dbc72 100644
--- a/docs/wiz/Windows_Rider_Cli_TUnit_None.md
+++ b/docs/wiz/Windows_Rider_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_XunitV3_AppVeyor.md b/docs/wiz/Windows_Rider_Cli_XunitV3_AppVeyor.md
index 39921fb13..0928d8cef 100644
--- a/docs/wiz/Windows_Rider_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_XunitV3_AzureDevOps.md b/docs/wiz/Windows_Rider_Cli_XunitV3_AzureDevOps.md
index 692b45551..6280f465e 100644
--- a/docs/wiz/Windows_Rider_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_XunitV3_GitHubActions.md b/docs/wiz/Windows_Rider_Cli_XunitV3_GitHubActions.md
index 8dd7a71c2..266ef3ba3 100644
--- a/docs/wiz/Windows_Rider_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Cli_XunitV3_None.md b/docs/wiz/Windows_Rider_Cli_XunitV3_None.md
index 6cd81636a..8818e0559 100644
--- a/docs/wiz/Windows_Rider_Cli_XunitV3_None.md
+++ b/docs/wiz/Windows_Rider_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Expecto_AppVeyor.md b/docs/wiz/Windows_Rider_Gui_Expecto_AppVeyor.md
index 17c03c1c9..434da6f6d 100644
--- a/docs/wiz/Windows_Rider_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Expecto_AzureDevOps.md b/docs/wiz/Windows_Rider_Gui_Expecto_AzureDevOps.md
index c56d506b9..7a135b638 100644
--- a/docs/wiz/Windows_Rider_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Expecto_GitHubActions.md b/docs/wiz/Windows_Rider_Gui_Expecto_GitHubActions.md
index cd3570deb..327d4a191 100644
--- a/docs/wiz/Windows_Rider_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Expecto_None.md b/docs/wiz/Windows_Rider_Gui_Expecto_None.md
index ffeaaf51e..6db69ea2d 100644
--- a/docs/wiz/Windows_Rider_Gui_Expecto_None.md
+++ b/docs/wiz/Windows_Rider_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Fixie_AppVeyor.md b/docs/wiz/Windows_Rider_Gui_Fixie_AppVeyor.md
index 85faa38c0..71bc7803a 100644
--- a/docs/wiz/Windows_Rider_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Fixie_AzureDevOps.md b/docs/wiz/Windows_Rider_Gui_Fixie_AzureDevOps.md
index 299272ee2..31de7b59b 100644
--- a/docs/wiz/Windows_Rider_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Fixie_GitHubActions.md b/docs/wiz/Windows_Rider_Gui_Fixie_GitHubActions.md
index 443915a58..c9827e84f 100644
--- a/docs/wiz/Windows_Rider_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_Fixie_None.md b/docs/wiz/Windows_Rider_Gui_Fixie_None.md
index 5aa340f51..a6d99ba29 100644
--- a/docs/wiz/Windows_Rider_Gui_Fixie_None.md
+++ b/docs/wiz/Windows_Rider_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_MSTest_AppVeyor.md b/docs/wiz/Windows_Rider_Gui_MSTest_AppVeyor.md
index b54ab643c..671aa8f89 100644
--- a/docs/wiz/Windows_Rider_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_MSTest_AzureDevOps.md b/docs/wiz/Windows_Rider_Gui_MSTest_AzureDevOps.md
index 9d07a401e..b67ce69ea 100644
--- a/docs/wiz/Windows_Rider_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_MSTest_GitHubActions.md b/docs/wiz/Windows_Rider_Gui_MSTest_GitHubActions.md
index 0b688a40c..42f94b0e6 100644
--- a/docs/wiz/Windows_Rider_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_MSTest_None.md b/docs/wiz/Windows_Rider_Gui_MSTest_None.md
index 94a8190c7..2803e7059 100644
--- a/docs/wiz/Windows_Rider_Gui_MSTest_None.md
+++ b/docs/wiz/Windows_Rider_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_NUnit_AppVeyor.md b/docs/wiz/Windows_Rider_Gui_NUnit_AppVeyor.md
index ea7e0783b..1f363a0bc 100644
--- a/docs/wiz/Windows_Rider_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_NUnit_AzureDevOps.md b/docs/wiz/Windows_Rider_Gui_NUnit_AzureDevOps.md
index 15dceb51d..17f5d040d 100644
--- a/docs/wiz/Windows_Rider_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_NUnit_GitHubActions.md b/docs/wiz/Windows_Rider_Gui_NUnit_GitHubActions.md
index f111f11e9..bf355457f 100644
--- a/docs/wiz/Windows_Rider_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_NUnit_None.md b/docs/wiz/Windows_Rider_Gui_NUnit_None.md
index 4ebc3f5ac..5e8811cad 100644
--- a/docs/wiz/Windows_Rider_Gui_NUnit_None.md
+++ b/docs/wiz/Windows_Rider_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_TUnit_AppVeyor.md b/docs/wiz/Windows_Rider_Gui_TUnit_AppVeyor.md
index 7dcb097c2..9bc8f9d3a 100644
--- a/docs/wiz/Windows_Rider_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_TUnit_AzureDevOps.md b/docs/wiz/Windows_Rider_Gui_TUnit_AzureDevOps.md
index 8334ef4b6..26dfc8952 100644
--- a/docs/wiz/Windows_Rider_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_TUnit_GitHubActions.md b/docs/wiz/Windows_Rider_Gui_TUnit_GitHubActions.md
index 885961fd2..576ec8f2b 100644
--- a/docs/wiz/Windows_Rider_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_TUnit_None.md b/docs/wiz/Windows_Rider_Gui_TUnit_None.md
index b846174c5..94b0a166f 100644
--- a/docs/wiz/Windows_Rider_Gui_TUnit_None.md
+++ b/docs/wiz/Windows_Rider_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_XunitV3_AppVeyor.md b/docs/wiz/Windows_Rider_Gui_XunitV3_AppVeyor.md
index ed547e468..99a9858ec 100644
--- a/docs/wiz/Windows_Rider_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_Rider_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_XunitV3_AzureDevOps.md b/docs/wiz/Windows_Rider_Gui_XunitV3_AzureDevOps.md
index b40616f21..400235312 100644
--- a/docs/wiz/Windows_Rider_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_Rider_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_XunitV3_GitHubActions.md b/docs/wiz/Windows_Rider_Gui_XunitV3_GitHubActions.md
index 81e6249a0..8a200db0d 100644
--- a/docs/wiz/Windows_Rider_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_Rider_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_Rider_Gui_XunitV3_None.md b/docs/wiz/Windows_Rider_Gui_XunitV3_None.md
index 012edce42..88a618361 100644
--- a/docs/wiz/Windows_Rider_Gui_XunitV3_None.md
+++ b/docs/wiz/Windows_Rider_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AppVeyor.md
index 5664f0882..1089c5934 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AzureDevOps.md
index b038c2c7a..2bf77fb61 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_GitHubActions.md
index a17b19312..cd29f3736 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_None.md
index a7904ba16..1693d6e2a 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AppVeyor.md
index 1e508d2c4..0804f216c 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AzureDevOps.md
index 373380eee..3e53db18c 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_GitHubActions.md
index 1896cf0a0..9379bc5e3 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_None.md
index 72e104c72..21e125e67 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AppVeyor.md
index 2c0364921..5687b153f 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AzureDevOps.md
index c78abb6f5..a95525fae 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_GitHubActions.md
index e9bd7ddca..a587fd10c 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_None.md
index cdb436f13..5c5fd5478 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AppVeyor.md
index d89743f58..704cd20b1 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AzureDevOps.md
index 9659366f9..7749daa2b 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_GitHubActions.md
index 1c1bf53ff..6710cca29 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_None.md
index b3fdce1c9..c624d3e63 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AppVeyor.md
index d865d46af..4630042f8 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AzureDevOps.md
index 6df918637..d4c82454d 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_GitHubActions.md
index ba1cb8450..405ee032f 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_None.md
index 6bc097563..af425e18a 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AppVeyor.md
index b4c396a7d..93002ca35 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AzureDevOps.md
index c59048988..86b147356 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_GitHubActions.md
index b10e407e5..66eab7d23 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_None.md
index babfdffd5..6701c274b 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AppVeyor.md
index 31af60409..355fec2a6 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AzureDevOps.md
index 1d33b6bd1..11a43f47d 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_GitHubActions.md
index c5f519a52..77b9e1b01 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_None.md
index 9b1381080..ccd488f30 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AppVeyor.md
index 7174718d9..d56aafca9 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AzureDevOps.md
index 3d3ac54cf..7917c1002 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_GitHubActions.md
index c8de2c6a6..ceecdc622 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_None.md
index 39cc10880..002b24149 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AppVeyor.md
index 91bf58ede..8a68c281d 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AzureDevOps.md
index 5e06ee0fd..0f76175eb 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_GitHubActions.md
index f4f5243d1..677fc308c 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_None.md
index 7dcc7ee66..5171add4a 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AppVeyor.md
index a2be7c011..556246650 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AzureDevOps.md
index 7f6ad2022..e480b92ff 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_GitHubActions.md
index 8723e1ea8..1ade42cb8 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_None.md
index 41c435190..74c4a01d5 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AppVeyor.md
index 62cfd39c0..dd31ceda3 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AzureDevOps.md
index 4d5eb7366..2f0e3d0c3 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_GitHubActions.md
index ad8ce9c42..f586b3a20 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_None.md
index fe9e9c94d..ecea0f818 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AppVeyor.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AppVeyor.md
index fd7dc776a..95beecf7d 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AzureDevOps.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AzureDevOps.md
index f3cd45c53..d5be877d4 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_GitHubActions.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_GitHubActions.md
index 33e0fe130..12bd34b32 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_None.md b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_None.md
index 49ab4be5d..95c8f21c6 100644
--- a/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_None.md
+++ b/docs/wiz/Windows_VisualStudioWithReSharper_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Expecto_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Cli_Expecto_AppVeyor.md
index 4609680eb..cffd6888e 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Expecto_AppVeyor.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Expecto_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Cli_Expecto_AzureDevOps.md
index 2852349c3..3a30f7da1 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Expecto_AzureDevOps.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Expecto_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Cli_Expecto_GitHubActions.md
index 9026f7a3a..ed2f98be1 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Expecto_GitHubActions.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Expecto_None.md b/docs/wiz/Windows_VisualStudio_Cli_Expecto_None.md
index 239cd4045..aae052916 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Expecto_None.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Expecto_None.md
@@ -134,7 +134,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Fixie_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Cli_Fixie_AppVeyor.md
index b8eddeb57..2fa7d139d 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Fixie_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Fixie_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Cli_Fixie_AzureDevOps.md
index 4c259ff3a..3f0139e3f 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Fixie_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Fixie_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Cli_Fixie_GitHubActions.md
index 6aaa20465..79f6d8e3e 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Fixie_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_Fixie_None.md b/docs/wiz/Windows_VisualStudio_Cli_Fixie_None.md
index 0c19debdd..8e8b12a47 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_Fixie_None.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_Fixie_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_MSTest_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Cli_MSTest_AppVeyor.md
index e03eaedf8..84144f1b8 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_MSTest_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_MSTest_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Cli_MSTest_AzureDevOps.md
index 69e95f613..773a232d9 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_MSTest_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_MSTest_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Cli_MSTest_GitHubActions.md
index 4e1c087f2..703e33d06 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_MSTest_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_MSTest_None.md b/docs/wiz/Windows_VisualStudio_Cli_MSTest_None.md
index c7ab6ff2b..8834eea0b 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_MSTest_None.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_MSTest_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_NUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Cli_NUnit_AppVeyor.md
index d49beb014..f41786a68 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_NUnit_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_NUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Cli_NUnit_AzureDevOps.md
index 4b160e5bc..0bab6a060 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_NUnit_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_NUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Cli_NUnit_GitHubActions.md
index 864b79d96..ffdac735d 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_NUnit_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_NUnit_None.md b/docs/wiz/Windows_VisualStudio_Cli_NUnit_None.md
index 8e7f27e25..e78027abf 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_NUnit_None.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_NUnit_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_TUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Cli_TUnit_AppVeyor.md
index d829cb940..a021a6ec8 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_TUnit_AppVeyor.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_TUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Cli_TUnit_AzureDevOps.md
index 1652126a0..4c819da70 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_TUnit_AzureDevOps.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_TUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Cli_TUnit_GitHubActions.md
index 7276aa247..4bc362e7a 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_TUnit_GitHubActions.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_TUnit_None.md b/docs/wiz/Windows_VisualStudio_Cli_TUnit_None.md
index a96f89821..1faf8dc13 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_TUnit_None.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_TUnit_None.md
@@ -133,7 +133,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AppVeyor.md
index a5778e8f8..2291e8448 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AppVeyor.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AzureDevOps.md
index d2d37c5e3..5d5f25019 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_AzureDevOps.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_GitHubActions.md
index 81e3aa491..c6843bc1c 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_GitHubActions.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_None.md b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_None.md
index 728d516ba..05d4418db 100644
--- a/docs/wiz/Windows_VisualStudio_Cli_XunitV3_None.md
+++ b/docs/wiz/Windows_VisualStudio_Cli_XunitV3_None.md
@@ -135,7 +135,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Expecto_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Gui_Expecto_AppVeyor.md
index 7c1e83e52..6dae4a182 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Expecto_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Expecto_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Expecto_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Gui_Expecto_AzureDevOps.md
index 6d8d9b295..0da7816a5 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Expecto_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Expecto_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Expecto_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Gui_Expecto_GitHubActions.md
index 16e510c67..172ec2aae 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Expecto_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Expecto_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Expecto_None.md b/docs/wiz/Windows_VisualStudio_Gui_Expecto_None.md
index 1ef502edf..d0aca940a 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Expecto_None.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Expecto_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Fixie_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Gui_Fixie_AppVeyor.md
index 044abb364..048f94790 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Fixie_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Fixie_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Fixie_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Gui_Fixie_AzureDevOps.md
index ef99a5390..eff4965bf 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Fixie_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Fixie_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Fixie_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Gui_Fixie_GitHubActions.md
index 7b431d0a8..f68cc5e7c 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Fixie_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Fixie_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_Fixie_None.md b/docs/wiz/Windows_VisualStudio_Gui_Fixie_None.md
index 9c794f35a..cb98cb8cd 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_Fixie_None.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_Fixie_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_MSTest_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Gui_MSTest_AppVeyor.md
index 92babf2f5..81a8e0dfb 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_MSTest_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_MSTest_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_MSTest_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Gui_MSTest_AzureDevOps.md
index e19be2628..5ee2c46df 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_MSTest_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_MSTest_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_MSTest_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Gui_MSTest_GitHubActions.md
index 6ff666ea1..ae96991c7 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_MSTest_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_MSTest_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_MSTest_None.md b/docs/wiz/Windows_VisualStudio_Gui_MSTest_None.md
index fa4b024a7..89fce3978 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_MSTest_None.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_MSTest_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_NUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Gui_NUnit_AppVeyor.md
index 068405059..f5ffa010a 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_NUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_NUnit_AppVeyor.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_NUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Gui_NUnit_AzureDevOps.md
index 869d90a3d..115b2aee7 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_NUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_NUnit_AzureDevOps.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_NUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Gui_NUnit_GitHubActions.md
index 57ecc86fe..b63f6c2f9 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_NUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_NUnit_GitHubActions.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_NUnit_None.md b/docs/wiz/Windows_VisualStudio_Gui_NUnit_None.md
index 8269df47b..734e5052a 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_NUnit_None.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_NUnit_None.md
@@ -141,7 +141,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_TUnit_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Gui_TUnit_AppVeyor.md
index 2d8f6d236..4dfe469ee 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_TUnit_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_TUnit_AppVeyor.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_TUnit_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Gui_TUnit_AzureDevOps.md
index 72ede708b..d2c71b24d 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_TUnit_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_TUnit_AzureDevOps.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_TUnit_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Gui_TUnit_GitHubActions.md
index 2c3618830..0ba6a9655 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_TUnit_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_TUnit_GitHubActions.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_TUnit_None.md b/docs/wiz/Windows_VisualStudio_Gui_TUnit_None.md
index b91d5e5b0..a3d392f4c 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_TUnit_None.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_TUnit_None.md
@@ -139,7 +139,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AppVeyor.md b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AppVeyor.md
index d9a5e5c91..3832d6f85 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AppVeyor.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AppVeyor.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AzureDevOps.md b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AzureDevOps.md
index eb2be5625..33d35db47 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AzureDevOps.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_AzureDevOps.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_GitHubActions.md b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_GitHubActions.md
index 9515cd81e..84873e401 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_GitHubActions.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_GitHubActions.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_None.md b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_None.md
index 116da99b4..8de32dda8 100644
--- a/docs/wiz/Windows_VisualStudio_Gui_XunitV3_None.md
+++ b/docs/wiz/Windows_VisualStudio_Gui_XunitV3_None.md
@@ -140,7 +140,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
diff --git a/readme.md b/readme.md
index bd6f7a962..9006a0771 100644
--- a/readme.md
+++ b/readme.md
@@ -677,7 +677,12 @@ indent_style = space
 
 **Note that the above are suggested for subset of text extension. Add others as required based on the text file types being verified.**
 
-**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.<!-- endInclude -->
+**Visual Studio Code** does not apply the EditorConfig `end_of_line` setting natively. Without it, accepting a snapshot by editing in the built-in diff editor (for example reverting a block from received into verified) can save the verified file with `crlf` on Windows, taken from the default `files.eol`. Verify then rejects that file for containing a carriage return. Installing the [EditorConfig for VS Code extension](https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig) applies `end_of_line = lf` on save. Setting `"files.eol": "\n"` in Visual Studio Code settings has the same effect without the extension.
+
+
+#### Newline tolerance
+
+The settings above are the recommended approach, since they keep the content on disk consistent for everyone working on a repository. Where per developer setup cannot be relied on, Verify can instead be made tolerant of carriage returns and of a trailing newline in verified files. Both are opt in, and both have side effects worth understanding before enabling them. See [Newline tolerance](/docs/newline-tolerance.md).<!-- endInclude -->
 
 
 ### Conventions check
@@ -1095,6 +1100,7 @@ Browser testing via
   * [Custom Diff Tool](https://github.com/VerifyTests/DiffEngine/blob/master/docs/diff-tool.custom.md)
   * [Using anonymous types](/docs/anonymous-types.md)
   * [Verifying binary data](/docs/binary.md)
+  * [Newline tolerance](/docs/newline-tolerance.md)
   * [Exception Message Format](/docs/exception-message-format.md)
   * [Build server](/docs/build-server.md)
   * [Kill process locking file](/docs/kill-process-locking-file.md)
diff --git a/src/ModuleInitDocs/FixNewlinesOnRead.cs b/src/ModuleInitDocs/FixNewlinesOnRead.cs
new file mode 100644
index 000000000..9e2b70ad4
--- /dev/null
+++ b/src/ModuleInitDocs/FixNewlinesOnRead.cs
@@ -0,0 +1,13 @@
+public class FixNewlinesOnRead
+{
+    #region FixNewlinesOnRead
+
+    public static class ModuleInitializer
+    {
+        [ModuleInitializer]
+        public static void Init() =>
+            VerifierSettings.FixNewlinesOnRead();
+    }
+
+    #endregion
+}
diff --git a/src/ModuleInitDocs/IgnoreTrailingNewline.cs b/src/ModuleInitDocs/IgnoreTrailingNewline.cs
new file mode 100644
index 000000000..e59b1aafe
--- /dev/null
+++ b/src/ModuleInitDocs/IgnoreTrailingNewline.cs
@@ -0,0 +1,13 @@
+public class IgnoreTrailingNewline
+{
+    #region IgnoreTrailingNewline
+
+    public static class ModuleInitializer
+    {
+        [ModuleInitializer]
+        public static void Init() =>
+            VerifierSettings.IgnoreTrailingNewline();
+    }
+
+    #endregion
+}
diff --git a/src/StaticSettingsTests/FixNewlinesOnReadTests.cs b/src/StaticSettingsTests/FixNewlinesOnReadTests.cs
new file mode 100644
index 000000000..680e30e7b
--- /dev/null
+++ b/src/StaticSettingsTests/FixNewlinesOnReadTests.cs
@@ -0,0 +1,84 @@
+// Lives here, rather than in Verify.Tests, since FixNewlinesOnRead is a static setting, and this
+// project runs serially with BaseTest resetting it between tests.
+public class FixNewlinesOnReadTests :
+    BaseTest
+{
+    [Fact]
+    public async Task RejectedByDefault()
+    {
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\r\nb");
+
+        var exception = await Assert.ThrowsAnyAsync<Exception>(() => Verify("a\nb", Settings(temp)));
+
+        Assert.Contains("carriage return", exception.Message);
+    }
+
+    [Fact]
+    public async Task Crlf()
+    {
+        VerifierSettings.FixNewlinesOnRead();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\r\nb");
+
+        await Verify("a\nb", Settings(temp));
+    }
+
+    [Fact]
+    public async Task Cr()
+    {
+        VerifierSettings.FixNewlinesOnRead();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\rb");
+
+        await Verify("a\nb", Settings(temp));
+    }
+
+    [Fact]
+    public async Task VerifiedIsNotRewritten()
+    {
+        VerifierSettings.FixNewlinesOnRead();
+
+        using var temp = new TempDirectory();
+        var verified = VerifiedPath(temp);
+        await File.WriteAllTextAsync(verified, "a\r\nb");
+
+        await Verify("a\nb", Settings(temp));
+
+        // Normalizing happens in memory. A passing test does not write, so the file on disk
+        // keeps its line endings.
+        Assert.Equal("a\r\nb", await File.ReadAllTextAsync(verified));
+    }
+
+    [Fact]
+    public async Task MismatchStillFails()
+    {
+        VerifierSettings.FixNewlinesOnRead();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\r\nb");
+
+        // Line endings are normalized, the rest of the content is still compared as is
+        var exception = await Assert.ThrowsAsync<VerifyException>(() => Verify("a\nc", Settings(temp)));
+
+        Assert.DoesNotContain("carriage return", exception.Message);
+        Assert.Equal("a\nc", await File.ReadAllTextAsync(ReceivedPath(temp)));
+    }
+
+    static VerifySettings Settings(TempDirectory temp)
+    {
+        var settings = new VerifySettings();
+        settings.UseDirectory(temp);
+        // Several verifies below are expected to fail, so without this the diff tool is launched
+        settings.DisableDiff();
+        return settings;
+    }
+
+    static string VerifiedPath(TempDirectory temp, [CallerMemberName] string name = "") =>
+        temp.BuildPath($"{nameof(FixNewlinesOnReadTests)}.{name}.verified.txt");
+
+    static string ReceivedPath(TempDirectory temp, [CallerMemberName] string name = "") =>
+        temp.BuildPath($"{nameof(FixNewlinesOnReadTests)}.{name}.received.txt");
+}
diff --git a/src/StaticSettingsTests/IgnoreTrailingNewlineTests.cs b/src/StaticSettingsTests/IgnoreTrailingNewlineTests.cs
new file mode 100644
index 000000000..8a66dbadc
--- /dev/null
+++ b/src/StaticSettingsTests/IgnoreTrailingNewlineTests.cs
@@ -0,0 +1,99 @@
+// Lives here, rather than in Verify.Tests, since IgnoreTrailingNewline is a static setting, and
+// this project runs serially with BaseTest resetting it between tests.
+public class IgnoreTrailingNewlineTests :
+    BaseTest
+{
+    [Fact]
+    public async Task NotIgnoredByDefault()
+    {
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\n");
+
+        await Assert.ThrowsAsync<VerifyException>(() => Verify("a", Settings(temp)));
+    }
+
+    [Fact]
+    public async Task Ignored()
+    {
+        VerifierSettings.IgnoreTrailingNewline();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\n");
+
+        await Verify("a", Settings(temp));
+    }
+
+    [Fact]
+    public async Task IgnoredWhenReceivedAlsoEndsInNewline()
+    {
+        VerifierSettings.IgnoreTrailingNewline();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\n\n");
+
+        await Verify("a\n", Settings(temp));
+    }
+
+    [Fact]
+    public async Task OnlyASingleNewline()
+    {
+        VerifierSettings.IgnoreTrailingNewline();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a\n\n");
+
+        await Assert.ThrowsAsync<VerifyException>(() => Verify("a", Settings(temp)));
+    }
+
+    [Fact]
+    public async Task OnlyWhereTheNewlineIsTheSoleDifference()
+    {
+        VerifierSettings.IgnoreTrailingNewline();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "b\n");
+
+        await Assert.ThrowsAsync<VerifyException>(() => Verify("a", Settings(temp)));
+    }
+
+    [Fact]
+    public async Task OnlyForVerified()
+    {
+        VerifierSettings.IgnoreTrailingNewline();
+
+        using var temp = new TempDirectory();
+        await File.WriteAllTextAsync(VerifiedPath(temp), "a");
+
+        // The tolerance exists for editors adding a final newline to verified. Received is
+        // written by Verify, so a trailing newline there is part of what the test produced.
+        await Assert.ThrowsAsync<VerifyException>(() => Verify("a\n", Settings(temp)));
+    }
+
+    [Fact]
+    public async Task VerifiedIsNotRewritten()
+    {
+        VerifierSettings.IgnoreTrailingNewline();
+
+        using var temp = new TempDirectory();
+        var verified = VerifiedPath(temp);
+        await File.WriteAllTextAsync(verified, "a\n");
+
+        await Verify("a", Settings(temp));
+
+        // Trimming happens in memory. A passing test does not write, so the trailing newline
+        // stays on disk.
+        Assert.Equal("a\n", await File.ReadAllTextAsync(verified));
+    }
+
+    static VerifySettings Settings(TempDirectory temp)
+    {
+        var settings = new VerifySettings();
+        settings.UseDirectory(temp);
+        // Several verifies above are expected to fail, so without this the diff tool is launched
+        settings.DisableDiff();
+        return settings;
+    }
+
+    static string VerifiedPath(TempDirectory temp, [CallerMemberName] string name = "") =>
+        temp.BuildPath($"{nameof(IgnoreTrailingNewlineTests)}.{name}.verified.txt");
+}
diff --git a/src/Verify/Compare/Comparer.cs b/src/Verify/Compare/Comparer.cs
index e265e3b4b..6f7347144 100644
--- a/src/Verify/Compare/Comparer.cs
+++ b/src/Verify/Compare/Comparer.cs
@@ -14,11 +14,18 @@ public static async Task<EqualityResult> Text(FilePair filePair, StringBuilder r
         var verified = await File.ReadAllTextAsync(filePair.VerifiedPath, VerifierSettings.Encoding);
         if (verified.Contains('\r'))
         {
-            // Write received before throwing. Otherwise the run produces no output at all,
-            // which reads as "verify silently did nothing" rather than a line ending problem.
-            // Accepting the received file also rewrites verified with \n endings.
-            IoHelpers.WriteText(filePair.ReceivedPath, received);
-            throw new VerifiedLineEndingException(filePair.VerifiedPath, filePair.Extension);
+            if (!VerifierSettings.fixNewlinesOnRead)
+            {
+                // Write received before throwing. Otherwise the run produces no output at all,
+                // which reads as "verify silently did nothing" rather than a line ending problem.
+                // Accepting the received file also rewrites verified with \n endings.
+                IoHelpers.WriteText(filePair.ReceivedPath, received);
+                throw new VerifiedLineEndingException(filePair.VerifiedPath, filePair.Extension);
+            }
+
+            verified = verified
+                .Replace("\r\n", "\n")
+                .Replace('\r', '\n');
         }
 
         var result = await CompareStrings(filePair.Extension, received, verified, settings, bypassComparer);
@@ -33,6 +40,15 @@ public static async Task<EqualityResult> Text(FilePair filePair, StringBuilder r
 
     static Task<CompareResult> CompareStrings(string extension, StringBuilder received, string verified, VerifySettings settings, bool bypassComparer)
     {
+        // Only a single trailing \n, and only where it is the sole difference in length. An
+        // editor adding a final newline to verified is tolerated, a genuine content change is not.
+        if (VerifierSettings.ignoreTrailingNewline &&
+            verified.Length - 1 == received.Length &&
+            verified[^1] == '\n')
+        {
+            verified = verified[..^1];
+        }
+
         var isEqual = received.Equals(verified.AsSpan());
         if (!isEqual &&
             !bypassComparer &&
diff --git a/src/Verify/Compare/VerifiedLineEndingException.cs b/src/Verify/Compare/VerifiedLineEndingException.cs
index 24c1192b5..48b4f949c 100644
--- a/src/Verify/Compare/VerifiedLineEndingException.cs
+++ b/src/Verify/Compare/VerifiedLineEndingException.cs
@@ -9,4 +9,7 @@ class VerifiedLineEndingException(string path, string extension) :
            git rm --cached -r .
            git reset --hard
          See https://github.com/verifytests/verify#text-file-settings
+         Alternatively Verify can be made tolerant of line endings in verified files, with
+         the side effects described in
+         https://github.com/VerifyTests/Verify/blob/main/docs/newline-tolerance.md
          """);
diff --git a/src/Verify/Serialization/VerifierSettings.cs b/src/Verify/Serialization/VerifierSettings.cs
index ae9799c20..e856d073d 100644
--- a/src/Verify/Serialization/VerifierSettings.cs
+++ b/src/Verify/Serialization/VerifierSettings.cs
@@ -163,6 +163,8 @@ internal static void Reset()
         UniquePrefixDisabled = false;
         UseUniqueDirectorySplitMode = false;
         omitContentFromException = false;
+        fixNewlinesOnRead = false;
+        ignoreTrailingNewline = false;
         encoding = new UTF8Encoding(true, true);
         addAttachments = true;
         excludedTargets = null;
diff --git a/src/Verify/VerifierSettings.cs b/src/Verify/VerifierSettings.cs
index 25bd591e8..0466249ab 100644
--- a/src/Verify/VerifierSettings.cs
+++ b/src/Verify/VerifierSettings.cs
@@ -33,6 +33,33 @@ public static void AutoVerify(GlobalAutoVerify autoVerify, bool includeBuildServ
     internal static GlobalAutoVerify? autoVerify;
     internal static bool throwException;
 
+    internal static bool fixNewlinesOnRead;
+
+    /// <summary>
+    /// Normalize `\r\n` and `\r` to `\n` when reading verified files, instead of rejecting a
+    /// verified file that contains a carriage return.
+    /// Has side effects. See https://github.com/VerifyTests/Verify/blob/main/docs/newline-tolerance.md
+    /// </summary>
+    public static void FixNewlinesOnRead()
+    {
+        InnerVerifier.ThrowIfVerifyHasBeenRun();
+        fixNewlinesOnRead = true;
+    }
+
+    internal static bool ignoreTrailingNewline;
+
+    /// <summary>
+    /// Treat a verified file that has a single trailing `\n`, where that newline is the only
+    /// difference, as equal to the received content.
+    /// Has side effects, and can mask a real change in trailing newlines. See
+    /// https://github.com/VerifyTests/Verify/blob/main/docs/newline-tolerance.md
+    /// </summary>
+    public static void IgnoreTrailingNewline()
+    {
+        InnerVerifier.ThrowIfVerifyHasBeenRun();
+        ignoreTrailingNewline = true;
+    }
+
     public static void UseUtf8NoBom() =>
         Encoding = new UTF8Encoding(false, true);