diff --git a/crates/webui-parser/benches/parser_bench.rs b/crates/webui-parser/benches/parser_bench.rs
index 2767837b9..61b2e368b 100644
--- a/crates/webui-parser/benches/parser_bench.rs
+++ b/crates/webui-parser/benches/parser_bench.rs
@@ -625,6 +625,34 @@ fn client_template_directives_bench(c: &mut Criterion) {
     });
 }
 
+fn client_template_whitespace_bench(c: &mut Criterion) {
+    let lf = format!(
+        "<section>{}</section>",
+        "\n  <button>\n    {{label}}\n  </button>".repeat(100)
+    );
+    let mut group = c.benchmark_group("client_template_whitespace");
+    for (name, input) in [
+        ("lf_100", lf.clone()),
+        ("crlf_100", lf.replace('\n', "\r\n")),
+        (
+            "entities_100",
+            lf.replace("{{label}}", "&lt; {{label}} &amp;"),
+        ),
+    ] {
+        group.throughput(Throughput::Bytes(input.len() as u64));
+        group.bench_with_input(name, &input, |b, html| {
+            b.iter(|| {
+                webui_parser::plugin::webui::generate_compiled_template(
+                    "bench-whitespace",
+                    black_box(html),
+                )
+                .unwrap_or_else(|error| panic!("client text compilation failed: {error}"))
+            });
+        });
+    }
+    group.finish();
+}
+
 fn parser_isolated_bench(c: &mut Criterion) {
     let mut group = c.benchmark_group("parser_isolated");
     for (name, input) in [
@@ -682,6 +710,7 @@ criterion_group!(
     parser_text_vs_directive_bench,
     parser_adversarial_bench,
     client_template_directives_bench,
+    client_template_whitespace_bench,
     parser_isolated_bench,
     css_token_analysis_bench
 );
diff --git a/crates/webui-parser/src/lib.rs b/crates/webui-parser/src/lib.rs
index d739cb6be..1b0750035 100644
--- a/crates/webui-parser/src/lib.rs
+++ b/crates/webui-parser/src/lib.rs
@@ -3943,9 +3943,9 @@ impl HtmlParser {
         let parsed_fragments = self.handlebars_parser.parse(content)?;
         for fragment in parsed_fragments {
             if let Some(Fragment::Raw(raw)) = fragment.fragment.as_ref() {
-                if Self::should_emit_text_content(&raw.value) {
-                    self.add_raw_fragment(&raw.value);
-                }
+                // Whitespace inside an emitted text run is part of the binding,
+                // not inter-element formatting. Client text parts retain it too.
+                self.add_raw_fragment(&raw.value);
             } else if let Some(Fragment::Signal(signal)) = fragment.fragment.as_ref() {
                 if signal.raw && is_html_text_only_scope(self.boundary_parent_scope) {
                     self.add_fragment(
@@ -5761,6 +5761,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_parse_preserves_whitespace_inside_bound_text_runs() -> Result<()> {
+        let mut parser = HtmlParser::new();
+        parser.parse(
+            "test.html",
+            "\n  <button>\n    {{title}}\n  </button>\n  <pre>  {{details}}\n  </pre>\n",
+        )?;
+        let records = parser.into_fragment_records();
+        assert_stream!(
+            records,
+            "test.html",
+            [
+                raw("<button>\n    "),
+                signal("title"),
+                raw("\n  </button><pre>  "),
+                signal("details"),
+                raw("\n  </pre>"),
+            ]
+        );
+        Ok(())
+    }
+
     #[test]
     fn test_invalid_for_each_is_template_diagnostic() {
         let mut parser = HtmlParser::new();
@@ -6697,7 +6719,15 @@ mod tests {
             [for_loop("item", "category.items", "for-2"),]
         );
 
-        assert_stream!(fragment_records, "for-2", [signal("item.title"),]);
+        assert_stream!(
+            fragment_records,
+            "for-2",
+            [
+                raw("\n                   "),
+                signal("item.title"),
+                raw("\n                "),
+            ]
+        );
     }
 
     #[test]
diff --git a/crates/webui-parser/src/plugin/webui.rs b/crates/webui-parser/src/plugin/webui.rs
index a517ba837..63e63bc49 100644
--- a/crates/webui-parser/src/plugin/webui.rs
+++ b/crates/webui-parser/src/plugin/webui.rs
@@ -541,6 +541,7 @@ struct TemplateSource<'a> {
     source: &'a str,
     range: Range<usize>,
     repeat_key: Option<usize>,
+    trim_boundary_formatting: bool,
 }
 
 impl<'a> From<&'a str> for TemplateSource<'a> {
@@ -549,6 +550,7 @@ impl<'a> From<&'a str> for TemplateSource<'a> {
             source,
             range: 0..source.len(),
             repeat_key: None,
+            trim_boundary_formatting: false,
         }
     }
 }
@@ -563,15 +565,17 @@ impl<'a> TemplateSource<'a> {
             source: self.source,
             range: self.range.start + range.start..self.range.start + range.end,
             repeat_key: self.repeat_key,
+            trim_boundary_formatting: false,
         }
     }
 
-    fn trimmed(mut self) -> Self {
+    fn trim_boundary_formatting(mut self) -> Self {
         let html = self.html();
         let trimmed = html.trim_start();
-        let leading = html.len() - trimmed.len();
-        self.range.start += leading;
-        self.range.end = self.range.start + trimmed.trim_end().len();
+        if trimmed.is_empty() || trimmed.starts_with('<') {
+            self.range.start += html.len() - trimmed.len();
+        }
+        self.trim_boundary_formatting = true;
         self
     }
 
@@ -794,8 +798,8 @@ fn generate_compiled_template_with_root_source(
     shadow_dom: bool,
     scriptless: bool,
 ) -> Result<CompiledTemplatePayload> {
-    let source = TemplateSource::from(html_content).trimmed();
-    let trimmed = source.html();
+    let source = TemplateSource::from(html_content);
+    let trimmed = html_content.trim();
     let shadow_body = shadow_template_body_range(trimmed);
     let authored_shadow_root = shadow_body.is_some();
     let mut root_events = if authored_shadow_root {
@@ -810,7 +814,13 @@ fn generate_compiled_template_with_root_source(
     {
         root_events = extract_root_events(tag_name, raw_root)?;
     }
-    let body = shadow_body.map_or_else(|| source.clone(), |range| source.slice(range));
+    let body = shadow_body.map_or_else(
+        || source.clone().trim_boundary_formatting(),
+        |range| {
+            let leading = html_content.len() - html_content.trim_start().len();
+            source.slice(leading + range.start..leading + range.end)
+        },
+    );
     let meta = compile_to_metadata(tag_name, body, root_events)?;
     let build_meta = collect_template_build_metadata(&meta);
     if scriptless && build_meta.has_events {
@@ -1647,6 +1657,7 @@ fn compile_section(
     let bytes = input.as_bytes();
     let len = bytes.len();
     let mut i = 0;
+    let mut last_markup_end = 0;
 
     while i < len {
         if !input.is_char_boundary(i) {
@@ -1666,6 +1677,7 @@ fn compile_section(
             if remaining.starts_with("<!--") {
                 if let Some(close) = remaining.find("-->") {
                     i += close + 3;
+                    last_markup_end = i;
                     continue;
                 }
             }
@@ -1682,6 +1694,7 @@ fn compile_section(
                     meta.conditionals.push((cond, block_index));
                     meta.html.push_str(&format!("<!--c:{idx}-->"));
                     i += consumed;
+                    last_markup_end = i;
                     continue;
                 }
             }
@@ -1706,6 +1719,7 @@ fn compile_section(
                     });
                     meta.html.push_str(&format!("<!--r:{idx}-->"));
                     i += repeat.consumed;
+                    last_markup_end = i;
                     continue;
                 }
             }
@@ -1715,6 +1729,7 @@ fn compile_section(
                 compile_style_content(&input[open_end..close_start], &mut meta);
                 meta.html.push_str(&input[close_start..close_end]);
                 i = close_end;
+                last_markup_end = i;
                 continue;
             }
 
@@ -1724,6 +1739,7 @@ fn compile_section(
                 if let Some(consumed) = find_element_end(remaining, "outlet") {
                     meta.html.push_str("<outlet></outlet>");
                     i += consumed;
+                    last_markup_end = i;
                     continue;
                 }
             }
@@ -1736,6 +1752,7 @@ fn compile_section(
             {
                 meta.html.push_str(&tag_html);
                 i += consumed;
+                last_markup_end = i;
                 continue;
             }
         }
@@ -1765,6 +1782,10 @@ fn compile_section(
         }
     }
 
+    if source.trim_boundary_formatting && input[last_markup_end..].trim().is_empty() {
+        let trailing = len - last_markup_end;
+        meta.html.truncate(meta.html.len() - trailing);
+    }
     Ok(meta)
 }
 
@@ -1915,6 +1936,7 @@ fn finalize_template_section(meta: &mut TemplateSectionMeta) {
     process_fragment_children(
         &nodes,
         0,
+        false,
         &text_bindings,
         &mut finalized_html,
         &mut text_runs,
@@ -1941,6 +1963,7 @@ fn finalize_template_section(meta: &mut TemplateSectionMeta) {
 fn process_fragment_children(
     nodes: &[FragmentNode],
     parent_index: usize,
+    ignore_initial_lf: bool,
     text_bindings: &[(String, bool)],
     out: &mut String,
     text_runs: &mut Vec<(SlotLocator, Vec<CompiledAttrPart>, bool)>,
@@ -1974,16 +1997,7 @@ fn process_fragment_children(
                 // (e.g. `&gt;` → `>`).  Static-only text runs are
                 // baked into `meta.h` and parsed via innerHTML which
                 // handles entity decoding natively.
-                let decoded_parts = parts
-                    .into_iter()
-                    .map(|part| match part {
-                        CompiledAttrPart::Static(s) => {
-                            let decoded = html_escape::decode_html_entities(&s);
-                            CompiledAttrPart::Static(decoded.into_owned())
-                        }
-                        other => other,
-                    })
-                    .collect();
+                let decoded_parts = decode_text_parts(parts, ignore_initial_lf && index == 0);
                 let order = slot_orders.get(&child_index).copied().unwrap_or(0);
                 slot_orders.insert(child_index, order + 1);
                 text_runs.push((
@@ -2082,6 +2096,53 @@ fn process_fragment_children(
     ssr_layout.finish_children(parent_index, &ssr_children, text_runs.len());
 }
 
+fn decode_text_parts(
+    mut parts: Vec<CompiledAttrPart>,
+    ignore_initial_lf: bool,
+) -> Vec<CompiledAttrPart> {
+    for part in &mut parts {
+        if let CompiledAttrPart::Static(text) = part {
+            normalize_text_newlines(text);
+            if let Cow::Owned(decoded) = html_escape::decode_html_entities(text.as_str()) {
+                *text = decoded;
+            }
+        }
+    }
+    // HTML parsing ignores the first LF after pre/textarea/listing. Client
+    // binding assignment bypasses HTML parsing, so mirror it in static parts.
+    if ignore_initial_lf {
+        if let Some(CompiledAttrPart::Static(text)) = parts.first_mut() {
+            if text.starts_with('\n') {
+                text.remove(0);
+            }
+        }
+    }
+    parts
+}
+
+fn normalize_text_newlines(text: &mut String) {
+    let Some(mut carriage_return) = text.find('\r') else {
+        return;
+    };
+    let first_is_crlf = text[carriage_return..].starts_with("\r\n");
+    let mut normalized = String::with_capacity(text.len() - usize::from(first_is_crlf));
+    let mut remaining = text.as_str();
+    loop {
+        normalized.push_str(&remaining[..carriage_return]);
+        normalized.push('\n');
+        remaining = &remaining[carriage_return + 1..];
+        if let Some(after_lf) = remaining.strip_prefix('\n') {
+            remaining = after_lf;
+        }
+        let Some(next) = remaining.find('\r') else {
+            break;
+        };
+        carriage_return = next;
+    }
+    normalized.push_str(remaining);
+    *text = normalized;
+}
+
 #[allow(clippy::too_many_arguments)]
 fn serialize_fragment_element(
     element: &FragmentElement,
@@ -2151,6 +2212,9 @@ fn serialize_fragment_element(
     process_fragment_children(
         &element.children,
         element_index,
+        element.tag_name.eq_ignore_ascii_case("pre")
+            || element.tag_name.eq_ignore_ascii_case("textarea")
+            || element.tag_name.eq_ignore_ascii_case("listing"),
         text_bindings,
         out,
         text_runs,
@@ -2719,7 +2783,9 @@ fn parse_if_block(
     let (body_end, close_end) = find_matching_end(input, tag.name, body_start)?;
     Some((
         condition,
-        source.slice(body_start..body_end).trimmed(),
+        source
+            .slice(body_start..body_end)
+            .trim_boundary_formatting(),
         close_end,
     ))
 }
@@ -2778,7 +2844,9 @@ fn parse_for_block<'a>(
     };
 
     let (item_var, collection) = crate::parse_for_each(component, each_val)?;
-    let mut body = source.slice(tag.close + 1..body_end).trimmed();
+    let mut body = source
+        .slice(tag.close + 1..body_end)
+        .trim_boundary_formatting();
     let repeat_key = first_child_repeat_key(component, item_var, body.html())?;
     body.repeat_key = repeat_key
         .as_ref()
@@ -3540,6 +3608,86 @@ mod whitespace_tests;
 mod tests {
     use super::*;
 
+    #[test]
+    fn decoding_plain_text_reuses_owned_buffers() {
+        let text = String::from("\n  plain text \n");
+        let text_pointer = text.as_ptr();
+        let parts = vec![
+            CompiledAttrPart::Static(text),
+            CompiledAttrPart::Dynamic("label".to_string()),
+        ];
+        let parts_pointer = parts.as_ptr();
+        let decoded = decode_text_parts(parts, false);
+        assert_eq!(decoded.as_ptr(), parts_pointer);
+        let CompiledAttrPart::Static(text) = &decoded[0] else {
+            panic!("expected static text");
+        };
+        assert_eq!(text, "\n  plain text \n");
+        assert_eq!(text.as_ptr(), text_pointer);
+    }
+
+    #[test]
+    fn source_newline_normalization_handles_mixed_runs() {
+        for (input, expected) in [
+            ("", ""),
+            ("plain\ntext", "plain\ntext"),
+            ("\r", "\n"),
+            ("\r\n", "\n"),
+            ("\r\r\n\r", "\n\n\n"),
+            ("a\r\nb\rc\n", "a\nb\nc\n"),
+            ("é\r\n中\r🙂", "é\n中\n🙂"),
+        ] {
+            let mut text = input.to_string();
+            normalize_text_newlines(&mut text);
+            assert_eq!(text, expected);
+        }
+    }
+
+    #[test]
+    fn boundary_formatting_stays_separate_from_stripped_comments() {
+        for text in [
+            "plain text",
+            "{{label}}",
+            "{{{label}}}",
+            "<span>{{label}}</span>",
+        ] {
+            let source = format!("\n<!-- leading -->{text}<!-- trailing -->\n");
+            assert_eq!(
+                generate_compiled_template("text-comments", &source),
+                generate_compiled_template("text-comments", text),
+            );
+        }
+    }
+
+    #[test]
+    fn text_run_edges_survive_component_and_block_boundaries() {
+        let text = "\n  {{label}}\n ";
+        let metadata = generate_compiled_template("text-root", text);
+        assert!(metadata.contains(r#"["\n  ",["label"],"\n "]"#));
+        for source in [
+            format!("<if condition=\"ready\">{text}</if>"),
+            format!("<for each=\"item in items\">{text}</for>"),
+        ] {
+            let metadata = generate_compiled_template("text-block", &source);
+            assert!(metadata.contains(r#"["\n  ",["label"],"\n "]"#));
+        }
+    }
+
+    #[test]
+    fn text_parts_follow_html_source_newline_rules() {
+        let button =
+            generate_compiled_template("text-newlines", "<button>\r\n  {{label}}\r</button>");
+        assert!(button.contains(r#"["\n  ",["label"],"\n"]"#));
+        for tag in ["pre", "textarea", "listing"] {
+            let source = format!("<{tag}>\r\n  {{{{label}}}}\r\n</{tag}>");
+            let metadata = generate_compiled_template("text-newlines", &source);
+            assert!(metadata.contains(r#"["  ",["label"],"\n"]"#));
+        }
+        let entity =
+            generate_compiled_template("text-newlines", "<span>&#13;{{label}}&#10;</span>");
+        assert!(entity.contains(r#"["\r",["label"],"\n"]"#));
+    }
+
     #[test]
     fn boolean_literal_conditions_have_no_state_dependencies() {
         for value in ["true", "false"] {
diff --git a/crates/webui-parser/src/plugin/webui/named_repeats.rs b/crates/webui-parser/src/plugin/webui/named_repeats.rs
index 89dd31724..75bcc999b 100644
--- a/crates/webui-parser/src/plugin/webui/named_repeats.rs
+++ b/crates/webui-parser/src/plugin/webui/named_repeats.rs
@@ -79,6 +79,7 @@ impl CompileBlocks {
                     source: repeat.body.source,
                     range: repeat.offset..repeat.offset,
                     repeat_key: None,
+                    trim_boundary_formatting: false,
                 };
                 source.locate_error(error)
             })?;
diff --git a/docs/guide/concepts/hydration.md b/docs/guide/concepts/hydration.md
index 279ffe80d..1396319f3 100644
--- a/docs/guide/concepts/hydration.md
+++ b/docs/guide/concepts/hydration.md
@@ -15,6 +15,12 @@ compiler and framework versions. SSR hydration requires the compiler's current
 metadata; stale artifacts fail with an error asking you to rebuild rather than
 being reinterpreted in the browser.
 
+Text bindings retain their surrounding authored whitespace on the server and
+during browser updates. Values are not trimmed; ordinary HTML whitespace
+collapsing and CSS such as `white-space: pre-wrap` determine their appearance.
+Native HTML rules still apply, including ignoring the first newline immediately
+after an opening `<pre>` or `<textarea>` tag.
+
 ## HTML-Only Components
 
 HTML-only components can use bindings, attributes, `<if>`, and `<for>`. Their
diff --git a/packages/webui-framework/tests/fixtures/hydration-mismatch/element.ts b/packages/webui-framework/tests/fixtures/hydration-mismatch/element.ts
index 98fc3806b..4db80b587 100644
--- a/packages/webui-framework/tests/fixtures/hydration-mismatch/element.ts
+++ b/packages/webui-framework/tests/fixtures/hydration-mismatch/element.ts
@@ -12,7 +12,7 @@
  * blank. The components differ only in WHEN they assign the observables.
  */
 
-import { WebUIElement, observable } from '../../../src/index.js';
+import { WebUIElement, attr, observable } from '../../../src/index.js';
 
 /**
  * `@observable` field default differs from SSR state. The initializer runs
@@ -97,3 +97,14 @@ export class MismatchSeeded extends WebUIElement {
   @observable seededValue = '3';
 }
 MismatchSeeded.define('mismatch-seeded');
+
+export class MismatchWhitespace extends WebUIElement {
+  @attr headerTitle!: string;
+  @attr details!: string;
+  @attr padded!: string;
+  @observable items!: string[];
+}
+MismatchWhitespace.define('mismatch-whitespace');
+
+export class WhitespaceSlot extends WebUIElement {}
+WhitespaceSlot.define('whitespace-slot');
diff --git a/packages/webui-framework/tests/fixtures/hydration-mismatch/hydration-mismatch.spec.ts b/packages/webui-framework/tests/fixtures/hydration-mismatch/hydration-mismatch.spec.ts
index 0664452df..14ffecc26 100644
--- a/packages/webui-framework/tests/fixtures/hydration-mismatch/hydration-mismatch.spec.ts
+++ b/packages/webui-framework/tests/fixtures/hydration-mismatch/hydration-mismatch.spec.ts
@@ -23,6 +23,7 @@ const ALL_TAGS = [
   'mismatch-after-super',
   'mismatch-deferred',
   'mismatch-seeded',
+  'mismatch-whitespace',
 ] as const;
 
 test.describe('hydration-mismatch (#379)', () => {
@@ -57,6 +58,179 @@ test.describe('hydration-mismatch (#379)', () => {
     expect(warningsFor('mismatch-after-super')).toHaveLength(0);
     expect(warningsFor('mismatch-deferred')).toHaveLength(0);
     expect(warningsFor('mismatch-seeded')).toHaveLength(0);
+    expect(warningsFor('mismatch-whitespace')).toHaveLength(0);
+  });
+
+  test('multiline text agrees across compilation, SSR, hydration, slots, and live updates', async ({ page, request }) => {
+    const warnings: string[] = [];
+    const errors: string[] = [];
+    page.on('console', (message) => {
+      if (message.type() === 'warning') warnings.push(message.text());
+    });
+    page.on('pageerror', (error) => errors.push(error.message));
+
+    const response = await request.get('/hydration-mismatch/fixture.html');
+    const raw = await response.text();
+    let releaseScript!: () => void;
+    const scriptReady = new Promise<void>((resolve) => { releaseScript = resolve; });
+    await page.route('**/dist/hydration-mismatch/element.js', async (route) => {
+      await scriptReady;
+      await route.continue();
+    });
+    const navigation = page.goto('/hydration-mismatch/fixture.html');
+    await page.locator('mismatch-whitespace .native').waitFor();
+    const before = await page.evaluate(() => {
+      const host = document.querySelector('mismatch-whitespace')!;
+      const root = host.shadowRoot!;
+      const native = root.querySelector('.native')!;
+      const wrapper = root.querySelector('whitespace-slot')!;
+      const text = native.firstChild;
+      const slot = wrapper.shadowRoot!.querySelector('slot')!;
+      Object.assign(window, { whitespaceNodes: { host, native, wrapper, text, slot } });
+      return {
+        native: native.textContent,
+        wrapper: wrapper.textContent,
+        assigned: slot.assignedNodes().map((node) => node.textContent),
+        nativeTypes: Array.from(native.childNodes, (node) => node.nodeType),
+        wrapperTypes: Array.from(wrapper.childNodes, (node) => node.nodeType),
+      };
+    });
+    releaseScript();
+    await navigation;
+    await page.waitForFunction(() =>
+      (document.querySelector('mismatch-whitespace') as { $ready?: boolean } | null)?.$ready === true);
+    // Wait for the existing genuine-mismatch diagnostic's asynchronous module.
+    await expect.poll(() => warnings.filter((warning) => warning.includes(MISMATCH)).length).toBeGreaterThanOrEqual(3);
+
+    const title = '\n      Downloads\n    ';
+    const details = '\n              Open file\n            ';
+    expect(raw).toContain(`<button class="native">${title}</button>`);
+    expect(before).toEqual({
+      native: title,
+      wrapper: details,
+      assigned: [details],
+      nativeTypes: [3],
+      wrapperTypes: [3],
+    });
+    const snapshot = () => page.evaluate(() => {
+      const host = document.querySelector('mismatch-whitespace') as HTMLElement & {
+        headerTitle: string;
+        details: string;
+        padded: string;
+      };
+      const root = host.shadowRoot!;
+      const saved = (window as Window & {
+        whitespaceNodes?: { host: Element; native: Element; wrapper: Element; text: Node; slot: HTMLSlotElement };
+      }).whitespaceNodes!;
+      const wrapper = root.querySelector('whitespace-slot')!;
+      const slot = wrapper.shadowRoot!.querySelector('slot')!;
+      return {
+        state: { headerTitle: host.headerTitle, details: host.details, padded: host.padded },
+        native: root.querySelector('.native')!.textContent,
+        wrapper: wrapper.textContent,
+        data: root.querySelector('.data')!.textContent,
+        inline: root.querySelector('.inline')!.textContent,
+        pre: root.querySelector('pre')!.textContent,
+        textarea: root.querySelector('textarea')!.textContent,
+        multilinePre: root.querySelector('pre.leading-newline')!.textContent,
+        multilineTextarea: root.querySelector('textarea.leading-newline')!.textContent,
+        conditional: root.querySelector('.conditional')!.textContent,
+        repeat: root.querySelector('.repeat')!.textContent,
+        assigned: slot.assignedNodes().map((node) => node.textContent),
+        identity: host === saved.host
+          && root.querySelector('.native') === saved.native
+          && saved.native.firstChild === saved.text
+          && wrapper === saved.wrapper && slot === saved.slot,
+      };
+    });
+    expect(await snapshot()).toEqual({
+      state: { headerTitle: 'Downloads', details: 'Open file', padded: '  data \n ' },
+      native: title,
+      wrapper: details,
+      data: '  data \n ',
+      inline: 'left Open file right',
+      pre: '  Open file\n    tail  ',
+      textarea: '  Open file\n    tail  ',
+      multilinePre: '    Open file\n  ',
+      multilineTextarea: '    Open file\n  ',
+      conditional: '\n    Open file\n  ',
+      repeat: '\n    First\n  \n    Second\n  ',
+      assigned: [details],
+      identity: true,
+    });
+    expect(warnings.filter((warning) => warning.includes('<mismatch-whitespace>'))).toEqual([]);
+    expect(warnings.filter((warning) => warning.includes(MISMATCH))).toHaveLength(3);
+    expect(errors).toEqual([]);
+
+    const created = await page.evaluate(() => {
+      const host = document.createElement('mismatch-whitespace');
+      Object.assign(host, {
+        headerTitle: 'Downloads', details: 'Open file', padded: '  data \n ', items: ['First', 'Second'],
+      });
+      document.body.append(host);
+      const root = host.shadowRoot!;
+      const texts = [
+        '.native', 'whitespace-slot', '.data', '.inline', 'pre', 'textarea',
+        'pre.leading-newline', 'textarea.leading-newline', '.conditional', '.repeat',
+      ]
+        .map((selector) => root.querySelector(selector)!.textContent);
+      host.remove();
+      return texts;
+    });
+    expect(created).toEqual([
+      title, details, '  data \n ', 'left Open file right', '  Open file\n    tail  ',
+      '  Open file\n    tail  ', '    Open file\n  ', '    Open file\n  ',
+      '\n    Open file\n  ', '\n    First\n  \n    Second\n  ',
+    ]);
+
+    for (const value of ['  next \n ', '', '\n  ']) {
+      await page.evaluate((value) => {
+        const host = document.querySelector('mismatch-whitespace') as HTMLElement & {
+            headerTitle: string; details: string; padded: string; items: string[];
+        };
+        host.headerTitle = value;
+        host.details = value;
+        host.padded = value;
+        host.items = [value];
+      }, value);
+      await expect.poll(snapshot).toEqual({
+        state: { headerTitle: value, details: value, padded: value },
+        native: `\n      ${value}\n    `,
+        wrapper: `\n              ${value}\n            `,
+        data: value,
+        inline: `left ${value} right`,
+        pre: `  ${value}\n    tail  `,
+        textarea: `  ${value}\n    tail  `,
+        multilinePre: `    ${value}\n  `,
+        multilineTextarea: `    ${value}\n  `,
+        conditional: value ? `\n    ${value}\n  ` : '',
+        repeat: `\n    ${value}\n  `,
+        assigned: [`\n              ${value}\n            `],
+        identity: true,
+      });
+    }
+  });
+
+  test('a genuinely different attribute value still warns for multiline text', async ({ page }) => {
+    const mismatches: string[] = [];
+    page.on('console', (message) => {
+      if (message.type() === 'warning' && message.text().includes('<mismatch-whitespace>')) {
+        mismatches.push(message.text());
+      }
+    });
+    await page.route('**/hydration-mismatch/fixture.html', async (route) => {
+      const response = await route.fetch();
+      const body = (await response.text()).replace('details="Open file"', 'details="Client override"');
+      await route.fulfill({ response, body });
+    });
+    await page.goto('/hydration-mismatch/fixture.html');
+    await expect.poll(() => mismatches.length).toBe(1);
+    expect(mismatches[0]).toContain('"details" changed at or before super.connectedCallback()');
+    const state = await page.locator('mismatch-whitespace').evaluate((host) =>
+      (host as HTMLElement & { details: string }).details);
+    expect(state).toBe('Client override');
+    expect(await page.locator('mismatch-whitespace whitespace-slot').textContent())
+      .toBe('\n              Open file\n            ');
   });
 
   test('the warning names the mismatched observables', async () => {
diff --git a/packages/webui-framework/tests/fixtures/hydration-mismatch/src/index.html b/packages/webui-framework/tests/fixtures/hydration-mismatch/src/index.html
index 45fa1276c..ab916902c 100644
--- a/packages/webui-framework/tests/fixtures/hydration-mismatch/src/index.html
+++ b/packages/webui-framework/tests/fixtures/hydration-mismatch/src/index.html
@@ -11,5 +11,6 @@
   <mismatch-after-super id="after-super"></mismatch-after-super>
   <mismatch-deferred id="deferred"></mismatch-deferred>
   <mismatch-seeded id="seeded"></mismatch-seeded>
+  <mismatch-whitespace header-title="{{headerTitle}}" details="{{details}}" padded="{{padded}}"></mismatch-whitespace>
 </body>
 </html>
diff --git a/packages/webui-framework/tests/fixtures/hydration-mismatch/src/mismatch-whitespace/mismatch-whitespace.html b/packages/webui-framework/tests/fixtures/hydration-mismatch/src/mismatch-whitespace/mismatch-whitespace.html
new file mode 100644
index 000000000..26bbf8594
--- /dev/null
+++ b/packages/webui-framework/tests/fixtures/hydration-mismatch/src/mismatch-whitespace/mismatch-whitespace.html
@@ -0,0 +1,26 @@
+<template shadowrootmode="open">
+  <button class="native">
+      {{headerTitle}}
+    </button>
+  <whitespace-slot>
+              {{details}}
+            </whitespace-slot>
+  <p class="data">{{padded}}</p>
+  <p class="inline"><span>left</span> <span>{{details}}</span> <span>right</span></p>
+  <pre>  {{details}}
+    tail  </pre>
+  <textarea>  {{details}}
+    tail  </textarea>
+  <pre class="leading-newline">
+    {{details}}
+  </pre>
+  <textarea class="leading-newline">
+    {{details}}
+  </textarea>
+  <div class="conditional"><if condition="details">
+    {{details}}
+  </if></div>
+  <div class="repeat"><for each="item in items">
+    {{item}}
+  </for></div>
+</template>
diff --git a/packages/webui-framework/tests/fixtures/hydration-mismatch/src/whitespace-slot/whitespace-slot.html b/packages/webui-framework/tests/fixtures/hydration-mismatch/src/whitespace-slot/whitespace-slot.html
new file mode 100644
index 000000000..a1bec3143
--- /dev/null
+++ b/packages/webui-framework/tests/fixtures/hydration-mismatch/src/whitespace-slot/whitespace-slot.html
@@ -0,0 +1 @@
+<template shadowrootmode="open"><slot></slot></template>
diff --git a/packages/webui-framework/tests/fixtures/hydration-mismatch/state.json b/packages/webui-framework/tests/fixtures/hydration-mismatch/state.json
index cd76a59cc..b15b8d36d 100644
--- a/packages/webui-framework/tests/fixtures/hydration-mismatch/state.json
+++ b/packages/webui-framework/tests/fixtures/hydration-mismatch/state.json
@@ -1,4 +1,8 @@
 {
   "seededShow": true,
-  "seededValue": "3"
+  "seededValue": "3",
+  "headerTitle": "Downloads",
+  "details": "Open file",
+  "padded": "  data \n ",
+  "items": ["First", "Second"]
 }
diff --git a/specs/hydration.md b/specs/hydration.md
index 2e95ed231..0b19f8a23 100644
--- a/specs/hydration.md
+++ b/specs/hydration.md
@@ -97,6 +97,14 @@ HTML binding. The client counterparts are defined in
 Ordinary escaped text bindings, attribute bindings, and event handlers are
 **not** marked. They are located via compiled element indices.
 
+An emitted text run preserves all of its static pieces, including indentation
+around bindings. SSR fragments and client text parts must agree on those
+pieces; formatting-only text between elements is not a reason to discard
+whitespace within a binding's text node. State values are never trimmed.
+Static text parts follow browser HTML parsing: source CR/CRLF becomes LF,
+character references are decoded, and the initial LF after
+`pre`/`textarea`/`listing` is ignored before client text assignment.
+
 Whole-value dynamic attributes omit missing and null values during SSR and
 client binding updates. Empty strings, zero, and false remain values; mixed
 attributes retain their static text. Omitting an attribute does not remove an