diff --git a/CHANGELOG.md b/CHANGELOG.md
index 461a161..cd78ba3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,28 @@ change the API; each entry says so when it does.
 
 Phases refer to [`docs/design/roadmap.md`](docs/design/roadmap.md).
 
+## [0.1.20] - 2026-09-30
+
+### Fixed
+- `reparseBlocks` and `reparseFromText` no longer cut a block short at the
+  edge of their window. An edit that opened a code fence, a display-math block
+  or an HTML comment without closing it was read as one short block followed
+  by the old blocks after it, where a whole parse has it run to the end of the
+  text. The window now has to end with the untouched block after it, exactly
+  as that block was; when it does not, the reparse reads on to the end. A line
+  that now continues the block before the window (lazy continuation) is also
+  picked up. (Phase 23.)
+
+### Changed
+- `serializeDocument` builds the next document from the blocks it moved and
+  small reparses around what changed, pinned the same way, instead of parsing
+  its whole output again. The document is the one `parseDocument` would
+  return, which the tests check on thousands of generated saves; the whole
+  parse remains as the fallback. On an 8 MB note a one-block save goes from
+  about 130-200 ms to 40-80 ms. (Phase 23.)
+- Line-ending detection uses two native scans instead of a character loop,
+  which took 20-35 ms of every parse of an 8 MB note.
+
 ## [0.1.19] - 2026-09-29
 
 ### Fixed
@@ -140,6 +162,7 @@ Phases refer to [`docs/design/roadmap.md`](docs/design/roadmap.md).
   `@roobli/md/legacy-micromark`. (Phase 6; breaking for callers that relied
   on the fallback.)
 
+[0.1.20]: https://github.com/roobli/md/compare/v0.1.19...v0.1.20
 [0.1.19]: https://github.com/roobli/md/compare/v0.1.18...v0.1.19
 [0.1.18]: https://github.com/roobli/md/compare/v0.1.17...v0.1.18
 [0.1.17]: https://github.com/roobli/md/compare/v0.1.16...v0.1.17
diff --git a/README.md b/README.md
index 5df7557..1bf883d 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,10 @@ AGPL.
 - **Stable spans.** Every block carries its `start` and `end` in the source,
   its kind, and the literal gap before it.
 - **Local reparse.** `reparseBlocks` and `reparseFromText` rebuild only the
-  window around an edit; blocks outside it keep their identity.
+  window around an edit; blocks outside it keep their identity. The window is
+  pinned at both edges, so the result is always what a whole parse would say;
+  an edit that runs past it (an unclosed fence) is read on to the end.
+  `serializeDocument` builds its next document the same way.
 - **One dialect.** CommonMark plus GFM tables, task lists and strikethrough,
   `$`/`$$` math, YAML frontmatter, footnotes, callouts, wiki links and
   CJK-friendly emphasis. Behaviour is checked against micromark for parity.
@@ -45,7 +48,7 @@ Design notes: [vision](docs/design/vision.md) ·
 ## Install
 
 ```
-pnpm add github:roobli/md#v0.1.19
+pnpm add github:roobli/md#v0.1.20
 ```
 
 Pin a tag: `main` moves. A host that runs install scripts may need to allow
diff --git a/docs/design/contract-v0.md b/docs/design/contract-v0.md
index b5d3fca..98e3ea2 100644
--- a/docs/design/contract-v0.md
+++ b/docs/design/contract-v0.md
@@ -84,11 +84,19 @@ only the dirty window (widened by `neighborSlack`), and stitches prefix /
 middle / suffix with absolute offsets. Untouched prefix spans keep object
 identity; untouched suffix spans keep `markdown` string identity. Micromark is not imported on this path (Phase 6); use `@roobli/md/legacy-micromark` for compat.
 
+The window is pinned at both edges (Phase 23, `src/window.ts`). It opens at the
+start of the untouched block before the dirty ordinals, which is re-read, so a
+line that now continues that block is picked up. It must close with the
+untouched block after them, exactly as that block was; if the edit ran on into
+it (an unclosed fence, display math or comment), the reparse reads on to the
+end of the text instead. The result is always what `parseBlocks` of the whole
+text would give; `neighborSlack` only trades window size for how often the
+fallback is needed, and is no longer what keeps the result correct.
+
 Noto call sites: `replaceMarkdown` can pass the differing middle ordinals as
 `replacedBlocks` instead of `splitBlocks(fullMarkdown)`; when the host only has
 the full next buffer, prefer `reparseFromText(prior, nextText)` (Phase 11).
-The single-block save path can use `neighborSlack: 0` after `parseSingleBlock`
-validation.
+`neighborSlack: 0` is safe on every path.
 
 ### Serialize (Phase 5)
 
@@ -224,6 +232,7 @@ Full table: [`roadmap.md`](./roadmap.md). Contract-facing summary:
 | **20** (done) | Empty list item + blank → structural outside |
 | **21** (done) | List-steal pipe-less delimiters not tables |
 | **22** (done) | Lazy only with open paragraph / link-def title / ordered start≠1 |
+| **23** (done) | Pinned reparse windows; `serializeDocument` without a whole-output parse |
 
 ## Replace boundary
 
diff --git a/docs/design/roadmap.md b/docs/design/roadmap.md
index f0303ce..79ab6e1 100644
--- a/docs/design/roadmap.md
+++ b/docs/design/roadmap.md
@@ -313,3 +313,19 @@ Phase 21 **shipped** on `main` (v0.1.18).
 
 Phase 22 **shipped** on `main` (v0.1.19).
 
+## Phase 23 acceptance
+
+- [x] A reparse window is pinned at both edges (`src/window.ts`): it opens at the
+      start of an untouched block, and must close with the untouched block after
+      it, exactly as that block was; otherwise it reads on to the end of the text
+- [x] Frontmatter, the one block decided by unbounded lookahead, is refused by a
+      window that opens the note and stops short of its close
+- [x] `reparseBlocks` / `reparseFromText` match `parseBlocks` on generated edits,
+      including unclosed fences, math, comments and lazy continuation
+      (`reparse-window.test.ts`)
+- [x] `serializeDocument` returns the document `parseDocument(outputBytes)` would,
+      without a whole parse, on generated saves over LF, CRLF, BOM, no final
+      newline and no frontmatter (`serialize-incremental.test.ts`)
+- [x] Package `0.1.20`
+
+Phase 23 **shipped** on `main` (v0.1.20).
diff --git a/package.json b/package.json
index a465f04..bd42307 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@roobli/md",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "WYSIWYG-first markdown engine for Noto — block-oriented, byte-exact friendly, fast on large vaults.",
   "license": "MIT",
   "type": "module",
diff --git a/src/backend/native-scanner.ts b/src/backend/native-scanner.ts
index cd18e74..8b7b205 100644
--- a/src/backend/native-scanner.ts
+++ b/src/backend/native-scanner.ts
@@ -514,8 +514,12 @@ function spansToSplit(text: string, raw: { kind: BlockKind; start: number; end:
  * Native split for the Phase 1–5 dialect. Always returns a SplitDocument
  * (never null). Micromark is not consulted — see `@roobli/md/legacy-micromark`
  * for the Phase 0 compatibility backend.
+ *
+ * `atDocumentStart` is false when `text` is a window cut from the middle of a
+ * document: YAML frontmatter is only recognised at the very start of a file,
+ * so a `---` that opens a window is a thematic break there, not frontmatter.
  */
-export function tryNativeSplit(text: string): SplitDocument {
+export function tryNativeSplit(text: string, atDocumentStart = true): SplitDocument {
   if (text.length === 0) {
     return { spans: [], leading: '', gaps: [], trailing: '' };
   }
@@ -532,7 +536,7 @@ export function tryNativeSplit(text: string): SplitDocument {
     }
 
     // YAML frontmatter (only at absolute document start)
-    if (i === 0 && line.start === 0 && isFrontmatterOpen(line.content, true)) {
+    if (atDocumentStart && i === 0 && line.start === 0 && isFrontmatterOpen(line.content, true)) {
       let j = i + 1;
       let closed = false;
       while (j < lines.length) {
diff --git a/src/parse.ts b/src/parse.ts
index 06fe815..3bdff57 100644
--- a/src/parse.ts
+++ b/src/parse.ts
@@ -7,16 +7,21 @@ function hasBom(bytes: Uint8Array): boolean {
   return bytes.length >= 3 && bytes[0] === UTF8_BOM[0] && bytes[1] === UTF8_BOM[1] && bytes[2] === UTF8_BOM[2];
 }
 
-function detectLineEnding(text: string): EngineEnvelope['lineEnding'] {
-  let crlf = 0;
-  let bareLf = 0;
-  for (let index = 0; index < text.length; index += 1) {
-    if (text[index] !== '\n') continue;
-    if (index > 0 && text[index - 1] === '\r') crlf += 1;
-    else bareLf += 1;
-  }
-  if (crlf > 0 && bareLf > 0) return 'mixed';
-  return crlf > 0 ? 'crlf' : 'lf';
+/** An LF with no CR before it. No `g` flag, so the regex carries no state. */
+const BARE_LF = /(?:^|[^\r])\n/;
+
+/**
+ * `crlf` when every line ends CRLF, `lf` when none does, `mixed` otherwise.
+ *
+ * Two native scans (`includes` and one regex test) rather than a character
+ * loop: on an 8 MB note this was 20 to 35 ms of every parse and is now well
+ * under one.
+ */
+export function detectLineEnding(text: string): EngineEnvelope['lineEnding'] {
+  const crlf = text.includes('\r\n');
+  const bareLf = BARE_LF.test(text);
+  if (crlf && bareLf) return 'mixed';
+  return crlf ? 'crlf' : 'lf';
 }
 
 function decodeUtf8(bytes: Uint8Array): string | null {
diff --git a/src/reparse-window.test.ts b/src/reparse-window.test.ts
new file mode 100644
index 0000000..70aaee3
--- /dev/null
+++ b/src/reparse-window.test.ts
@@ -0,0 +1,166 @@
+import { describe, expect, it } from 'vitest';
+import { parseBlocks } from './parse.js';
+import { reparseFromText } from './reparse.js';
+import type { SplitDocument } from './types.js';
+
+/**
+ * An incremental reparse is only correct if it says what a whole parse of the
+ * same text says. These hold it to exactly that, including for edits whose
+ * effect reaches well past the blocks they touched.
+ */
+
+function shape(split: SplitDocument) {
+  return {
+    spans: split.spans.map((span) => [span.kind, span.start, span.end, span.markdown]),
+    leading: split.leading,
+    gaps: split.gaps,
+    trailing: split.trailing,
+  };
+}
+
+function expectSameAsFull(prior: SplitDocument, next: string, neighborSlack: number, label = ''): void {
+  const incremental = reparseFromText(prior, next, { neighborSlack });
+  expect(shape(incremental), label).toEqual(shape(parseBlocks(next)));
+}
+
+const PARAGRAPHS = Array.from({ length: 12 }, (_, index) => `Paragraph ${index}.`).join('\n\n') + '\n';
+
+describe('reparse windows that an edit runs out of', () => {
+  it('follows an unclosed fence to the end of the note', () => {
+    const prior = parseBlocks(PARAGRAPHS);
+    const at = PARAGRAPHS.indexOf('Paragraph 3.');
+    const next = `${PARAGRAPHS.slice(0, at)}\`\`\`\n${PARAGRAPHS.slice(at)}`;
+    for (const slack of [0, 1, 2]) expectSameAsFull(prior, next, slack, `slack ${slack}`);
+    expect(parseBlocks(next).spans.at(-1)!.kind).toBe('fenced-code');
+  });
+
+  it('follows an unclosed comment, and math, the same way', () => {
+    const prior = parseBlocks(PARAGRAPHS);
+    const at = PARAGRAPHS.indexOf('Paragraph 5.');
+    for (const opener of ['<!--\n', '$$\n', '<script>\n']) {
+      const next = `${PARAGRAPHS.slice(0, at)}${opener}${PARAGRAPHS.slice(at)}`;
+      for (const slack of [0, 1]) expectSameAsFull(prior, next, slack, `${JSON.stringify(opener)} slack ${slack}`);
+    }
+  });
+
+  it('picks up a closing fence that ends a fence which used to run to the end', () => {
+    const text = `Intro\n\n\`\`\`\n${PARAGRAPHS}`;
+    const prior = parseBlocks(text);
+    expect(prior.spans.at(-1)!.kind).toBe('fenced-code');
+    const at = text.indexOf('Paragraph 4.');
+    const next = `${text.slice(0, at)}\`\`\`\n\n${text.slice(at)}`;
+    for (const slack of [0, 1]) expectSameAsFull(prior, next, slack, `slack ${slack}`);
+  });
+
+  it('lets the block before the window take in a line that now continues it', () => {
+    // "- item" interrupted the paragraph; without the marker it is a lazy
+    // continuation line, so the paragraph before the edit grows.
+    const text = 'Intro\n\nLead paragraph\n- item\n\nOutro\n';
+    const prior = parseBlocks(text);
+    const next = text.replace('- item', 'item');
+    for (const slack of [0, 1]) expectSameAsFull(prior, next, slack, `slack ${slack}`);
+  });
+
+  it('keeps the identity of blocks outside the window when nothing ran on', () => {
+    const prior = parseBlocks(PARAGRAPHS);
+    const next = PARAGRAPHS.replace('Paragraph 6.', 'Paragraph six.');
+    const result = reparseFromText(prior, next, { neighborSlack: 1 });
+    expect(shape(result)).toEqual(shape(parseBlocks(next)));
+    expect(result.spans[0]).toBe(prior.spans[0]);
+    expect(result.spans[4]).toBe(prior.spans[4]);
+    expect(result.spans[11]!.markdown).toBe(prior.spans[11]!.markdown);
+    expect(result.dirtyFrom).toBe(5);
+    expect(result.dirtyTo).toBe(7);
+  });
+});
+
+/** A small deterministic generator, so a failure names a reproducible case. */
+function rng(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state = (state * 1664525 + 1013904223) >>> 0;
+    return state / 0x100000000;
+  };
+}
+
+const SOURCE = `---
+title: Windows
+---
+
+# Title
+
+A paragraph with *emphasis* and a [link](https://example.com).
+It continues on a second line.
+
+- first item
+- second item
+  - nested item
+
+1. one
+2. two
+
+> A quote
+> that goes on.
+
+\`\`\`ts
+const value = 1;
+
+const other = 2;
+\`\`\`
+
+| a | b |
+| - | - |
+| 1 | 2 |
+
+$$
+x = y^2
+$$
+
+<div align="center">html</div>
+
+Text with a footnote.[^f]
+
+[^f]: The footnote.
+
+[ref]: https://example.com/ref
+
+Setext heading
+--------------
+
+    indented code
+
+***
+
+Last paragraph.
+`;
+
+const SNIPPETS = [
+  '```\n', '```', '~~~\n', '$$\n', '<!--\n', '-->', '<div>\n', '</div>\n', '- ', '* ', '1. ', '> ', '# ',
+  '---\n', '===\n', '    ', '\n', '\n\n', '| x | y |\n| - | - |\n', '[r]: /u\n', '[^n]: note\n', 'word ', 'text\n',
+];
+
+describe('reparse windows, against a whole parse, on generated edits', () => {
+  for (const slack of [0, 1]) {
+    it(`agrees with parseBlocks on 600 random edits (slack ${slack})`, () => {
+      const prior = parseBlocks(SOURCE);
+      for (let seed = 1; seed <= 600; seed += 1) {
+        const random = rng(seed * 7 + slack);
+        const at = Math.floor(random() * (SOURCE.length + 1));
+        const pick = random();
+        let next: string;
+        if (pick < 0.55) {
+          const snippet = SNIPPETS[Math.floor(random() * SNIPPETS.length)]!;
+          next = SOURCE.slice(0, at) + snippet + SOURCE.slice(at);
+        } else if (pick < 0.85) {
+          const end = Math.min(SOURCE.length, at + 1 + Math.floor(random() * 40));
+          next = SOURCE.slice(0, at) + SOURCE.slice(end);
+        } else {
+          const end = Math.min(SOURCE.length, at + 1 + Math.floor(random() * 20));
+          const snippet = SNIPPETS[Math.floor(random() * SNIPPETS.length)]!;
+          next = SOURCE.slice(0, at) + snippet + SOURCE.slice(end);
+        }
+        expectSameAsFull(prior, next, slack, `seed ${seed}`);
+      }
+    });
+  }
+});
diff --git a/src/reparse.ts b/src/reparse.ts
index 40663fd..50b5126 100644
--- a/src/reparse.ts
+++ b/src/reparse.ts
@@ -12,6 +12,7 @@
  */
 
 import { joinSplit, parseBlocks } from './parse.js';
+import { parseWindow } from './window.js';
 import type { BlockSpan, SplitDocument } from './types.js';
 
 /** Character edit against the prior joined source (`joinSplit(prior)`). */
@@ -202,18 +203,6 @@ function resolveDirtyOrdinals(
   return { from, to };
 }
 
-function priorWindow(
-  prior: SplitDocument,
-  priorText: string,
-  dirtyFrom: number,
-  dirtyTo: number,
-): { start: number; end: number } {
-  const n = prior.spans.length;
-  const start = dirtyFrom === 0 ? 0 : prior.spans[dirtyFrom - 1]!.end;
-  const end = dirtyTo === n - 1 ? priorText.length : prior.spans[dirtyTo + 1]!.start;
-  return { start, end };
-}
-
 function shiftSpan(span: BlockSpan, delta: number): BlockSpan {
   if (delta === 0) return span;
   return {
@@ -225,16 +214,6 @@ function shiftSpan(span: BlockSpan, delta: number): BlockSpan {
   };
 }
 
-function remapLocalSpan(span: BlockSpan, windowStart: number): BlockSpan {
-  return {
-    kind: span.kind,
-    start: span.start + windowStart,
-    end: span.end + windowStart,
-    markdown: span.markdown,
-    node: span.node,
-  };
-}
-
 function stitchCoverage(text: string, spans: readonly BlockSpan[], prior: SplitDocument, dirtyFrom: number, dirtyTo: number, middleCount: number): SplitDocument {
   if (spans.length === 0) {
     return { spans: [], leading: '', gaps: [], trailing: text };
@@ -311,34 +290,47 @@ export function reparseBlocks(options: ReparseBlocksOptions): ReparseBlocksResul
   const dirty = resolveDirtyOrdinals(prior, edit, replacedBlocks, slack);
   if (dirty === 'full' || prior.spans.length === 0) return finishFull();
 
-  const { from: dirtyFrom, to: dirtyTo } = dirty;
-  const window = priorWindow(prior, priorText, dirtyFrom, dirtyTo);
-
-  let windowStart: number;
-  let windowEnd: number;
-  if (edit) {
-    windowStart = mapPriorOffsetExclusiveEnd(window.start, edit);
-    windowEnd = mapPriorOffsetExclusiveEnd(window.end, edit);
-  } else {
-    // Block-ordinal path: host guarantees the change is confined to the dirty
-    // window, so prefix bytes are unchanged and suffix length is preserved.
-    windowStart = window.start;
-    windowEnd = text.length - (priorText.length - window.end);
-  }
+  const n = prior.spans.length;
+  // Everything before the edit is where it was; everything after it moved by
+  // the same amount. On the block path the host vouches that the change sits
+  // inside the dirty ordinals.
+  const delta = edit
+    ? edit.inserted.length - (edit.priorEnd - edit.priorStart)
+    : text.length - priorText.length;
 
-  if (windowStart < 0 || windowEnd < windowStart || windowEnd > text.length) {
+  // The window is pinned at both edges (see `window.ts`): it opens at the start
+  // of the untouched block before the dirty ordinals, and must close with the
+  // untouched block after them, exactly as that block was. If the edit ran on
+  // into it, as an unclosed fence does, the window is read on to the end of
+  // the text instead.
+  const leftOrdinal = dirty.from - 1;
+  const rightOrdinal = dirty.to + 1;
+  const left = leftOrdinal >= 0 ? prior.spans[leftOrdinal]! : null;
+  const right = rightOrdinal < n ? shiftSpan(prior.spans[rightOrdinal]!, delta) : null;
+  const windowStart = left ? left.start : 0;
+  if (
+    (left && text.slice(left.start, left.end) !== left.markdown)
+    || (right && (right.end > text.length || text.slice(right.start, right.end) !== right.markdown))
+  ) {
     return finishFull();
   }
 
-  const slice = text.slice(windowStart, windowEnd);
-  const local = parseBlocks(slice);
-  const middle = local.spans.map((span) => remapLocalSpan(span, windowStart));
+  let local = right ? parseWindow(text, windowStart, right.end, right) : null;
+  const anchored = local !== null;
+  if (local === null) local = parseWindow(text, windowStart, text.length, null);
+  if (local === null) return finishFull();
+  const windowEnd = anchored ? right!.end : text.length;
+
+  // The block before the window keeps its identity unless the edit changed how
+  // it ends (a line that now continues it, say).
+  const leftUnchanged = left !== null && local.length > 0
+    && local[0]!.start === left.start && local[0]!.end === left.end && local[0]!.kind === left.kind;
+  const dirtyFrom = leftUnchanged ? leftOrdinal + 1 : Math.max(0, leftOrdinal);
+  const dirtyTo = anchored ? rightOrdinal - 1 : n - 1;
+  const middle = local.slice(leftUnchanged ? 1 : 0, anchored ? -1 : undefined);
 
   const prefix = prior.spans.slice(0, dirtyFrom) as BlockSpan[];
-  const delta = edit
-    ? edit.inserted.length - (edit.priorEnd - edit.priorStart)
-    : text.length - priorText.length;
-  const suffix = prior.spans.slice(dirtyTo + 1).map((span) => shiftSpan(span, delta));
+  const suffix = anchored ? prior.spans.slice(rightOrdinal).map((span) => shiftSpan(span, delta)) : [];
 
   const spans: BlockSpan[] = [...prefix, ...middle, ...suffix];
   const stitched = stitchCoverage(text, spans, prior, dirtyFrom, dirtyTo, middle.length);
diff --git a/src/serialize-incremental.test.ts b/src/serialize-incremental.test.ts
new file mode 100644
index 0000000..4f46765
--- /dev/null
+++ b/src/serialize-incremental.test.ts
@@ -0,0 +1,190 @@
+import { describe, expect, it } from 'vitest';
+import { parseDocument } from './parse.js';
+import { identityUnits, serializeDocument, type SerializeUnit } from './serialize.js';
+import type { EngineDocument } from './types.js';
+
+/**
+ * A save builds the next document from the blocks it moved and a few small
+ * reparses instead of parsing its whole output again. That is only sound if
+ * the document it builds is the one a parse of the output would give; these
+ * hold it to exactly that.
+ */
+
+const encoder = new TextEncoder();
+
+function parsed(text: string, bom = false): EngineDocument {
+  const body = encoder.encode(text);
+  const bytes = bom ? Uint8Array.from([0xef, 0xbb, 0xbf, ...body]) : body;
+  const result = parseDocument(bytes);
+  if (result.status !== 'parsed') throw new Error(result.message);
+  return result.document;
+}
+
+function shape(document: EngineDocument) {
+  return {
+    envelope: document.envelope,
+    text: document.text,
+    leading: document.leading,
+    trailing: document.trailing,
+    gaps: document.gaps,
+    blocks: document.blocks.map((block) => [block.kind, block.start, block.end, block.markdown, block.node]),
+  };
+}
+
+/** Serialize, then check the document against a parse of the output. */
+function expectFaithful(document: EngineDocument, units: SerializeUnit[], label: string, envelope?: { hasFinalNewline?: boolean }) {
+  const result = envelope ? serializeDocument(document, { units, envelope }) : serializeDocument(document, { units });
+  if (result.status !== 'serialized') return result;
+  const full = parseDocument(result.outputBytes);
+  if (full.status !== 'parsed') throw new Error(full.message);
+  expect(shape(result.document), label).toEqual(shape(full.document));
+  return result;
+}
+
+const SOURCE = `---
+title: Saves
+---
+
+# Title
+
+A paragraph with *emphasis* and a [link](https://example.com).
+It continues on a second line.
+
+- first item
+- second item
+  - nested item
+
+Between the lists.
+
+- another list
+
+1. one
+2. two
+
+> A quote
+> that goes on.
+
+\`\`\`ts
+const value = 1;
+
+const other = 2;
+\`\`\`
+
+| a | b |
+| - | - |
+| 1 | 2 |
+
+$$
+x = y^2
+$$
+
+<div align="center">html</div>
+
+Text with a footnote.[^f]
+
+[^f]: The footnote.
+
+[ref]: https://example.com/ref
+
+Setext heading
+--------------
+
+    indented code
+
+***
+
+Last paragraph.
+`;
+
+const REPLACEMENTS = [
+  'A plain paragraph.', '```\nnever closed', '$$\nnever closed', '<!--\nnever closed', '- a list item',
+  '> a quote', '# A heading', '---', 'Title\n===', '1. numbered', '| x | y |\n| - | - |\n| 1 | 2 |',
+  '[r]: /u', '[^n]: note', '    indented', '<div>\nhtml', 'text with trailing spaces   ',
+];
+
+function rng(seed: number): () => number {
+  let state = seed >>> 0;
+  return () => {
+    state = (state * 1664525 + 1013904223) >>> 0;
+    return state / 0x100000000;
+  };
+}
+
+function editedUnits(document: EngineDocument, seed: number): SerializeUnit[] {
+  const random = rng(seed);
+  const units: SerializeUnit[] = identityUnits(document);
+  const operations = 1 + Math.floor(random() * 3);
+  for (let op = 0; op < operations && units.length > 1; op += 1) {
+    const at = Math.floor(random() * units.length);
+    const pick = random();
+    const markdown = REPLACEMENTS[Math.floor(random() * REPLACEMENTS.length)]!;
+    if (pick < 0.4) units[at] = { origin: units[at]!.origin, markdown };
+    else if (pick < 0.7) units.splice(at + (random() < 0.5 ? 0 : 1), 0, { origin: null, markdown });
+    else units.splice(at, 1);
+  }
+  return units;
+}
+
+describe('the document a save builds without a full reparse', () => {
+  const variants: [string, string, boolean][] = [
+    ['LF', SOURCE, false],
+    ['CRLF', SOURCE.replace(/\n/g, '\r\n'), false],
+    ['BOM', SOURCE, true],
+    ['no final newline', SOURCE.trimEnd(), false],
+    ['no frontmatter', SOURCE.slice(SOURCE.indexOf('# Title')), false],
+  ];
+  for (const [name, text, bom] of variants) {
+    it(`is the one a parse of the output gives (${name}, 500 generated saves)`, () => {
+      const document = parsed(text, bom);
+      let serialized = 0;
+      for (let seed = 1; seed <= 500; seed += 1) {
+        const result = expectFaithful(document, editedUnits(document, seed), `${name} seed ${seed}`);
+        if (result.status === 'serialized') serialized += 1;
+      }
+      expect(serialized).toBeGreaterThan(400);
+    });
+  }
+
+  it('moves untouched blocks instead of re-creating them', () => {
+    const document = parsed(SOURCE);
+    const units = identityUnits(document);
+    const target = document.blocks.findIndex((block) => block.markdown === 'Between the lists.');
+    units[target] = { origin: target, markdown: 'Between the two lists.' };
+    const result = expectFaithful(document, units, 'edit');
+    if (result.status !== 'serialized') throw new Error('expected a save');
+    // Before the edit: the very same objects. After it: the same text, moved.
+    expect(result.document.blocks[0]).toBe(document.blocks[0]);
+    expect(result.document.blocks[target - 2]).toBe(document.blocks[target - 2]);
+    expect(result.document.blocks.at(-1)!.markdown).toBe(document.blocks.at(-1)!.markdown);
+    expect(result.document.blocks.at(-1)!.start).toBe(document.blocks.at(-1)!.start + 4);
+  });
+
+  it('follows an unclosed fence to the end of the note', () => {
+    const document = parsed(SOURCE);
+    const units = identityUnits(document);
+    const target = document.blocks.findIndex((block) => block.markdown === 'Between the lists.');
+    // A tilde fence: nothing later in the note can close it.
+    units[target] = { origin: target, markdown: '~~~~\nnever closed' };
+    const result = expectFaithful(document, units, 'fence');
+    if (result.status !== 'serialized') throw new Error('expected a save');
+    expect(result.document.blocks.at(-1)!.kind).toBe('fenced-code');
+    expect(result.document.blocks.length).toBe(target + 1);
+  });
+
+  it('merges two lists when the paragraph between them goes', () => {
+    const document = parsed(SOURCE);
+    const target = document.blocks.findIndex((block) => block.markdown === 'Between the lists.');
+    const units = identityUnits(document).filter((_, index) => index !== target);
+    const result = expectFaithful(document, units, 'merge');
+    if (result.status !== 'serialized') throw new Error('expected a save');
+    expect(result.document.blocks.length).toBe(document.blocks.length - 2);
+  });
+
+  it('handles the first and last blocks going, and the final newline changing', () => {
+    const document = parsed(SOURCE);
+    expectFaithful(document, identityUnits(document).slice(1), 'first');
+    expectFaithful(document, identityUnits(document).slice(0, -1), 'last');
+    expectFaithful(document, identityUnits(document), 'final newline', { hasFinalNewline: false });
+    expectFaithful(document, [{ origin: null, markdown: '---\ntitle: new\n---' }, ...identityUnits(document).slice(1)], 'frontmatter');
+  });
+});
diff --git a/src/serialize.ts b/src/serialize.ts
index e85ed98..8b56837 100644
--- a/src/serialize.ts
+++ b/src/serialize.ts
@@ -10,8 +10,9 @@
 
 import { renderMarkdown } from './dialect.js';
 import { fromLf, toLf, type LineEnding } from './line-endings.js';
-import { parseDocument, parseSingleBlock } from './parse.js';
-import type { EngineDocument, EngineEnvelope } from './types.js';
+import { detectLineEnding, parseDocument, parseSingleBlock } from './parse.js';
+import type { BlockSpan, EngineDocument, EngineEnvelope } from './types.js';
+import { parseWindow } from './window.js';
 import type { RootContent } from 'mdast';
 
 const UTF8_BOM = Uint8Array.from([0xef, 0xbb, 0xbf]);
@@ -186,6 +187,127 @@ function gapBetween(
   };
 }
 
+/** Lone surrogates do not survive UTF-8: the output would read back differently. */
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+
+function isWellFormed(text: string): boolean {
+  const native = (text as { isWellFormed?: () => boolean }).isWellFormed;
+  return native ? native.call(text) : !LONE_SURROGATE.test(text);
+}
+
+/**
+ * The document `parseDocument(outputBytes)` would return, built without
+ * parsing all of it: every untouched block is moved to where it landed, and
+ * only the stretches around what changed are parsed again, each pinned at both
+ * edges (see `window.ts`). Null when a window does not hold, or the output is
+ * one this shortcut does not cover, and the caller parses the whole output.
+ *
+ * On an 8 MB note this is the difference between a full parse, about a
+ * hundred milliseconds, and parsing a handful of blocks.
+ */
+function nextDocument(
+  document: EngineDocument,
+  units: readonly SerializeUnit[],
+  pristine: readonly boolean[],
+  starts: readonly number[],
+  ends: readonly number[],
+  keptTrailing: boolean,
+  text: string,
+  bytes: Uint8Array,
+): EngineDocument | null {
+  const count = units.length;
+  const last = document.blocks.length - 1;
+  if (count === 0) return null;
+  // A leading U+FEFF would read back as a byte-order mark.
+  if (document.envelope.bom === 'none' && text.charCodeAt(0) === 0xfeff) return null;
+  for (let index = 0; index < count; index += 1) {
+    if (!pristine[index] && !isWellFormed(text.slice(starts[index]!, ends[index]!))) return null;
+  }
+
+  // Which units a window has to cover: every changed unit, both neighbours of
+  // a seam where blocks were deleted (two lists may now be one), and the ends
+  // of the note when its first or last block went or its last newline moved.
+  const inside = new Uint8Array(count);
+  for (let index = 0; index < count; index += 1) {
+    if (!pristine[index]) {
+      inside[index] = 1;
+      continue;
+    }
+    const ordinal = units[index]!.origin!;
+    if (index === 0 && ordinal !== 0) inside[index] = 1;
+    if (index === count - 1 && (ordinal !== last || !keptTrailing)) inside[index] = 1;
+    if (index > 0 && pristine[index - 1] && units[index - 1]!.origin !== ordinal - 1) {
+      inside[index - 1] = 1;
+      inside[index] = 1;
+    }
+  }
+
+  // Runs of covered units, each widened by one untouched unit on either side:
+  // the left one pins where the window starts, the right one is its anchor.
+  // Runs that would share an anchor are one window.
+  const windows: { first: number; last: number }[] = [];
+  for (let index = 0; index < count; index += 1) {
+    if (!inside[index]) continue;
+    let end = index;
+    while (end + 1 < count && inside[end + 1]) end += 1;
+    const first = Math.max(0, index - 1);
+    const lastUnit = Math.min(count - 1, end + 1);
+    const previous = windows.at(-1);
+    if (previous && first <= previous.last) previous.last = lastUnit;
+    else windows.push({ first, last: lastUnit });
+    index = end;
+  }
+
+  const blocks: BlockSpan[] = [];
+  let unit = 0;
+  for (const window of windows) {
+    for (; unit < window.first; unit += 1) blocks.push(moved(document, units[unit]!, starts[unit]!));
+    const from = window.first === 0 && inside[0] ? 0 : starts[window.first]!;
+    const closes = window.last === count - 1 && inside[count - 1];
+    const anchor = closes
+      ? null
+      : { kind: document.blocks[units[window.last]!.origin!]!.kind, start: starts[window.last]!, end: ends[window.last]! };
+    const spans = parseWindow(text, from, anchor ? anchor.end : text.length, anchor);
+    if (spans === null) return null;
+    for (const span of spans) blocks.push(span);
+    unit = window.last + 1;
+  }
+  for (; unit < count; unit += 1) blocks.push(moved(document, units[unit]!, starts[unit]!));
+
+  const gaps = new Array<string>(Math.max(0, blocks.length - 1));
+  for (let index = 0; index + 1 < blocks.length; index += 1) {
+    gaps[index] = text.slice(blocks[index]!.end, blocks[index + 1]!.start);
+  }
+  const first = blocks[0];
+  const final = blocks.at(-1);
+  return {
+    envelope: {
+      byteLength: bytes.byteLength,
+      bom: document.envelope.bom,
+      lineEnding: detectLineEnding(text),
+      hasFinalNewline: text.endsWith('\n'),
+    },
+    text,
+    blocks,
+    gaps,
+    leading: first ? text.slice(0, first.start) : '',
+    trailing: final ? text.slice(final.end) : text,
+  };
+}
+
+/** An untouched block where it landed in the output: same text, new offsets. */
+function moved(document: EngineDocument, unit: SerializeUnit, start: number): BlockSpan {
+  const block = document.blocks[unit.origin!]!;
+  if (block.start === start && block.node === null) return block;
+  return {
+    kind: block.kind,
+    start,
+    end: start + (block.end - block.start),
+    markdown: block.markdown,
+    node: null,
+  };
+}
+
 /**
  * Apply a block-mode save. Untouched spans are sliced from `document.text`.
  */
@@ -246,6 +368,10 @@ export function serializeDocument(
   }
 
   const pristine = units.map((unit) => isPristine(unit, document));
+  // Where each unit landed in the output, so the next document can be built
+  // without parsing all of it again.
+  const starts = new Array<number>(units.length);
+  const ends = new Array<number>(units.length);
 
   for (let index = 0; index < units.length; index += 1) {
     const unit = units[index]!;
@@ -265,12 +391,14 @@ export function serializeDocument(
       if (gap.preserved) keep(gap.preserved);
     }
 
+    starts[index] = cursor;
     if (pristine[index] && unit.origin !== null) {
       const block = document.blocks[unit.origin]!;
       // Byte-exact: slice original source, never re-stringify.
       const source = document.text.slice(block.start, block.end);
       emit(converting ? fromLf(toLf(source), lineEnding) : source);
       keep({ role: 'block', start: block.start, end: block.end });
+      ends[index] = cursor;
       continue;
     }
 
@@ -282,6 +410,7 @@ export function serializeDocument(
       return fail('MULTI_BLOCK_UNIT', 'Each editing unit must be exactly one markdown block.');
     }
     emit(fromLf(toLf(markdown), lineEnding));
+    ends[index] = cursor;
   }
 
   const lastUnit = units.at(-1);
@@ -289,12 +418,12 @@ export function serializeDocument(
     lastUnit?.origin === document.blocks.length - 1 && document.blocks.length > 0;
   const trailingUnchanged =
     !converting && hasFinalNewline === document.envelope.hasFinalNewline;
-  if (
+  const keptTrailing =
     endsAtLastBlock &&
-    pristine[units.length - 1] &&
+    pristine[units.length - 1] === true &&
     document.trailing.length > 0 &&
-    trailingUnchanged
-  ) {
+    trailingUnchanged;
+  if (keptTrailing) {
     const lastBlock = document.blocks[document.blocks.length - 1]!;
     emit(document.trailing);
     keep({
@@ -321,6 +450,19 @@ export function serializeDocument(
     };
   }
 
+  const incremental = converting
+    ? null
+    : nextDocument(document, units, pristine, starts, ends, keptTrailing, outputText, outputBytes);
+  if (incremental !== null) {
+    return {
+      status: 'serialized',
+      text: outputText,
+      outputBytes,
+      document: incremental,
+      preserved,
+    };
+  }
+
   const reparsed = parseDocument(outputBytes);
   if (reparsed.status !== 'parsed') {
     return fail('MULTI_BLOCK_UNIT', reparsed.message);
diff --git a/src/window.ts b/src/window.ts
new file mode 100644
index 0000000..54e1dc0
--- /dev/null
+++ b/src/window.ts
@@ -0,0 +1,77 @@
+/**
+ * Reparsing part of a document, and proving the answer is the one a parse of
+ * the whole document would give.
+ *
+ * The scanner reads a document top to bottom, and where a top-level block
+ * starts is decided by that block's first line and everything above it. So a
+ * window of the text can stand in for the whole parse when both of its edges
+ * are pinned:
+ *
+ * - **Left.** The window opens at offset 0, or at the start of a block whose
+ *   first line, and everything before it, reads as it did when the caller last
+ *   parsed it. A whole parse is then between blocks there, with nothing open,
+ *   exactly as the window's own parse is when it begins.
+ * - **Right.** The window closes at the end of the text, or at the end of an
+ *   *anchor*: an untouched block the caller expects there, followed by
+ *   untouched text. The window is only accepted when its last block is exactly
+ *   that anchor. Then nothing inside the window ran on into it, a whole parse
+ *   starts the anchor afresh just as it did before, and every block after it
+ *   reads as it did before, shifted.
+ *
+ * The anchor check is what makes this safe. Without it, an edit that opens a
+ * code fence and never closes it would look like one short block to the
+ * window, while a parse of the whole text would see the fence swallow
+ * everything after it.
+ */
+
+import { tryNativeSplit } from './backend/native-scanner.js';
+import type { BlockKind, BlockSpan } from './types.js';
+
+/** A first line the scanner would try as frontmatter (`isFrontmatterOpen`). */
+const OPENS_FRONTMATTER = /^---[^\S\r\n]*(?:\r\n|\r|\n|$)/;
+
+/** The block a window must end with: kind and absolute offsets. */
+export interface WindowAnchor {
+  readonly kind: BlockKind;
+  readonly start: number;
+  readonly end: number;
+}
+
+/**
+ * The blocks of `text[from, to)` with offsets into `text`, or `null` when the
+ * window does not end with `anchor`.
+ *
+ * The caller is responsible for the left edge (see the module comment); this
+ * checks the right one, and refuses a window that opens the note with a `---`
+ * it cannot close. `to` is `text.length` exactly when `anchor` is null.
+ * Frontmatter is only recognised when the window opens the document.
+ */
+export function parseWindow(
+  text: string,
+  from: number,
+  to: number,
+  anchor: WindowAnchor | null,
+): BlockSpan[] | null {
+  const local = tryNativeSplit(text.slice(from, to), from === 0);
+  // Frontmatter is the one block decided by looking arbitrarily far ahead: a
+  // `---` on the first line is frontmatter if a closing `---` comes anywhere
+  // after it, and a thematic break if none does. A window that opens the note
+  // with one, stops short of the end, and does not contain its close cannot
+  // tell which.
+  if (from === 0 && to < text.length && OPENS_FRONTMATTER.test(text) && local.spans[0]?.kind !== 'frontmatter') {
+    return null;
+  }
+  const spans: BlockSpan[] = local.spans.map((span) => ({
+    kind: span.kind,
+    start: span.start + from,
+    end: span.end + from,
+    markdown: span.markdown,
+    node: span.node,
+  }));
+  if (anchor === null) return spans;
+  const last = spans.at(-1);
+  if (last === undefined || last.start !== anchor.start || last.end !== anchor.end || last.kind !== anchor.kind) {
+    return null;
+  }
+  return spans;
+}