@@ -3,6 +3,9 @@
 *.bin binary
 *.png binary
 *.docx binary
+*.xlsx binary
+*.pptx binary
+*.pdf binary
 *.dll binary
 *.so binary
 *.dylib binary
 
@@ -177,6 +177,38 @@ apart.
   three fit from `ImagePane.Width/Height` — the file header's numbers, not the decoder's — one blank
   line under the pane's rows, so the placement rule lives once. Headers are sniffed by hand
   (`ImageHeader`) rather than by System.Drawing, which does not exist on macOS or Linux.
+- Documents (PDF, docx, xlsx, pptx, and SVG drawn beside its text) need **`src/DiffEngineViewer.Documents`**,
+  a separate assembly with Morph, Morph.PDFium, Skia and the OpenXml SDK behind it: tens of MB per
+  RID. So it ships only in a `documents/` folder of the three tool packages and of the tray (one folder
+  at `viewer/documents/`, which each RID copy finds one directory up), never in DiffEngine's bundle.
+  `Documents.targets` adds it, and only to RID-less builds - the bundle is the only per-RID publish -
+  which is the same switch the Mac and Linux heads use for their own natives. Its natives and `.pdb`s
+  are trimmed inside that project, from the items `deps.json` is generated from, because
+  `AssemblyDependencyResolver` refuses a folder whose `deps.json` names a missing asset for the
+  running RID.
+  - `DocumentPlugin.Find()` looks for the folder; absent, it is null all the way down and every
+    file reads exactly as before. Present, it loads on first use into a `DocumentLoadContext`, one
+    per process (PDFium's lock is a static of its assembly), through two methods bound by name with
+    BCL types only. It is **handed** to every reader from `ViewerProgram` - `FileSide.Read(path,
+    documents)`, `TrackedEntry`, `TrackedWatch`, `OwnerLink`, `MessageHandler` - never found by
+    each, so a test process does not read with whatever folder sits beside it.
+  - In process, by choice: a native fault in PDFium or Skia ends the window. A hang is given up on
+    after `DocumentWatch.Timeout`, and a PDF left behind holds PDFium's lock, so PDFs then fail at once.
+  - `FileSide.Read` only hashes a document, because it runs on the listener thread a test process
+    waits on. `DocumentWatch` (owned, attached and file modes) does the slow part from a copy taken
+    under the cache's hash directory, checked against the hash, so nothing holds a lock on the user's
+    file and what is drawn is what the hash says. Text replaces the entry once both sides are read
+    (`ViewerSession.TextRead`, by reference, as `Refresh` does); pages go into
+    `SessionState.Renders` by content hash a page at a time, so they never rebuild an entry or close
+    a menu, and `Sync` never undoes them.
+  - A page is an ordinary `ImagePane` pointing at a png, so no head and no ABI field knows what a
+    document is. Both view halves `ScreenBuilder.PaneRows` and the heads place the page under the rows
+    that are left; everything that scrolls a pane uses `PaneRows`, the queue column `BodyRows`.
+    Which page shows and which differ is said in the headers and status line, for the reason above.
+    `r`, `[` and `]` are additive `DeviewKey` values, as `m` was: no `DEVIEW_VERSION` bump, and the
+    footer buttons reach the same commands from a shim built before them.
+  - DiffEngine offers the viewer `DocumentExtensions.Paged` only when `ViewerDocuments.Beside` finds
+    the folder by the resolved exe (beside, one up, or in the tool store behind a shim).
 - Text selection is a view, and makes the same bargain images do. A drag arrives as both of its
   ends at once, in rows of the whole side rather than of the visible slice: a head knows the scroll
   top it drew the press with, so only it can resolve one that spans a wheel notch, and reporting
@@ -339,7 +371,8 @@ apart.
 **Packaging.Tests (`src/Packaging.Tests/`):**
 - Opens each `.nupkg` a Release build drops in `nugets` and snapshots its entry list, plus a few
   invariants a snapshot states poorly: an apphost with no assembly beside it, a viewer file in the
-  tray package, an incomplete bundled head.
+  tray package, an incomplete bundled head, a documents folder in DiffEngine's bundle, and a
+  documents folder whose `deps.json` names a native it does not carry.
 - Exists because package content is assembled by several unrelated MSBuild mechanisms and nothing
   else asserts the result. The failure mode it was written for is stale build output: `PackAsTool`
   packages the publish directory wholesale, and MSBuild never removes a file that stopped being
 
@@ -298,6 +298,10 @@ DiffTools.UseOrder(DiffTool.DiffEngineViewer);
    macOS, Dear ImGui through raylib on Linux
  * Compares images by format, dimensions and content, and draws them, with
    whichever formats each platform's own decoder reads
+ * The standalone tool and the copy installed with DiffEngineTray also read PDF,
+   docx, xlsx and pptx files - as text, as pages drawn, or both - and draw SVGs
+   beside their text. Offered for those files only when the copy found is one of
+   these, never the bundled one, which stays small
 
 #### Windows settings:
 
@@ -312,9 +316,9 @@ DiffTools.UseOrder(DiffTool.DiffEngineViewer);
   * Scanned paths:
     * `%USERPROFILE%\.dotnet\tools\DiffEngineViewer.exe`
     * `%USERPROFILE%\.dotnet\tools\.store\diffenginetray\*\diffenginetray\*\tools\*\any\viewer\win-x64\DiffEngineViewer.exe`
-    * `%NUGET_PACKAGES%\diffengine\20.5.2\tools\viewer\win-x64\DiffEngineViewer.exe`
+    * `%NUGET_PACKAGES%\diffengine\20.6.0\tools\viewer\win-x64\DiffEngineViewer.exe`
     * `%NUGET_PACKAGES%\diffengine\*\tools\viewer\win-x64\DiffEngineViewer.exe`
-    * `%USERPROFILE%\.nuget\packages\diffengine\20.5.2\tools\viewer\win-x64\DiffEngineViewer.exe`
+    * `%USERPROFILE%\.nuget\packages\diffengine\20.6.0\tools\viewer\win-x64\DiffEngineViewer.exe`
     * `%USERPROFILE%\.nuget\packages\diffengine\*\tools\viewer\win-x64\DiffEngineViewer.exe`
     * `%PATH%DiffEngineViewer.exe`
 
@@ -330,9 +334,9 @@ DiffTools.UseOrder(DiffTool.DiffEngineViewer);
    ```
   * Scanned paths:
     * `%HOME%/.dotnet/tools/DiffEngineViewer`
-    * `%NUGET_PACKAGES%/diffengine/20.5.2/tools/viewer/osx-x64/DiffEngineViewer`
+    * `%NUGET_PACKAGES%/diffengine/20.6.0/tools/viewer/osx-x64/DiffEngineViewer`
     * `%NUGET_PACKAGES%/diffengine/*/tools/viewer/osx-x64/DiffEngineViewer`
-    * `%HOME%/.nuget/packages/diffengine/20.5.2/tools/viewer/osx-x64/DiffEngineViewer`
+    * `%HOME%/.nuget/packages/diffengine/20.6.0/tools/viewer/osx-x64/DiffEngineViewer`
     * `%HOME%/.nuget/packages/diffengine/*/tools/viewer/osx-x64/DiffEngineViewer`
     * `%PATH%DiffEngineViewer`
 
@@ -348,9 +352,9 @@ DiffTools.UseOrder(DiffTool.DiffEngineViewer);
    ```
   * Scanned paths:
     * `%HOME%/.dotnet/tools/DiffEngineViewer`
-    * `%NUGET_PACKAGES%/diffengine/20.5.2/tools/viewer/linux-x64/DiffEngineViewer`
+    * `%NUGET_PACKAGES%/diffengine/20.6.0/tools/viewer/linux-x64/DiffEngineViewer`
     * `%NUGET_PACKAGES%/diffengine/*/tools/viewer/linux-x64/DiffEngineViewer`
-    * `%HOME%/.nuget/packages/diffengine/20.5.2/tools/viewer/linux-x64/DiffEngineViewer`
+    * `%HOME%/.nuget/packages/diffengine/20.6.0/tools/viewer/linux-x64/DiffEngineViewer`
     * `%HOME%/.nuget/packages/diffengine/*/tools/viewer/linux-x64/DiffEngineViewer`
     * `%PATH%DiffEngineViewer`
 
 
@@ -52,6 +52,8 @@ A delete is withdrawn when a later test run verifies against its file again, sin
 
 When the tray holds it, the window becomes disposable. A viewer that is closed, killed or crashes takes nothing pending with it, and the tray opens a new one on the same queue. A snapshot arriving with no window open starts one.
 
+The viewer installed with the tray also reads [documents](/docs/viewer.md#documents): PDF, Word, Excel and PowerPoint files as text, as their pages drawn, or both, and SVGs drawn beside their text. The copy bundled in the DiffEngine package does not. On a machine with the tray installed, test runs resolve the tray's copy ahead of the bundled one, so pending documents open in a viewer that can read them.
+
 "Pending Snapshots" accepts all of them. Clicking one accepts that one, and its drop down offers discard, opening the viewer on it, and opening the source file. A snapshot that failed to apply is marked with `!` and stays pending, so it can be retried once whatever blocked it is out of the way.
 
 Exiting the tray writes any still-pending inline snapshots back to disk, under the source project's `obj/VerifyInline/`, where accept tooling such as [Verify.Terminal](https://github.com/VerifyTests/Verify.Terminal) still finds them. A kill or a crash skips that, and loses the queue as it loses pending moves and deletes; re-run the tests.
 
@@ -21,7 +21,7 @@ All three draw the same screen model, and the layout, scrolling and keyboard han
  * https://www.nuget.org/packages/DiffEngineViewer.Mac
  * https://www.nuget.org/packages/DiffEngineViewer.Linux
 
-Only needed to use the viewer outside a project that references DiffEngine, since DiffEngine already bundles it.
+Only needed to use the viewer outside a project that references DiffEngine, since DiffEngine already bundles it, or to read [documents](#documents), which only these packages and the copy installed with [DiffEngineTray](/docs/tray.md) do.
 
 ```
 dotnet tool install -g DiffEngineViewer.Windows
@@ -72,6 +72,8 @@ Nothing is staged for inline review. A newly launched viewer gets the patch in a
 | `Up` `Down` `PgUp` `PgDn` `Home` `End` | Scroll |
 | `n` `p` | Next and previous change (also the **Next change** and **Prev change** buttons) |
 | `m` | Show only the changes, or every line (also the **Changes only** button) |
+| `r` | Cycle a [document](#documents) between text and picture, picture only, and text only (also the button naming the next view) |
+| `[` `]` | Previous and next page of a document (also **Prev page** and **Next page**) |
 | `Tab` `Shift+Tab` | Next and previous pending item |
 | `a` | Accept |
 | `Shift+A` | Accept all |
@@ -183,6 +185,37 @@ A format a head cannot decode draws nothing, and the comparison is still there i
 Accepting is the same act it is for text — copy the received file over the expected one, or forward the move to the tray — so nothing about reviewing an image changes what accepting one does.
 
 
+## Documents
+
+The standalone tool and the copy installed with [DiffEngineTray](/docs/tray.md) carry a `documents` folder, and with it read `.pdf`, `.docx`, `.xlsx` and `.pptx` files, and draw `.svg` files. The copy bundled in the DiffEngine package does not, to stay small: the folder is about 16 MB of libraries and 22 MB of natives per platform. That copy reads these files exactly as it always has, an SVG as text.
+
+A document is shown one of three ways, and `r`, or the button naming the next one, cycles between them:
+
+| View | Shows |
+| --- | --- |
+| Text and picture | The text in the top half of each pane, and the page being read drawn under it. The default. |
+| Picture only | The page, under two rows saying what each file is. |
+| Text only | The text, as any text file is shown. |
+
+What the text is depends on the format:
+
+ * SVG: the file itself.
+ * PDF: each page's text under a `--- page N ---` line, read with [PDFium](https://pdfium.googlesource.com/pdfium) through [Morph.PDFium](https://github.com/Papyrine/Morph.PDFium).
+ * Word, Excel and PowerPoint: the document as Markdown, from [Morph](https://github.com/Papyrine/Morph). Embedded pictures become `image-N` references rather than lines of base64.
+
+Pages are drawn by PDFium for a PDF, by Morph for an Office file and by [Svg.Skia](https://github.com/wieslawsoltes/Svg.Skia) for an SVG. A spreadsheet's pages are its printed pages rather than its sheets. Drawing is deterministic, so the same page always draws to the same bytes, which is how the viewer knows which pages differ. A small SVG is drawn at a reviewable size rather than its own, since a picture is never enlarged on screen.
+
+A document opens at its first page that differs, the way a text comparison opens at its first change. `[` and `]`, or **Prev page** and **Next page**, turn the page on both sides at once. With only the pictures on screen, **Prev change** and **Next change** move between the pages that differ.
+
+The status line says what is known about the pair as it becomes known: `reading text` and `drawing` while that happens, which page is showing and which differ, `every page draws the same` when the files differ only where nothing shows, and `documents are identical` when the bytes match. Each pane's header names the page it shows, `received.pdf (page 2 of 5)`, or `(no page 6)` when that side has fewer.
+
+Reading and drawing happen on a thread of their own once the window is up, so a long document never holds a test run waiting on the viewer. Each document is read from a copy the viewer takes, never the file itself, so it cannot hold a lock that stops it being accepted. They run inside the viewer's process: a document that hangs is given up on after two minutes, but one that crashes PDFium or Skia takes the window with it, and with no tray running, any inline snapshots the window was holding.
+
+An SVG is drawn with scripts, external images and external elements turned off. A snapshot is test output, and nothing in one gets to reach the network or the disk.
+
+DiffEngine offers the viewer for `.pdf`, `.docx`, `.xlsx` and `.pptx` only when the copy it resolved carries the folder. The viewer is last in the default tool order, so Word, Excel, Beyond Compare or DeltaWalker are still preferred where installed.
+
+
 ## With DiffEngineTray
 
 The tray starts at login, so it normally binds the port first and holds the queue. The viewer then displays it: it reads the pending snapshots back over the socket and forwards accept and discard rather than applying them. That is what `--attach` is for, and the tray starts one whenever a snapshot arrives with no window open.
 
@@ -59,6 +59,8 @@ A delete is withdrawn when a later test run verifies against its file again, sin
 
 When the tray holds it, the window becomes disposable. A viewer that is closed, killed or crashes takes nothing pending with it, and the tray opens a new one on the same queue. A snapshot arriving with no window open starts one.
 
+The viewer installed with the tray also reads [documents](/docs/viewer.md#documents): PDF, Word, Excel and PowerPoint files as text, as their pages drawn, or both, and SVGs drawn beside their text. The copy bundled in the DiffEngine package does not. On a machine with the tray installed, test runs resolve the tray's copy ahead of the bundled one, so pending documents open in a viewer that can read them.
+
 "Pending Snapshots" accepts all of them. Clicking one accepts that one, and its drop down offers discard, opening the viewer on it, and opening the source file. A snapshot that failed to apply is marked with `!` and stays pending, so it can be retried once whatever blocked it is out of the way.
 
 Exiting the tray writes any still-pending inline snapshots back to disk, under the source project's `obj/VerifyInline/`, where accept tooling such as [Verify.Terminal](https://github.com/VerifyTests/Verify.Terminal) still finds them. A kill or a crash skips that, and loses the queue as it loses pending moves and deletes; re-run the tests.