diff --git a/CHANGELOG.md b/CHANGELOG.md
index 61dc143a..eef40378 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,7 +7,15 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## \[Unreleased\]
 
-- Nothing yet.
+### Fixed
+
+- Flattened heredoc bodies match the values Terraform and OpenTofu evaluate the same source to. Three things differed, all checked against OpenTofu v1.12.5 rather than read off the spec: the newline terminating the last content line was dropped (`<<EOT\nline\nEOT` returned `'line'`, not `'line\n'`); `<<-` measured its indent in spaces alone, so a tab-indented body was not dedented at all; and a whitespace-only line was excluded from the measurement but trimmed anyway. This is not a regression — 7.2.1 returned the same values — so it changes long-standing behaviour rather than restoring anything.
+- A carriage return in a flattened heredoc body is written as `\r` rather than left raw. `preserve_heredocs=False` returns quoted-string *source*, and a quoted string cannot hold a literal carriage return: OpenTofu rejects one with "No closing marker was found for the string". A heredoc read out of a CRLF file therefore flattened to source that would not parse again. The value form (`strip_string_quotes=True`) is unchanged and still hands back real carriage returns. `strings_to_heredocs` resolves `\r` when it writes a body, so the two halves stay each other's inverse: a heredoc interprets no escape, so a body carrying a backslash and an `r` would be those two characters rather than the carriage return the value held.
+- A `<<-` heredoc whose closing marker is indented with something other than spaces or tabs no longer appends that indentation to the value. The dedent already measured whitespace rather than spaces, matching OpenTofu, but the marker's own indent was stripped as `[ \t]*`, so a body indented with a non-breaking space, a vertical tab, a form feed or an ideographic space came back with one of those characters on the end. Four such cases are now in the table that `bin/heredoc_ground_truth` re-derives from OpenTofu.
+- A heredoc written inside a list or an object ends its own line. It ends at its closing marker, on a line of its own, so the separator that follows has to start the next one -- `EOF,` closes nothing, and the file this library had just written did not parse, here or in Terraform. A top-level attribute survived only because the newline after it comes from the document. Only a heredoc built by the deserializer needs this: `HEREDOC_TEMPLATE` matches through the newline after the marker, so one that came from the parser already ends the line, and reconstructing a parsed document is byte for byte what it was. ([#338](https://github.com/amplify-education/python-hcl2/issues/338))
+- `strings_to_heredocs` leaves a value carrying a lone carriage return quoted. A heredoc body is read literally, so it can hold a `\r` only where one ends a line: OpenTofu rejects `<<EOF\nx\ry\nEOF` with "No closing marker was found for the string", while the quoted `"x\ry\n"` it came from is valid. Such a value stays quoted, for the same reason one that does not end in a newline does.
+- `strings_to_heredocs` picks a delimiter the body cannot close. It wrote `<<EOF` over every value, so a string holding a line reading `EOF` -- a log excerpt, a shell script, an embedded config, the payloads heredocs are for -- ended its own heredoc early and produced a file that no longer parsed. A numbered variant is used when the body occupies `EOF`, and ordinary values are written exactly as before. The lines that count as markers are Terraform's, which are looser than this grammar's: OpenTofu ends a heredoc on `EOF  ` while `HEREDOC_TEMPLATE` here requires the newline to follow the word. A CRLF body counts too -- it is split on `\n`, so its lines carry their own `\r`, and OpenTofu ends a heredoc on `EOF\r` as readily as on `EOF `. ([#330](https://github.com/amplify-education/python-hcl2/issues/330))
+- `strings_to_heredocs` no longer adds a line to the body it writes. The value's own trailing newline is the one that precedes the closing marker, so a heredoc was being emitted one line longer than the string it came from. A value that does not end in a newline is now left as a quoted string, since no heredoc can express it. Flattening a document and restoring it now yields HCL that OpenTofu evaluates identically to the original; five of the eleven values in the round-trip fixture did not survive it before.
 
 ## \[8.1.3\] - 2026-08-26
 
diff --git a/bin/heredoc_ground_truth b/bin/heredoc_ground_truth
new file mode 100755
index 00000000..6003ee13
--- /dev/null
+++ b/bin/heredoc_ground_truth
@@ -0,0 +1,108 @@
+#!/usr/bin/env python
+"""Check the heredoc expectations in the test suite against Terraform itself.
+
+`test/unit/test_heredoc_matches_terraform.py` asserts what a heredoc body
+evaluates to. Those values did not come from this library or from reading the
+spec -- each one was produced by handing the same source to OpenTofu. That
+provenance is a docstring, which a reader has to take on trust and which
+nothing re-checks if the reference implementation ever moves.
+
+This script re-derives them. It reads the `CASES` table out of that test module,
+evaluates every source with `tofu console` (or `terraform console`), and
+compares. It is not part of the test run: the suite must not depend on a
+Terraform binary, and these values change about as often as the HCL spec does.
+
+Usage:
+    bin/heredoc_ground_truth            # verify; non-zero exit on any mismatch
+    bin/heredoc_ground_truth --print    # print the table as Python, to paste
+
+Requires `tofu` or `terraform` on PATH.
+"""
+
+import argparse
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+from test.unit.test_heredoc_matches_terraform import CASES  # noqa: E402
+
+BINARIES = ("tofu", "terraform")
+
+
+def find_binary():
+    """Return the first Terraform-compatible binary on PATH, or None."""
+    for name in BINARIES:
+        path = shutil.which(name)
+        if path:
+            return path
+    return None
+
+
+def evaluate(binary, source):
+    """Return the value `binary` evaluates the given heredoc expression to.
+
+    The source is written as a local rather than an output so that nothing has
+    to be applied, and `jsonencode` is what carries the exact string back --
+    the console's own rendering escapes newlines for display.
+    """
+    with tempfile.TemporaryDirectory() as directory:
+        # newline="" so a case testing CRLF is written with the bytes it names.
+        with open(os.path.join(directory, "main.tf"), "w", encoding="utf-8", newline="") as handle:
+            handle.write("locals {\n  x = %s\n}\n" % source)
+        result = subprocess.run(
+            [binary, "console"],
+            cwd=directory,
+            input="jsonencode(local.x)\n",
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(result.stderr.strip())
+        return json.loads(json.loads(result.stdout.strip().splitlines()[-1]))
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--print",
+        dest="print_table",
+        action="store_true",
+        help="print the evaluated table as Python instead of verifying",
+    )
+    args = parser.parse_args()
+
+    binary = find_binary()
+    if binary is None:
+        print("neither `tofu` nor `terraform` is on PATH", file=sys.stderr)
+        return 2
+
+    print("using %s\n" % binary, file=sys.stderr)
+    mismatches = 0
+    for source, expected in CASES:
+        actual = evaluate(binary, source)
+        if args.print_table:
+            print("    (%r, %r)," % (source, actual))
+            continue
+        if actual == expected:
+            print("ok   %r" % source)
+        else:
+            mismatches += 1
+            print("BAD  %r\n       expected %r\n       %s says %r" % (source, expected, binary, actual))
+
+    if args.print_table:
+        return 0
+
+    # stdout, so it lands after the per-case lines rather than ahead of them
+    # when the output is piped.
+    print("\n%d of %d cases disagree" % (mismatches, len(CASES)))
+    return 1 if mismatches else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/cli/json_to_hcl.py b/cli/json_to_hcl.py
index d14daed5..f7ce868b 100644
--- a/cli/json_to_hcl.py
+++ b/cli/json_to_hcl.py
@@ -180,7 +180,7 @@ def main():  # pylint: disable=too-many-branches,too-many-statements,too-many-lo
     parser.add_argument(
         "--strings-to-heredocs",
         action="store_true",
-        help="Convert strings containing escaped newlines to heredocs",
+        help="Convert newline-terminated escaped strings to heredocs",
     )
 
     # FormatterOptions flags
diff --git a/docs/01_getting_started.md b/docs/01_getting_started.md
index 431fc06b..4fd79f05 100644
--- a/docs/01_getting_started.md
+++ b/docs/01_getting_started.md
@@ -74,7 +74,7 @@ data = loads(text, serialization_options=SerializationOptions(
 | `wrap_objects` | `bool` | `False` | Wrap object values as inline HCL2 strings                                                                                                       |
 | `wrap_tuples` | `bool` | `False` | Wrap tuple values as inline HCL2 strings                                                                                                        |
 | `explicit_blocks` | `bool` | `True` | Add `__is_block__: True` markers to blocks. **Mandatory for JSON->HCL2 deserialization and reconstruction.**                                    |
-| `preserve_heredocs` | `bool` | `True` | Keep heredocs in their original form, markers included. When `False`, a heredoc becomes a quoted string with its newlines escaped (`'"a\nb"'`); combine with `strip_string_quotes` to get the body as a plain multi-line value instead. |
+| `preserve_heredocs` | `bool` | `True` | Keep heredocs in their original form, markers included. When `False`, a heredoc becomes a quoted string with its newlines escaped (`'"a\nb\n"'`); combine with `strip_string_quotes` to get the body as a plain multi-line value instead. Either way the body keeps the newline that terminates its last line, as Terraform's does. |
 | `force_operation_parentheses` | `bool` | `False` | Force parentheses around all operations                                                                                                         |
 | `preserve_scientific_notation` | `bool` | `True` | Keep scientific notation as-is                                                                                                                  |
 | `strip_string_quotes` | `bool` | `False` | Yield string *values* rather than source text: remove surrounding quotes (e.g. `"hello"` instead of `'"hello"'`) and resolve escape sequences (`"a\nb"` becomes a real newline). String literals inside expressions keep their quotes, so `upper("x")` stays `'${upper("x")}'`. **Breaks JSON->HCL2 deserialization and reconstruction.** |
@@ -127,7 +127,7 @@ text = dumps(data, deserializer_options=DeserializerOptions(
 | Field | Type | Default | Description |
 |---|---|---|---|
 | `heredocs_to_strings` | `bool` | `False` | Convert heredocs to plain strings |
-| `strings_to_heredocs` | `bool` | `False` | Convert strings with `\n` to heredocs |
+| `strings_to_heredocs` | `bool` | `False` | Convert newline-terminated strings to heredocs. A value that does not end in a newline is left as a quoted string, because a heredoc body always ends in one and writing it as a heredoc would change the value. |
 | `object_elements_colon` | `bool` | `False` | Use `:` instead of `=` in object elements |
 | `object_elements_trailing_comma` | `bool` | `True` | Add trailing commas in object elements |
 
diff --git a/docs/06_migrating_to_v8.md b/docs/06_migrating_to_v8.md
index 0c4703bf..467c1d0d 100644
--- a/docs/06_migrating_to_v8.md
+++ b/docs/06_migrating_to_v8.md
@@ -213,17 +213,18 @@ This restores the v7 dict shape but disables round-trip support and comment pres
 
 ```python
 hcl2.loads('x = <<-EOT\n  line1\n  line2\n  EOT\n', serialization_options=V7_COMPAT)
-# {'x': 'line1\nline2'}
+# {'x': 'line1\nline2\n'}
 ```
 
-Note that `preserve_heredocs=False` on its own — without `strip_string_quotes` — produces the quoted *source* form with escaped newlines (`'"line1\\nline2"'`), because that output is meant to be reconstructable.
+Note that `preserve_heredocs=False` on its own — without `strip_string_quotes` — produces the quoted *source* form with escaped newlines (`'"line1\\nline2\\n"'`), because that output is meant to be reconstructable.
 
-Two details of heredoc values are easy to trip over, and both match how HCL itself behaves:
+Three details of heredoc values are easy to trip over, and all three match how HCL itself behaves:
 
+- **The body ends with a newline.** Every content line is terminated by its own newline, the last one included, so `<<EOT\nline\nEOT` is `'line\n'` — the same value Terraform evaluates it to. v7 returned `'line'`, and so did 8.1.x; both were wrong. Only an empty body has no trailing newline, because it has no content line.
 - **Backslash escapes are not interpreted in heredocs.** `strip_string_quotes` resolves `\n` inside a *quoted* string, but a heredoc body containing the two characters `\n` keeps them verbatim. HCL only processes escape sequences in quoted templates.
 - **Line endings come through as written.** A heredoc in a CRLF file yields a body with `\r\n`, because a carriage return inside the body is content rather than structure. Normalize on your side if you need `\n`.
 
 ```python
 hcl2.loads('x = <<EOT\na\\nb\nEOT\n', serialization_options=V7_COMPAT)
-# {'x': 'a\\nb'}  — the backslash and the "n" are two literal characters
+# {'x': 'a\\nb\n'}  — the backslash and the "n" are two literal characters
 ```
diff --git a/hcl2/deserializer.py b/hcl2/deserializer.py
index 667e0b20..ce87553f 100644
--- a/hcl2/deserializer.py
+++ b/hcl2/deserializer.py
@@ -63,6 +63,75 @@
 from hcl2.transformer import RuleTransformer
 from hcl2.utils import HEREDOC_PATTERN, HEREDOC_TRIM_PATTERN
 
+_HEREDOC_BODY_ESCAPES = {"n": "\n", "r": "\r"}
+
+# A line that could end a heredoc: the delimiter word alone, give or take
+# surrounding spaces and tabs -- and a carriage return, because the body is
+# split on "\n" and a CRLF line hands back its own `\r`. OpenTofu ends a
+# heredoc on `EOF\r` exactly as it does on `EOF `, so a CRLF body carrying
+# the delimiter has to count. This grammar is stricter than Terraform, whose
+# scanner ends the heredoc on `EOF  ` while `HEREDOC_TEMPLATE` here requires
+# the newline to follow the word itself. The looser reading is the safe one to
+# pick a delimiter against: emitting a body that only Terraform would treat as
+# closed writes a file this library can read and Terraform cannot.
+_CLOSING_MARKER_LINE = re.compile(r"[ \t]*([a-zA-Z][a-zA-Z0-9._-]*)[ \t\r]*")
+
+
+def _heredoc_delimiter(content: str) -> str:
+    """Return a delimiter the body does not close on its own.
+
+    `EOF` unless the body holds a line that would end the heredoc there, in
+    which case a numbered variant is used. The word matters: a log excerpt, a
+    shell script or an embedded config is exactly the sort of value people put
+    in a heredoc, and `EOF` is exactly the word such a payload tends to
+    contain. Writing one blindly produced a file that no longer parsed.
+    """
+    occupied = set()
+    for line in content.split("\n"):
+        match = _CLOSING_MARKER_LINE.fullmatch(line)
+        if match is not None:
+            occupied.add(match.group(1))
+
+    if "EOF" not in occupied:
+        return "EOF"
+
+    suffix = 1
+    while f"EOF_{suffix}" in occupied:
+        suffix += 1
+    return f"EOF_{suffix}"
+
+
+def _expressible_as_heredoc(content: str) -> bool:
+    """Whether *content* can be a heredoc body without changing.
+
+    A heredoc body is read literally, so it can hold a carriage return only
+    where one ends a line. A lone `\r` makes the file unreadable rather than
+    merely different: OpenTofu rejects `<<EOF\nx\ry\nEOF` with "No closing
+    marker was found for the string", while the quoted `"x\ry\n"` it came
+    from is valid and evaluates to that carriage return. Such a value stays
+    quoted, for the same reason one that does not end in a newline does.
+    """
+    return "\r" not in content.replace("\r\n", "")
+
+
+def _unescape_heredoc_body(inner: str) -> str:
+    r"""Resolve the escapes a heredoc body carries literally: \n, \r, \" and \\.
+
+    A heredoc interprets no backslash sequence -- its body is the characters
+    themselves -- so anything the quoted form spelled as an escape has to be
+    resolved before it is written into one. `\r` is here because the flattened
+    form escapes carriage returns: without it, a heredoc read out of a CRLF
+    file and written back came out holding a literal backslash and an `r`.
+
+    Single-pass, so an escaped backslash cannot combine with the character
+    after it.
+    """
+    return re.sub(
+        r'\\(n|r|"|\\)',
+        lambda m: _HEREDOC_BODY_ESCAPES.get(m.group(1), m.group(1)),
+        inner,
+    )
+
 
 @dataclass
 class DeserializerOptions:
@@ -71,8 +140,10 @@ class DeserializerOptions:
     # Convert heredoc values (<<EOF...EOF) to regular escaped strings during
     # deserialization. When False, heredoc syntax is preserved as-is.
     heredocs_to_strings: bool = False
-    # Convert multi-line escaped strings (containing \n) back into heredoc
-    # syntax (<<EOF...EOF) during deserialization.
+    # Convert newline-terminated escaped strings back into heredoc syntax
+    # (<<EOF...EOF) during deserialization. A value that does not end in a
+    # newline is left quoted: a non-empty heredoc body always does, so writing
+    # one as a heredoc would hand back a different value on the next read.
     strings_to_heredocs: bool = False
     # Use colon (:) instead of equals (=) as the separator in object elements.
     object_elements_colon: bool = False
@@ -179,9 +250,18 @@ def _deserialize_text(self, value: Any) -> LarkRule:
                         return self._deserialize_heredoc(value[1:-1], False)
 
                 if self.options.strings_to_heredocs:
-                    inner = value[1:-1]
-                    if "\\n" in inner:
-                        return self._deserialize_string_as_heredoc(inner)
+                    content = _unescape_heredoc_body(value[1:-1])
+                    # A heredoc's closing marker sits on a line of its own, so
+                    # any body with content in it ends with a newline. A value
+                    # that does not cannot be written as one without gaining
+                    # that character, so it stays a quoted string.
+                    #
+                    # The empty string is the one value this excludes that a
+                    # heredoc could in fact express -- `<<EOF\nEOF` evaluates
+                    # to "" in Terraform and here. It stays quoted anyway,
+                    # because `x = ""` says the same thing in one line.
+                    if content.endswith("\n") and _expressible_as_heredoc(content):
+                        return self._deserialize_string_as_heredoc(content)
 
                 return self._deserialize_string(value)
 
@@ -259,15 +339,10 @@ def _deserialize_heredoc(
             return HeredocTrimTemplateRule([HEREDOC_TRIM_TEMPLATE(value)])
         return HeredocTemplateRule([HEREDOC_TEMPLATE(value)])
 
-    def _deserialize_string_as_heredoc(self, inner: str) -> HeredocTemplateRule:
-        """Convert a quoted string with escaped newlines back into a heredoc."""
-        # Single-pass unescape: \\n → \n, \\" → ", \\\\ → \
-        content = re.sub(
-            r'\\(n|"|\\)',
-            lambda m: "\n" if m.group(1) == "n" else m.group(1),
-            inner,
-        )
-        heredoc = f"<<EOF\n{content}\nEOF"
+    def _deserialize_string_as_heredoc(self, content: str) -> HeredocTemplateRule:
+        """Wrap an unescaped body, already newline-terminated, in heredoc syntax."""
+        delimiter = _heredoc_delimiter(content)
+        heredoc = f"<<{delimiter}\n{content}{delimiter}"
         return HeredocTemplateRule([HEREDOC_TEMPLATE(heredoc)])
 
     def _deserialize_expression(self, value: str) -> ExprTermRule:
diff --git a/hcl2/reconstructor.py b/hcl2/reconstructor.py
index 166e6c58..5665dd09 100644
--- a/hcl2/reconstructor.py
+++ b/hcl2/reconstructor.py
@@ -66,6 +66,7 @@ def _reset_state(self):
         self._last_was_space = True
         self._current_indent = 0
         self._last_token_name = None
+        self._last_token_ended_line = False
         self._last_rule_name = None
 
     # pylint:disable=R0911,R0912
@@ -288,18 +289,44 @@ def _reconstruct_tree(self, tree: Tree, parent_rule_name: Optional[str] = None)
 
         return result
 
+    _heredoc_token_names = frozenset({"HEREDOC_TEMPLATE", "HEREDOC_TEMPLATE_TRIM"})
+
     def _reconstruct_token(self, token: Token, parent_rule_name: Optional[str] = None) -> str:
         """Reconstruct a Token node into HCL text fragments."""
         result = str(token.value)
-        if self._should_add_space_before(token, parent_rule_name):
+        if self._needs_line_after_heredoc(token):
+            # A heredoc ends at its closing marker, on a line of its own. Any
+            # token that follows has to start the next line -- inside a list or
+            # an object that token is the separator, and `EOF,` closes nothing,
+            # so the file did not parse. A top-level attribute survived only
+            # because the newline it is followed by comes from the document.
+            result = "\n" + result
+        elif self._should_add_space_before(token, parent_rule_name):
             result = " " + result
 
         self._last_token_name = token.type
+        self._last_token_ended_line = str(token.value).endswith(("\n", "\r\n"))
         if len(token) != 0:
             self._last_was_space = result[-1].endswith(" ") or result[-1].endswith("\n")
 
         return result
 
+    def _needs_line_after_heredoc(self, token: Token) -> bool:
+        """Whether *token* has to start a new line because a heredoc just ended.
+
+        Only for a heredoc that does not carry its own. `HEREDOC_TEMPLATE`
+        matches through the newline after the closing marker, so a token that
+        came from the parser already ends the line; one built by the
+        deserializer does not, and that is the case where the separator landed
+        on the marker's line.
+        """
+        if self._last_token_name not in self._heredoc_token_names:
+            return False
+        if self._last_token_ended_line:
+            return False
+        # Anything that already begins one is fine as it is.
+        return not str(token.value).startswith(("\n", "\r\n"))
+
     def _reconstruct_node(
         self, node: Union[Tree, Token], parent_rule_name: Optional[str] = None
     ) -> List[str]:
diff --git a/hcl2/rules/strings.py b/hcl2/rules/strings.py
index 76ce0660..1e559959 100644
--- a/hcl2/rules/strings.py
+++ b/hcl2/rules/strings.py
@@ -27,23 +27,30 @@
 )
 
 
-def _strip_closing_marker_line(text: str) -> str:
-    r"""Drop the closing marker line's indentation and the one newline before it.
+def _strip_closing_marker_indent(text: str) -> str:
+    r"""Drop the whitespace indenting the closing marker on its own line.
 
     A heredoc body always ends ``...\n<indent>``, where ``<indent>`` is the
-    whitespace preceding the closing marker on its own line. The spec allows
-    "an arbitrary number of spaces preceding it", and neither that indentation
-    nor the newline separating it from the last content line is part of the
-    value. The newline may be ``\r\n``, since heredocs parse in CRLF files.
-
-    Everything else is: additional blank lines, and trailing spaces on a
-    content line. The latter are safe because a content line always ends with
-    its own newline, so the indentation match never reaches them. This replaces
-    a blanket ``rstrip("\n\t ")``, which could not tell the two apart and
-    discarded both.
+    whitespace preceding the closing marker. The spec allows "an arbitrary
+    number of spaces preceding it", and that indentation is not part of the
+    value.
+
+    The newline before it *is*. The spec ends the template where the delimiter
+    "subsequently appears again on a line of its own", so every content line,
+    the last one included, is terminated by its own newline: ``<<EOT\nline\nEOT``
+    is ``"line\n"``, which is what Terraform and OpenTofu evaluate it to.
+
+    Trailing spaces on a content line survive too, because such a line always
+    ends with its own newline, and the match below cannot cross one. This
+    replaced a blanket ``rstrip("\n\t ")``, which could tell none of these
+    apart and discarded all of them.
+
+    The indentation is any whitespace but a newline, not spaces and tabs
+    alone: a marker indented with a non-breaking space, a vertical tab, a form
+    feed or an ideographic space is indented as far as OpenTofu is concerned,
+    and leaving those characters in place appended them to the value.
     """
-    text = re.sub(r"[ \t]*\Z", "", text)
-    return re.sub(r"\r?\n\Z", "", text)
+    return re.sub(r"[^\S\n]*\Z", "", text)
 
 
 class InterpolationRule(LarkRule):
@@ -169,13 +176,18 @@ def serialize(self, options=SerializationOptions(), context=SerializationContext
             match = HEREDOC_PATTERN.match(heredoc)
             if not match:
                 raise RuntimeError(f"Invalid Heredoc token: {heredoc}")
-            heredoc = _strip_closing_marker_line(match.group(2))
+            heredoc = _strip_closing_marker_indent(match.group(2))
             if options.strip_string_quotes:
                 # The caller asked for the value, so hand back the body as-is:
                 # real newlines, no escaping. The escaping below exists only to
                 # build the quoted-string *source* form returned otherwise.
                 return heredoc
-            heredoc = heredoc.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
+            # A carriage return is escaped alongside the newline: raw, it would
+            # break the quoted string it is being written into. OpenTofu rejects
+            # `"a<CR>b"` with "No closing marker was found for the string".
+            heredoc = (
+                heredoc.replace("\\", "\\\\").replace('"', '\\"').replace("\r", "\\r").replace("\n", "\\n")
+            )
             return f'"{heredoc}"'
 
         result = heredoc.rstrip(self._trim_chars)
@@ -197,49 +209,54 @@ def lark_name() -> str:
     def serialize(self, options=SerializationOptions(), context=SerializationContext()) -> Any:
         """Serialize the trim heredoc, stripping common leading whitespace."""
         # See https://github.com/hashicorp/hcl2/blob/master/hcl/hclsyntax/spec.md#template-expressions
-        # This is a special version of heredocs that are declared with "<<-"
-        # This will calculate the minimum number of leading spaces in each line of a heredoc
-        # and then remove that number of spaces from each line
-
+        # This is a special version of heredocs that are declared with "<<-",
+        # whose body is dedented by the smallest indent any of its lines carries.
         heredoc = self.heredoc.serialize(options, context)
 
         if not options.preserve_heredocs:
             match = HEREDOC_TRIM_PATTERN.match(heredoc)
             if not match:
                 raise RuntimeError(f"Invalid Heredoc token: {heredoc}")
-            heredoc = match.group(2)
+            lines = self._dedent(_strip_closing_marker_indent(match.group(2)))
+            if options.strip_string_quotes:
+                # The caller asked for the value: real newlines, no escaping.
+                return "\n".join(lines)
+            escaped = [line.replace("\\", "\\\\").replace('"', '\\"').replace("\r", "\\r") for line in lines]
+            return '"' + "\\n".join(escaped) + '"'
+
+        result = heredoc.rstrip(self._trim_chars)
+        if options.strip_string_quotes:
+            return result
+        return f'"{result}"'
 
-        heredoc = _strip_closing_marker_line(heredoc)
-        lines = heredoc.split("\n")
+    @staticmethod
+    def _dedent(body: str) -> List[str]:
+        """Split *body* into lines and remove the common leading whitespace."""
+        lines = body.split("\n")
 
-        # calculate the min number of leading spaces in each line
+        # The margin is the smallest indent any content line carries.
+        #
         # The spec measures "any literal string at the start of each line", so a
         # blank line offers no measurement. Counting it as zero would drag the
-        # minimum down and cancel the dedent for every other line -- which only
-        # became reachable once blank lines stopped being stripped above.
-        min_spaces = sys.maxsize
+        # margin down and cancel the dedent for every other line.
+        #
+        # It also says "spaces", but the reference implementation does not read
+        # that as narrowly: OpenTofu dedents a tab-indented `<<-` heredoc by one
+        # tab per level. Measuring whitespace characters rather than spaces
+        # alone matches it, and is identical to counting spaces on the
+        # space-indented input that reading the letter of the spec would cover.
+        margin = sys.maxsize
         for line in lines:
             if not line.strip():
                 continue
-            leading_spaces = len(line) - len(line.lstrip(" "))
-            min_spaces = min(min_spaces, leading_spaces)
-        if min_spaces == sys.maxsize:
-            min_spaces = 0
-
-        # trim off that number of leading spaces from each line
-        lines = [line[min_spaces:] for line in lines]
-
-        if not options.preserve_heredocs:
-            lines = [line.replace("\\", "\\\\").replace('"', '\\"') for line in lines]
-
-        if options.strip_string_quotes:
-            # Value, not source: join with real newlines regardless of
-            # preserve_heredocs, and skip the escaping done for the quoted form.
-            return "\n".join(lines)
-
-        sep = "\\n" if not options.preserve_heredocs else "\n"
-        inner = sep.join(lines)
-        return '"' + inner + '"'
+            margin = min(margin, len(line) - len(line.lstrip()))
+        if margin == sys.maxsize:
+            margin = 0
+
+        # A line that offered no measurement is left exactly as written --
+        # OpenTofu keeps a six-space line inside a four-space heredoc at six
+        # spaces rather than two.
+        return [line[margin:] if line.strip() else line for line in lines]
 
 
 class TemplateStringRule(LarkRule):
diff --git a/test/integration/specialized/heredocs_flattened.json b/test/integration/specialized/heredocs_flattened.json
index 95fb4e55..43c6fd2c 100644
--- a/test/integration/specialized/heredocs_flattened.json
+++ b/test/integration/specialized/heredocs_flattened.json
@@ -1,16 +1,16 @@
 {
   "locals": [
     {
-      "simple": "\"hello world\"",
-      "multiline": "\"line1\\nline2\\nline3\"",
-      "with_quotes": "\"say \\\"hello\\\"\"",
-      "with_backslashes": "\"path\\\\to\\\\file\"",
-      "trimmed": "\"indented1\\nindented2\"",
-      "trimmed_mixed": "\"line1\\n  line2\\nline3\"",
-      "json_content": "\"{\\\"key\\\": \\\"value\\\"}\"",
+      "simple": "\"hello world\\n\"",
+      "multiline": "\"line1\\nline2\\nline3\\n\"",
+      "with_quotes": "\"say \\\"hello\\\"\\n\"",
+      "with_backslashes": "\"path\\\\to\\\\file\\n\"",
+      "trimmed": "\"indented1\\nindented2\\n\"",
+      "trimmed_mixed": "\"line1\\n  line2\\nline3\\n\"",
+      "json_content": "\"{\\\"key\\\": \\\"value\\\"}\\n\"",
       "empty": "\"\"",
       "empty_trimmed": "\"\"",
-      "blank_line_only": "\"\"",
+      "blank_line_only": "\"\\n\"",
       "after_empty": "\"still parsed\"",
       "__is_block__": true
     }
diff --git a/test/integration/specialized/heredocs_restored.tf b/test/integration/specialized/heredocs_restored.tf
index 05832d52..a7bad307 100644
--- a/test/integration/specialized/heredocs_restored.tf
+++ b/test/integration/specialized/heredocs_restored.tf
@@ -1,12 +1,18 @@
 locals {
-  simple           = "hello world"
+  simple           = <<EOF
+hello world
+EOF
   multiline        = <<EOF
 line1
 line2
 line3
 EOF
-  with_quotes      = "say \"hello\""
-  with_backslashes = "path\\to\\file"
+  with_quotes      = <<EOF
+say "hello"
+EOF
+  with_backslashes = <<EOF
+path\to\file
+EOF
   trimmed          = <<EOF
 indented1
 indented2
@@ -16,9 +22,13 @@ line1
   line2
 line3
 EOF
-  json_content     = "{\"key\": \"value\"}"
+  json_content     = <<EOF
+{"key": "value"}
+EOF
   empty            = ""
   empty_trimmed    = ""
-  blank_line_only  = ""
+  blank_line_only  = <<EOF
+
+EOF
   after_empty      = "still parsed"
 }
diff --git a/test/unit/cli/test_json_to_hcl.py b/test/unit/cli/test_json_to_hcl.py
index aebdbc28..4038c017 100644
--- a/test/unit/cli/test_json_to_hcl.py
+++ b/test/unit/cli/test_json_to_hcl.py
@@ -354,8 +354,9 @@ def test_heredocs_to_strings_flag(self):
         self.assertIn('"', converted.split("=", 1)[1].strip())
 
     def test_strings_to_heredocs_flag(self):
-        # Quoted strings with escaped newlines get converted to heredocs
-        data = {"x": '"hello\\nworld"'}
+        # A newline-terminated string is what a heredoc body looks like, and is
+        # the only shape converted -- see the deserializer tests for why.
+        data = {"x": '"hello\\nworld\\n"'}
         default = self._run_json_to_hcl(data)
         converted = self._run_json_to_hcl(data, ["--strings-to-heredocs"])
         self.assertNotEqual(default, converted)
diff --git a/test/unit/rules/test_strings.py b/test/unit/rules/test_strings.py
index ef800d91..eaf6340b 100644
--- a/test/unit/rules/test_strings.py
+++ b/test/unit/rules/test_strings.py
@@ -221,28 +221,28 @@ def test_serialize_no_preserve_extracts_content(self):
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"hello world"')
+        self.assertEqual(result, '"hello world\\n"')
 
     def test_serialize_no_preserve_multiline(self):
         token = HEREDOC_TEMPLATE("<<EOF\nline1\nline2\nEOF")
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"line1\\nline2"')
+        self.assertEqual(result, '"line1\\nline2\\n"')
 
     def test_serialize_no_preserve_escapes_quotes(self):
         token = HEREDOC_TEMPLATE('<<EOF\nsay "hello"\nEOF')
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"say \\"hello\\""')
+        self.assertEqual(result, '"say \\"hello\\"\\n"')
 
     def test_serialize_no_preserve_escapes_backslashes(self):
         token = HEREDOC_TEMPLATE("<<EOF\npath\\to\\file\nEOF")
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"path\\\\to\\\\file"')
+        self.assertEqual(result, '"path\\\\to\\\\file\\n"')
 
     def test_serialize_no_preserve_escapes_backslashes_before_quotes(self):
         token = HEREDOC_TEMPLATE('<<EOF\n\\"escaped\\"\nEOF')
@@ -250,21 +250,21 @@ def test_serialize_no_preserve_escapes_backslashes_before_quotes(self):
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
         # \ becomes \\, then " becomes \" → \\" and \\"
-        self.assertEqual(result, '"\\\\\\"escaped\\\\\\""')
+        self.assertEqual(result, '"\\\\\\"escaped\\\\\\"\\n"')
 
     def test_serialize_no_preserve_json_content(self):
         token = HEREDOC_TEMPLATE('<<EOF\n{"key": "value"}\nEOF')
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"{\\"key\\": \\"value\\"}"')
+        self.assertEqual(result, '"{\\"key\\": \\"value\\"}\\n"')
 
     def test_serialize_no_preserve_escapes_newlines(self):
         token = HEREDOC_TEMPLATE("<<EOF\nfirst\nsecond\nthird\nEOF")
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"first\\nsecond\\nthird"')
+        self.assertEqual(result, '"first\\nsecond\\nthird\\n"')
 
     def test_serialize_no_preserve_invalid_raises(self):
         token = HEREDOC_TEMPLATE("not a heredoc")
@@ -284,14 +284,14 @@ def test_serialize_strip_string_quotes_no_preserve(self):
         token = HEREDOC_TEMPLATE("<<EOF\nline1\nline2\nEOF")
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False, strip_string_quotes=True)
-        self.assertEqual(rule.serialize(opts), "line1\nline2")
+        self.assertEqual(rule.serialize(opts), "line1\nline2\n")
 
     def test_serialize_no_preserve_keeps_escaping_for_the_quoted_form(self):
         """Without strip_string_quotes the result is source, so escapes stay."""
         token = HEREDOC_TEMPLATE("<<EOF\nline1\nline2\nEOF")
         rule = HeredocTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
-        self.assertEqual(rule.serialize(opts), '"line1\\nline2"')
+        self.assertEqual(rule.serialize(opts), '"line1\\nline2\\n"')
 
 
 # --- HeredocTrimTemplateRule tests ---
@@ -319,46 +319,47 @@ def test_serialize_no_preserve_trims_indent(self):
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        # Extracted content: "    line1\n    line2"
-        # Lines: ["    line1", "    line2"], min_spaces=4
-        # Trimmed: ["line1", "line2"]
-        self.assertEqual(result, '"line1\\nline2"')
+        # Extracted content: "    line1\n    line2\n"
+        # Lines: ["    line1", "    line2", ""], margin=4 (the empty last line
+        # offers no measurement and is not trimmed)
+        # Trimmed: ["line1", "line2", ""]
+        self.assertEqual(result, '"line1\\nline2\\n"')
 
     def test_serialize_no_preserve_mixed_indent(self):
         token = HEREDOC_TRIM_TEMPLATE("<<-EOF\n  line1\n    line2\n  line3\nEOF")
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        # Content: "  line1\n    line2\n  line3", min_spaces=2
-        self.assertEqual(result, '"line1\\n  line2\\nline3"')
+        # Content: "  line1\n    line2\n  line3\n", margin=2
+        self.assertEqual(result, '"line1\\n  line2\\nline3\\n"')
 
     def test_serialize_no_preserve_escapes_quotes(self):
         token = HEREDOC_TRIM_TEMPLATE('<<-EOF\n    say "hello"\nEOF')
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"say \\"hello\\""')
+        self.assertEqual(result, '"say \\"hello\\"\\n"')
 
     def test_serialize_no_preserve_escapes_backslashes(self):
         token = HEREDOC_TRIM_TEMPLATE("<<-EOF\n    path\\to\\file\nEOF")
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"path\\\\to\\\\file"')
+        self.assertEqual(result, '"path\\\\to\\\\file\\n"')
 
     def test_serialize_no_preserve_json_content(self):
         token = HEREDOC_TRIM_TEMPLATE('<<-EOF\n    {"key": "value"}\nEOF')
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"{\\"key\\": \\"value\\"}"')
+        self.assertEqual(result, '"{\\"key\\": \\"value\\"}\\n"')
 
     def test_serialize_no_preserve_escapes_newlines(self):
         token = HEREDOC_TRIM_TEMPLATE("<<-EOF\n    first\n    second\n    third\nEOF")
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
         result = rule.serialize(opts)
-        self.assertEqual(result, '"first\\nsecond\\nthird"')
+        self.assertEqual(result, '"first\\nsecond\\nthird\\n"')
 
     def test_serialize_no_preserve_invalid_raises(self):
         token = HEREDOC_TRIM_TEMPLATE("not a heredoc")
@@ -378,11 +379,11 @@ def test_serialize_strip_string_quotes_no_preserve(self):
         token = HEREDOC_TRIM_TEMPLATE("<<-EOF\n    line1\n    line2\nEOF")
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False, strip_string_quotes=True)
-        self.assertEqual(rule.serialize(opts), "line1\nline2")
+        self.assertEqual(rule.serialize(opts), "line1\nline2\n")
 
     def test_serialize_no_preserve_keeps_escaping_for_the_quoted_form(self):
         """Without strip_string_quotes the result is source, so escapes stay."""
         token = HEREDOC_TRIM_TEMPLATE("<<-EOF\n    line1\n    line2\nEOF")
         rule = HeredocTrimTemplateRule([token])
         opts = SerializationOptions(preserve_heredocs=False)
-        self.assertEqual(rule.serialize(opts), '"line1\\nline2"')
+        self.assertEqual(rule.serialize(opts), '"line1\\nline2\\n"')
diff --git a/test/unit/test_api.py b/test/unit/test_api.py
index d6599fec..0c444152 100644
--- a/test/unit/test_api.py
+++ b/test/unit/test_api.py
@@ -556,7 +556,7 @@ def test_single_character_delimiter_empty_body(self):
 
     def test_single_character_delimiter_flattens(self):
         options = SerializationOptions(preserve_heredocs=False)
-        self.assertEqual(loads("a = <<E\nx\nE\n", serialization_options=options), {"a": '"x"'})
+        self.assertEqual(loads("a = <<E\nx\nE\n", serialization_options=options), {"a": '"x\\n"'})
 
     def test_single_character_delimiter_does_not_swallow_what_follows(self):
         self.assertEqual(loads("a = <<E\nx\nE\nb = 1\n"), {"a": '"<<E\nx\nE"', "b": 1})
@@ -584,12 +584,12 @@ class TestHeredocFlattenedToValue(TestCase):
 
     def test_value_has_real_newlines(self):
         result = loads("a = <<EOT\nline1\nline2\nEOT\n", serialization_options=self._VALUE)
-        self.assertEqual(result, {"a": "line1\nline2"})
+        self.assertEqual(result, {"a": "line1\nline2\n"})
 
     def test_trimmed_value_has_real_newlines(self):
         source = "a = <<-EOT\n  line1\n  line2\n  EOT\n"
         result = loads(source, serialization_options=self._VALUE)
-        self.assertEqual(result, {"a": "line1\nline2"})
+        self.assertEqual(result, {"a": "line1\nline2\n"})
 
     def test_multiline_secret_survives_intact(self):
         """The reported case: a heredoc-defined key block must stay multi-line."""
@@ -603,23 +603,24 @@ def test_multiline_secret_survives_intact(self):
             "}\n"
         )
         value = loads(source, serialization_options=self._VALUE)["keys"]["private"]
-        self.assertEqual(value.count("\n"), 2)
+        # Three lines, each terminated by its own newline -- the last included.
+        self.assertEqual(value.count("\n"), 3)
         self.assertNotIn("\\n", value)
         self.assertTrue(value.startswith("-----BEGIN"))
-        self.assertTrue(value.endswith("KEY BLOCK-----"))
+        self.assertTrue(value.endswith("KEY BLOCK-----\n"))
 
     def test_quoted_form_still_escapes(self):
         """Without strip_string_quotes the result is source and must escape."""
         result = loads("a = <<EOT\nline1\nline2\nEOT\n", serialization_options=self._SOURCE)
-        self.assertEqual(result, {"a": '"line1\\nline2"'})
+        self.assertEqual(result, {"a": '"line1\\nline2\\n"'})
 
     def test_embedded_quote_and_backslash_only_escaped_in_source_form(self):
         source = 'a = <<EOT\nsay "hi"\nback\\slash\nEOT\n'
         self.assertEqual(
             loads(source, serialization_options=self._VALUE),
-            {"a": 'say "hi"\nback\\slash'},
+            {"a": 'say "hi"\nback\\slash\n'},
         )
         self.assertEqual(
             loads(source, serialization_options=self._SOURCE),
-            {"a": '"say \\"hi\\"\\nback\\\\slash"'},
+            {"a": '"say \\"hi\\"\\nback\\\\slash\\n"'},
         )
diff --git a/test/unit/test_crlf.py b/test/unit/test_crlf.py
index f4ad7509..7f58fad1 100644
--- a/test/unit/test_crlf.py
+++ b/test/unit/test_crlf.py
@@ -15,7 +15,8 @@
 
 from unittest import TestCase
 
-from hcl2.api import loads, parses_to_tree, reconstruct, transform
+from hcl2.api import dumps, loads, parses_to_tree, reconstruct, transform
+from hcl2.deserializer import DeserializerOptions
 from hcl2.utils import SerializationOptions
 
 CR = "\r"
@@ -105,15 +106,21 @@ def test_closing_marker_leaves_no_trailing_carriage_return(self):
         self.assertTrue(result["a"].endswith('EOF"'), result["a"])
 
     def test_flattening_a_crlf_heredoc_does_not_raise(self):
-        """The heredoc patterns in utils.py run on an already-parsed token."""
+        r"""The heredoc patterns in utils.py run on an already-parsed token.
+
+        Every body line keeps its own `\r\n`, the last one included: OpenTofu
+        evaluates this source to `"x\r\ny\r\n"`. Both characters are written
+        escaped, because this form is quoted-string *source* -- see
+        `TestFlattenedCrlfHeredocsStayValidHcl`.
+        """
         options = SerializationOptions(preserve_heredocs=False)
         result = loads("a = <<EOF\r\nx\r\ny\r\nEOF\r\n", serialization_options=options)
-        self.assertEqual(result, {"a": '"x' + CR + '\\ny"'})
+        self.assertEqual(result, {"a": r'"x\r\ny\r\n"'})
 
     def test_trimmed_heredoc_flattens(self):
         options = SerializationOptions(preserve_heredocs=False)
         result = loads("a = <<-EOF\r\n  x\r\n  EOF\r\n", serialization_options=options)
-        self.assertEqual(result, {"a": '"x"'})
+        self.assertEqual(result, {"a": r'"x\r\n"'})
 
 
 class TestCrlfReconstruction(TestCase):
@@ -128,3 +135,112 @@ def test_lf_is_unchanged(self):
         source = "a = 1\nb = 2\n"
         output = reconstruct(transform(parses_to_tree(source)).to_lark())
         self.assertEqual(output, source)
+
+
+class TestFlattenedCrlfHeredocsStayValidHcl(TestCase):
+    r"""`preserve_heredocs=False` writes a quoted string, which cannot hold a CR.
+
+    The flattened form is source, not a value: it is the string another parser
+    -- or this one, on the next pass -- has to read back. A raw carriage return
+    inside quotes is not valid there. OpenTofu rejects `"a<CR>b"` with "No
+    closing marker was found for the string", while `"a\rb"` evaluates to a
+    carriage return, which is what the heredoc body actually held.
+
+    The value form is unaffected: it hands back the body, so its newlines and
+    carriage returns stay real characters.
+    """
+
+    FLAT = SerializationOptions(preserve_heredocs=False)
+    VALUE = SerializationOptions(preserve_heredocs=False, strip_string_quotes=True)
+
+    def test_heredoc_source_form_escapes_carriage_returns(self):
+        source = loads("a = <<EOF\r\nx\r\ny\r\nEOF\r\n", serialization_options=self.FLAT)["a"]
+        self.assertNotIn(CR, source)
+        self.assertEqual(source, r'"x\r\ny\r\n"')
+
+    def test_trim_heredoc_source_form_escapes_carriage_returns(self):
+        source = loads("a = <<-EOF\r\n  x\r\n  y\r\nEOF\r\n", serialization_options=self.FLAT)["a"]
+        self.assertNotIn(CR, source)
+        self.assertEqual(source, r'"x\r\ny\r\n"')
+
+    def test_value_form_keeps_real_carriage_returns(self):
+        value = loads("a = <<EOF\r\nx\r\ny\r\nEOF\r\n", serialization_options=self.VALUE)["a"]
+        self.assertEqual(value, "x\r\ny\r\n")
+
+    def test_a_lone_cr_inside_a_line_is_escaped_too(self):
+        # Not a line ending: a carriage return the body carries mid-line.
+        source = loads("a = <<EOF\nx\ry\nEOF\n", serialization_options=self.FLAT)["a"]
+        self.assertEqual(source, r'"x\ry\n"')
+
+
+class TestCrlfSurvivesFlattenAndRestore(TestCase):
+    r"""Flattening a CRLF heredoc and writing it back preserves the value.
+
+    The two halves have to be each other's inverse. The flattened form writes
+    a carriage return as `\r`, because it is quoted-string source; the writer
+    then has to resolve `\r` back into the character, because a heredoc
+    interprets no escape at all -- a body holding a backslash and an `r` is
+    those two characters, and OpenTofu reads it that way.
+
+    The target value is not this implementation's opinion: OpenTofu evaluates
+    a CRLF file containing `<<EOF\r\nx\r\ny\r\nEOF\r\n` to `"x\r\ny\r\n"`,
+    checked with `tofu console` against v1.12.5.
+
+    Each half was already covered on its own -- flattening a CRLF heredoc, and
+    restoring an LF string -- which is exactly why the combination could break
+    without a test noticing.
+    """
+
+    FLAT = SerializationOptions(preserve_heredocs=False)
+    VALUE = SerializationOptions(preserve_heredocs=False, strip_string_quotes=True)
+    HEREDOCS = DeserializerOptions(strings_to_heredocs=True)
+
+    def _restore(self, source: str) -> str:
+        flattened = loads(source, serialization_options=self.FLAT)
+        return dumps(flattened, deserializer_options=self.HEREDOCS)
+
+    def _round_trip(self, source: str) -> str:
+        restored = self._restore(source)
+        return loads(restored, serialization_options=self.VALUE)["a"]
+
+    def test_the_value_is_unchanged(self):
+        self.assertEqual(self._round_trip("a = <<EOF\r\nx\r\ny\r\nEOF\r\n"), "x\r\ny\r\n")
+
+    def test_the_written_body_holds_real_carriage_returns(self):
+        restored = self._restore("a = <<EOF\r\nx\r\ny\r\nEOF\r\n")
+        self.assertNotIn("\\r", restored)
+        self.assertEqual(restored, "a = <<EOF\nx\r\ny\r\nEOF\n")
+
+    def test_a_trimmed_heredoc_survives_too(self):
+        self.assertEqual(self._round_trip("a = <<-EOF\r\n  x\r\n  y\r\nEOF\r\n"), "x\r\ny\r\n")
+
+    def test_a_lone_carriage_return_keeps_the_value_quoted(self):
+        r"""A heredoc body cannot hold a `\r` that does not end a line.
+
+        OpenTofu rejects `<<EOF\nx\ry\nEOF` with "No closing marker was
+        found for the string", while the quoted `"x\ry\n"` it came from is
+        valid and evaluates to that carriage return. Writing the heredoc
+        anyway traded a wrong value for an unreadable file; the value stays
+        quoted instead, as one that does not end in a newline does.
+        """
+        source = "a = <<EOF\nx\ry\nEOF\n"
+        restored = self._restore(source)
+        self.assertEqual(restored, 'a = "x\\ry\\n"\n')
+        self.assertEqual(self._round_trip(source), "x\ry\n")
+
+    def test_a_crlf_body_carrying_the_delimiter_gets_another_one(self):
+        r"""`EOF\r` ends a heredoc in Terraform, so it counts when choosing.
+
+        The body is split on `\n`, so a CRLF line hands back its own `\r`
+        and a marker check that only allowed spaces and tabs never saw it.
+        OpenTofu evaluates `<<EOF\nbody\r\nEOF\r\n` to `"body\r\n"` --
+        it ends there -- so writing `<<EOF` over a CRLF body containing that
+        line produced a file that closed early and no longer parsed.
+        """
+        # Such a body cannot be written as a heredoc source to read from --
+        # this parser ends it at that line too, as Terraform does -- so the
+        # value arrives the way it would in practice, from a quoted string.
+        quoted = r'"x\r\nEOF\r\ny\r\n"'
+        written = dumps({"a": quoted}, deserializer_options=self.HEREDOCS)
+        self.assertEqual(written, "a = <<EOF_1\nx\r\nEOF\r\ny\r\nEOF_1\n")
+        self.assertEqual(loads(written, serialization_options=self.VALUE)["a"], "x\r\nEOF\r\ny\r\n")
diff --git a/test/unit/test_deserializer.py b/test/unit/test_deserializer.py
index 25a88df6..bf674f5c 100644
--- a/test/unit/test_deserializer.py
+++ b/test/unit/test_deserializer.py
@@ -200,9 +200,27 @@ def test_heredocs_to_strings_skips_trim_heredoc(self):
     def test_strings_to_heredocs_with_newline(self):
         opts = DeserializerOptions(strings_to_heredocs=True)
         d = _deser(opts)
-        result = d._deserialize_text('"line1\\nline2"')
+        result = d._deserialize_text('"line1\\nline2\\n"')
         self.assertIsInstance(result, HeredocTemplateRule)
 
+    def test_strings_to_heredocs_body_is_not_given_an_extra_line(self):
+        """The value's own trailing newline is the one before the marker."""
+        opts = DeserializerOptions(strings_to_heredocs=True)
+        d = _deser(opts)
+        result = d._deserialize_text('"line1\\nline2\\n"')
+        self.assertEqual(result.heredoc.value, "<<EOF\nline1\nline2\nEOF")
+
+    def test_strings_to_heredocs_skips_a_value_without_a_trailing_newline(self):
+        r"""A heredoc body always ends in a newline, so such a value is not one.
+
+        Writing `"line1\nline2"` as a heredoc would hand back `line1\nline2\n`
+        on the next read, which is a different value.
+        """
+        opts = DeserializerOptions(strings_to_heredocs=True)
+        d = _deser(opts)
+        result = d._deserialize_text('"line1\\nline2"')
+        self.assertIsInstance(result, StringRule)
+
     def test_strings_to_heredocs_without_newline(self):
         opts = DeserializerOptions(strings_to_heredocs=True)
         d = _deser(opts)
diff --git a/test/unit/test_heredoc_line_end.py b/test/unit/test_heredoc_line_end.py
new file mode 100644
index 00000000..289a78e3
--- /dev/null
+++ b/test/unit/test_heredoc_line_end.py
@@ -0,0 +1,77 @@
+# pylint: disable=C0103,C0114,C0115,C0116
+r"""A heredoc ends its own line, wherever it is written (GH #338).
+
+A heredoc ends at its closing marker, on a line of its own, so whatever comes
+next has to start the following line. Inside a list or an object that is the
+separator, and `EOF,` closes nothing: the file this library had just written
+did not parse, here or in Terraform.
+
+A top-level attribute survived only because the newline after it comes from
+the document rather than from the heredoc.
+
+The distinction the fix turns on: `HEREDOC_TEMPLATE` matches through the
+newline after the marker, so a token that came from the parser already ends
+the line. One built by the deserializer does not, and that is the only case
+that needs help -- which is why reconstructing a parsed document is byte for
+byte what it was.
+
+Checked against OpenTofu v1.12.5: the emitted list reads back as
+`["line1\n", "p"]`.
+"""
+
+from unittest import TestCase
+
+from hcl2.api import dumps, loads
+from hcl2.deserializer import DeserializerOptions
+from hcl2.utils import SerializationOptions
+
+HEREDOCS = DeserializerOptions(strings_to_heredocs=True)
+FLAT = SerializationOptions(preserve_heredocs=False)
+
+
+class TestAHeredocInAContainer(TestCase):
+    def _restore(self, source: str) -> str:
+        return dumps(loads(source, serialization_options=FLAT), deserializer_options=HEREDOCS)
+
+    def test_in_a_list(self):
+        written = self._restore('a = [<<EOT\nline1\nEOT\n, "p"]\n')
+        self.assertNotIn("EOF,", written)
+        loads(written)
+
+    def test_in_an_object(self):
+        written = self._restore("a = { k = <<EOT\nline1\nEOT\n }\n")
+        self.assertNotIn("EOF,", written)
+        loads(written)
+
+    def test_as_the_only_element(self):
+        written = self._restore("a = [<<EOT\nline1\nEOT\n]\n")
+        loads(written)
+
+    def test_two_of_them(self):
+        written = self._restore("a = [<<EOT\none\nEOT\n, <<EOT\ntwo\nEOT\n]\n")
+        loads(written)
+
+    def test_the_values_survive(self):
+        source = 'a = [<<EOT\nline1\nEOT\n, "p"]\n'
+        restored = self._restore(source)
+        self.assertEqual(
+            loads(restored, serialization_options=FLAT), loads(source, serialization_options=FLAT)
+        )
+
+    def test_a_top_level_attribute_still_works(self):
+        written = self._restore("a = <<EOT\nline1\nEOT\n")
+        self.assertEqual(written, "a = <<EOF\nline1\nEOF\n")
+
+
+class TestReconstructionIsUnchanged(TestCase):
+    """A parsed heredoc carries its own newline, so nothing is added to it."""
+
+    def test_a_document_round_trips_byte_for_byte(self):
+        for source in (
+            "locals {\n  a = <<EOT\n  x\n  EOT\n}\n",
+            "a = <<EOT\nx\nEOT\n",
+            "a = <<-EOT\n  x\n  EOT\n",
+            'locals {\n  a = <<EOT\n  x\n  EOT\n  b = "y"\n}\n',
+        ):
+            with self.subTest(source=source):
+                self.assertEqual(dumps(loads(source)), source)
diff --git a/test/unit/test_heredoc_matches_terraform.py b/test/unit/test_heredoc_matches_terraform.py
new file mode 100644
index 00000000..901ea299
--- /dev/null
+++ b/test/unit/test_heredoc_matches_terraform.py
@@ -0,0 +1,180 @@
+# pylint: disable=C0103,C0114,C0115,C0116
+r"""Flattened heredoc bodies match what Terraform/OpenTofu evaluate.
+
+Every expectation in this file was produced by evaluating the same source with
+OpenTofu v1.12.5 (`tofu console`, `jsonencode` of the resulting local), not by
+reading the spec. `bin/heredoc_ground_truth` re-derives the `CASES` table below
+from whatever Terraform-compatible binary is on PATH, so that provenance can be
+checked rather than taken on trust. It is deliberately not part of the test run:
+the suite must not need a Terraform binary to pass.
+
+Three things used to differ:
+
+1. The newline before the closing marker was dropped, so `<<EOT\nline\nEOT`
+   came back as `"line"` rather than `"line\n"`. The spec ends the template
+   where the delimiter "subsequently appears again on a line of its own", so
+   every content line, the last one included, is terminated by its own newline.
+2. `<<-` measured its indent with `lstrip(" ")`, so a tab-indented heredoc
+   measured zero on every line and was not dedented at all. The spec says
+   "spaces", but the reference implementation dedents tabs too.
+3. A whitespace-only line was excluded from the measurement and then trimmed
+   anyway, so a six-space line inside a four-space heredoc came back with two.
+
+None of this was a regression -- 7.2.1 returned the same values -- so these
+are new expectations rather than restored ones.
+"""
+
+from unittest import TestCase
+
+from hcl2.api import dumps, loads
+from hcl2.deserializer import DeserializerOptions
+from hcl2.utils import SerializationOptions
+
+_VALUE = SerializationOptions(preserve_heredocs=False, strip_string_quotes=True)
+
+# (source expression, value OpenTofu evaluates it to)
+CASES = [
+    ("<<EOT\nline\nEOT", "line\n"),
+    ("<<EOT\nbody  \n\nEOT", "body  \n\n"),
+    ("<<EOT\nx\n   EOT", "x\n"),
+    ("<<EOT\nx   \nEOT", "x   \n"),
+    ("<<EOT\nx\n\ny\nEOT", "x\n\ny\n"),
+    ("<<EOT\nEOT", ""),
+    ("<<EOT\n\nEOT", "\n"),
+    ("<<EOT\n\n\nEOT", "\n\n"),
+    ("<<-EOT\n  a\n    b\n  EOT", "a\n  b\n"),
+    ("<<-EOT\n\ta\n\t\tb\n\tEOT", "a\n\tb\n"),
+    ("<<-EOT\n    a\n      \n    b\n    EOT", "a\n      \nb\n"),
+    ("<<-EOT\n  x\n\n  EOT", "x\n\n"),
+    ("<<-EOT\n    a\n  b\n  EOT", "  a\nb\n"),
+    ("<<-EOT\nEOT", ""),
+    ("<<EOT\r\nx\r\ny\r\nEOT", "x\r\ny\r\n"),
+    ("<<-EOT\r\n  x\r\n  EOT", "x\r\n"),
+    # `<<-` measures whitespace, not spaces and tabs. OpenTofu dedents a body
+    # indented with a non-breaking space, a vertical tab, a form feed or an
+    # ideographic space exactly as it dedents one indented with spaces, so
+    # measuring `line.lstrip()` matches it and `line.lstrip(" \t")` would not:
+    # against the stricter reading these bodies come back with their indent
+    # still attached.
+    ("<<-EOT\n\u00a0a\n\u00a0b\n\u00a0EOT", "a\nb\n"),
+    ("<<-EOT\n\va\n\vb\n\vEOT", "a\nb\n"),
+    ("<<-EOT\n\fa\n\fb\n\fEOT", "a\nb\n"),
+    ("<<-EOT\n\u3000a\n\u3000b\n\u3000EOT", "a\nb\n"),
+]
+
+
+class TestHeredocValuesMatchOpenTofu(TestCase):
+    maxDiff = None
+
+    def test_every_case(self):
+        for source, expected in CASES:
+            with self.subTest(source=source):
+                self.assertEqual(loads(f"x = {source}\n", serialization_options=_VALUE)["x"], expected)
+
+
+class TestTrailingNewline(TestCase):
+    """The last content line is terminated like every other one."""
+
+    def test_one_line_body_keeps_its_newline(self):
+        self.assertEqual(loads("x = <<EOT\nline\nEOT\n", serialization_options=_VALUE)["x"], "line\n")
+
+    def test_the_marker_indent_is_still_not_content(self):
+        source = "x = <<EOT\nline\n      EOT\n"
+        self.assertEqual(loads(source, serialization_options=_VALUE)["x"], "line\n")
+
+    def test_an_empty_body_stays_empty(self):
+        # There is no content line, so there is no newline to keep.
+        self.assertEqual(loads("x = <<EOT\nEOT\n", serialization_options=_VALUE)["x"], "")
+
+
+class TestTrimMeasuresTabs(TestCase):
+    """`<<-` dedents tab-indented bodies, as the reference implementation does."""
+
+    def test_tabs_are_dedented(self):
+        source = "x = <<-EOT\n\ta\n\t\tb\n\tEOT\n"
+        self.assertEqual(loads(source, serialization_options=_VALUE)["x"], "a\n\tb\n")
+
+    def test_spaces_are_unaffected(self):
+        source = "x = <<-EOT\n  a\n    b\n  EOT\n"
+        self.assertEqual(loads(source, serialization_options=_VALUE)["x"], "a\n  b\n")
+
+    def test_a_mixed_indent_measures_characters(self):
+        # One tab and one space are one character each, so the margin is 1.
+        source = "x = <<-EOT\n\ta\n b\n EOT\n"
+        self.assertEqual(loads(source, serialization_options=_VALUE)["x"], "a\nb\n")
+
+
+class TestWhitespaceOnlyLines(TestCase):
+    """A line that offers no measurement is not trimmed by one either."""
+
+    def test_a_whitespace_line_keeps_its_whitespace(self):
+        source = "x = <<-EOT\n    a\n      \n    b\n    EOT\n"
+        self.assertEqual(loads(source, serialization_options=_VALUE)["x"], "a\n      \nb\n")
+
+    def test_a_blank_line_does_not_cancel_the_dedent(self):
+        source = "x = <<-EOT\n  a\n\n  b\n  EOT\n"
+        self.assertEqual(loads(source, serialization_options=_VALUE)["x"], "a\n\nb\n")
+
+
+class TestQuotedSourceFormAgrees(TestCase):
+    """Without `strip_string_quotes` the result is source for the same value."""
+
+    _SOURCE = SerializationOptions(preserve_heredocs=False)
+
+    def test_quoted_form_carries_the_trailing_newline(self):
+        result = loads("x = <<EOT\nline\nEOT\n", serialization_options=self._SOURCE)["x"]
+        self.assertEqual(result, '"line' + chr(92) + 'n"')
+
+    def test_the_two_forms_describe_the_same_string(self):
+        source = "x = <<-EOT\n  a\n    b\n  EOT\n"
+        value = loads(source, serialization_options=_VALUE)["x"]
+        quoted = loads(source, serialization_options=self._SOURCE)["x"]
+        # Re-read the quoted form as HCL and it yields the value back.
+        reread = loads(f"x = {quoted}\n", serialization_options=_VALUE)["x"]
+        self.assertEqual(reread, value)
+
+
+class TestWrittenDelimiterCannotCloseEarly(TestCase):
+    r"""The delimiter is chosen against the body, not assumed to be `EOF`.
+
+    A log excerpt, a shell script, an embedded config -- the payloads people
+    put in heredocs -- are exactly the values that contain the word `EOF`.
+    Writing `<<EOF` over one produced a file that closed at the body's own
+    line and no longer parsed, here or in Terraform.
+
+    The lines that count as closing markers are Terraform's, which are looser
+    than this grammar's: OpenTofu v1.12.5 ends a heredoc on `EOF  ` and
+    evaluates `<<EOF\nbody\nEOF  \n` to `"body\n"`, while `HEREDOC_TEMPLATE`
+    here requires the newline to follow the word. Choosing against the looser
+    reading is what keeps the written file readable by both.
+    """
+
+    HEREDOCS = DeserializerOptions(strings_to_heredocs=True)
+    VALUE = SerializationOptions(preserve_heredocs=False, strip_string_quotes=True)
+
+    def _write(self, value: str) -> str:
+        return dumps({"x": value}, deserializer_options=self.HEREDOCS)
+
+    def _round_trip(self, value: str) -> str:
+        return loads(self._write(value), serialization_options=self.VALUE)["x"]
+
+    def test_an_ordinary_body_still_uses_eof(self):
+        self.assertEqual(self._write(r'"plain\n"'), "x = <<EOF\nplain\nEOF\n")
+
+    def test_a_body_holding_the_delimiter_gets_another_one(self):
+        self.assertEqual(self._write(r'"first\nEOF\nlast\n"'), "x = <<EOF_1\nfirst\nEOF\nlast\nEOF_1\n")
+
+    def test_an_indented_marker_line_counts(self):
+        self.assertEqual(self._write('"  EOF\\nx\\n"'), "x = <<EOF_1\n  EOF\nx\nEOF_1\n")
+
+    def test_a_trailing_space_marker_line_counts_because_terraform_ends_there(self):
+        self.assertEqual(self._write('"EOF  \\nkeeps\\n"'), "x = <<EOF_1\nEOF  \nkeeps\nEOF_1\n")
+
+    def test_the_search_continues_past_a_taken_variant(self):
+        self.assertEqual(self._write(r'"EOF\nEOF_1\ny\n"'), "x = <<EOF_2\nEOF\nEOF_1\ny\nEOF_2\n")
+
+    def test_every_case_survives_the_round_trip(self):
+        for value in (r'"plain\n"', r'"first\nEOF\nlast\n"', '"  EOF\\nx\\n"', r'"EOF\nEOF_1\ny\n"'):
+            with self.subTest(value=value):
+                original = loads(f"x = {value}\n", serialization_options=self.VALUE)["x"]
+                self.assertEqual(self._round_trip(value), original)
diff --git a/test/unit/test_heredoc_trailing_whitespace.py b/test/unit/test_heredoc_trailing_whitespace.py
index bc0c1ddf..ce2c6ea7 100644
--- a/test/unit/test_heredoc_trailing_whitespace.py
+++ b/test/unit/test_heredoc_trailing_whitespace.py
@@ -11,13 +11,17 @@
 
 The blanket rstrip was doing two jobs at once: dropping that separating
 newline, and dropping the closing marker line's own indentation. Splitting
-them (`_strip_closing_marker_line`) is what lets body content survive while
+them (`_strip_closing_marker_indent`) is what lets body content survive while
 the marker line still disappears, and it applies to `<<MARKER` and
 `<<-MARKER` alike.
 
-Note: expected values below are built with BS (a literal backslash character,
-via chr(92)) rather than hand-written escapes, to avoid any ambiguity between
-"a literal backslash followed by n" and "a real newline character".
+Every body below ends in a newline, because the last content line is
+terminated by its own newline just like the others -- see
+`test_heredoc_matches_terraform.py`, which checks each case against OpenTofu.
+
+Note: expected values below are built with NL, a literal backslash (chr(92))
+followed by "n", rather than hand-written escapes, to avoid any ambiguity
+between "a literal backslash followed by n" and "a real newline character".
 """
 
 from unittest import TestCase
@@ -26,26 +30,26 @@
 from hcl2.utils import SerializationOptions
 
 _FLATTEN = SerializationOptions(preserve_heredocs=False)
-BS = chr(92)  # a single literal backslash character
+NL = chr(92) + "n"  # an escaped newline, as it appears in the quoted form
 
 
 class TestHeredocTrailingWhitespace(TestCase):
     def test_trailing_blank_line_preserved(self):
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) + chr(10) + "MARKER" + chr(10)
         result = loads(src, serialization_options=_FLATTEN)
-        expected = '"x' + BS + 'n"'
+        expected = '"x' + NL + NL + '"'
         self.assertEqual(result["a"], expected)
 
     def test_two_trailing_blank_lines_preserved(self):
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) * 3 + "MARKER" + chr(10)
         result = loads(src, serialization_options=_FLATTEN)
-        expected = '"x' + BS + "n" + BS + 'n"'
+        expected = '"x' + NL * 3 + '"'
         self.assertEqual(result["a"], expected)
 
     def test_trailing_spaces_preserved(self):
         src = "a = <<MARKER" + chr(10) + "x   " + chr(10) + "MARKER" + chr(10)
         result = loads(src, serialization_options=_FLATTEN)
-        self.assertEqual(result["a"], '"x   "')
+        self.assertEqual(result["a"], '"x   ' + NL + '"')
 
     def test_three_distinct_sources_no_longer_collapse(self):
         blank_line = loads(
@@ -63,18 +67,18 @@ def test_three_distinct_sources_no_longer_collapse(self):
         values = {blank_line, two_blank, trailing_spaces}
         self.assertEqual(len(values), 3)
 
-    def test_plain_one_line_heredoc_unaffected(self):
-        # The single final newline separating content from the marker line
-        # is still dropped -- this is the established, non-regressed
-        # behavior (Terraform's own one-liner golden semantics).
+    def test_plain_one_line_heredoc_keeps_its_newline(self):
+        # The one content line is terminated by its own newline, so the value
+        # is "x\n". Both this library and 7.2.1 used to return "x"; OpenTofu
+        # evaluates the same source to "x\n".
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) + "MARKER" + chr(10)
         result = loads(src, serialization_options=_FLATTEN)
-        self.assertEqual(result["a"], '"x"')
+        self.assertEqual(result["a"], '"x' + NL + '"')
 
     def test_interior_blank_line_still_preserved(self):
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) * 2 + "y" + chr(10) + "MARKER" + chr(10)
         result = loads(src, serialization_options=_FLATTEN)
-        expected = '"x' + BS + "n" + BS + 'ny"'
+        expected = '"x' + NL + NL + "y" + NL + '"'
         self.assertEqual(result["a"], expected)
 
 
@@ -83,26 +87,26 @@ class TestHeredocIndentedClosingMarker(TestCase):
 
     The grammar allows whitespace before the closing marker, and the spec says
     it "may also have an arbitrary number of spaces preceding it on its line".
-    Removing only a newline would leave that indentation behind as a spurious
-    extra line.
+    That indentation goes; the newline before it stays, being the last content
+    line's own terminator.
     """
 
     def test_space_indented_marker(self):
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) + "   MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x"')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + NL + '"')
 
     def test_tab_indented_marker(self):
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) + chr(9) + "MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x"')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + NL + '"')
 
     def test_indented_marker_after_a_blank_line(self):
         src = "a = <<MARKER" + chr(10) + "x" + chr(10) * 2 + "   MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + BS + 'n"')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + NL + NL + '"')
 
     def test_content_trailing_spaces_survive_an_indented_marker(self):
         """The content line ends with its own newline, so its spaces are safe."""
         src = "a = <<MARKER" + chr(10) + "x   " + chr(10) + "   MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x   "')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x   ' + NL + '"')
 
 
 class TestTrimmedHeredocTrailingWhitespace(TestCase):
@@ -115,27 +119,28 @@ class TestTrimmedHeredocTrailingWhitespace(TestCase):
 
     def test_trailing_blank_line_preserved(self):
         src = "a = <<-MARKER" + chr(10) + "  x" + chr(10) * 2 + "  MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + BS + 'n"')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + NL + NL + '"')
 
     def test_two_trailing_blank_lines_preserved(self):
         src = "a = <<-MARKER" + chr(10) + "  x" + chr(10) * 3 + "  MARKER" + chr(10)
-        expected = '"x' + BS + "n" + BS + 'n"'
+        expected = '"x' + NL * 3 + '"'
         self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], expected)
 
     def test_trailing_spaces_preserved(self):
         src = "a = <<-MARKER" + chr(10) + "  x   " + chr(10) + "  MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x   "')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x   ' + NL + '"')
 
     def test_dedent_still_applies(self):
         src = "a = <<-MARKER" + chr(10) + "  x" + chr(10) + "  y" + chr(10) + "  MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + BS + 'ny"')
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + NL + "y" + NL + '"')
 
     def test_uneven_dedent_keeps_relative_indentation(self):
         src = "a = <<-MARKER" + chr(10) + "  x" + chr(10) + "    y" + chr(10) + "  MARKER" + chr(10)
-        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], '"x' + BS + 'n  y"')
+        expected = '"x' + NL + "  y" + NL + '"'
+        self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], expected)
 
     def test_blank_line_does_not_cancel_the_dedent(self):
         """A blank line has no leading string to measure, so it must not count."""
         src = "a = <<-MARKER" + chr(10) + "  x" + chr(10) * 2 + "  y" + chr(10) + "  MARKER" + chr(10)
-        expected = '"x' + BS + "n" + BS + 'ny"'
+        expected = '"x' + NL + NL + "y" + NL + '"'
         self.assertEqual(loads(src, serialization_options=_FLATTEN)["a"], expected)