diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9e0b144..7489b99 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,17 @@ open: **a second build under the same version goes under the already cut
 heading, not back under `Unreleased`.** Date the heading and add its compare link
 once the version tag exists.
 
+## [Unreleased]
+
+### Changed
+
+- PDFs are rendered by odrcore instead of being handed to the web view, and a
+  password protected one takes the prompt the other formats use. Their text is
+  in the page, so they become searchable once odrcore writes the search script
+  for a pdf page as it does for a document.
+- The search button leaves the tool bar when the page cannot be searched,
+  rather than greying out - the same as the edit button.
+
 ## [1.40]
 
 ### Changed
diff --git a/OpenDocumentReader.xcodeproj/project.pbxproj b/OpenDocumentReader.xcodeproj/project.pbxproj
index 8ee56b2..bb657a4 100644
--- a/OpenDocumentReader.xcodeproj/project.pbxproj
+++ b/OpenDocumentReader.xcodeproj/project.pbxproj
@@ -29,6 +29,8 @@
 		E2A17B1000000000000000B0 /* test.ods in Resources */ = {isa = PBXBuildFile; fileRef = E2A17B1200000000000000B2 /* test.ods */; };
 		E2A17B1100000000000000B1 /* test.odp in Resources */ = {isa = PBXBuildFile; fileRef = E2A17B1300000000000000B3 /* test.odp */; };
 		E2A17B1400000000000000B4 /* test.csv in Resources */ = {isa = PBXBuildFile; fileRef = E2A17B1500000000000000B5 /* test.csv */; };
+		E2A17B1600000000000000B6 /* test.pdf in Resources */ = {isa = PBXBuildFile; fileRef = E2A17B1700000000000000B7 /* test.pdf */; };
+		E2A17B1800000000000000B8 /* test-encrypted.pdf in Resources */ = {isa = PBXBuildFile; fileRef = E2A17B1900000000000000B9 /* test-encrypted.pdf */; };
 		E2A17B2000000000000000C0 /* CoreFoundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = E2A17B2200000000000000C2 /* CoreFoundation.framework */; };
 		E2A17B2100000000000000C1 /* CFNetwork.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = E2A17B2300000000000000C3 /* CFNetwork.framework */; };
 		FB494C85E264BD924C1EA54E /* OdrCore in Frameworks */ = {isa = PBXBuildFile; productRef = E381918B979121CD165C966A /* OdrCore */; };
@@ -65,6 +67,8 @@
 		E2A17B1200000000000000B2 /* test.ods */ = {isa = PBXFileReference; lastKnownFileType = file; path = test.ods; sourceTree = "<group>"; };
 		E2A17B1300000000000000B3 /* test.odp */ = {isa = PBXFileReference; lastKnownFileType = file; path = test.odp; sourceTree = "<group>"; };
 		E2A17B1500000000000000B5 /* test.csv */ = {isa = PBXFileReference; lastKnownFileType = text; path = test.csv; sourceTree = "<group>"; };
+		E2A17B1700000000000000B7 /* test.pdf */ = {isa = PBXFileReference; lastKnownFileType = image.pdf; path = test.pdf; sourceTree = "<group>"; };
+		E2A17B1900000000000000B9 /* test-encrypted.pdf */ = {isa = PBXFileReference; lastKnownFileType = image.pdf; path = "test-encrypted.pdf"; sourceTree = "<group>"; };
 		E2A17B2200000000000000C2 /* CoreFoundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreFoundation.framework; path = System/Library/Frameworks/CoreFoundation.framework; sourceTree = SDKROOT; };
 		E2A17B2300000000000000C3 /* CFNetwork.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CFNetwork.framework; path = System/Library/Frameworks/CFNetwork.framework; sourceTree = SDKROOT; };
 /* End PBXFileReference section */
@@ -163,6 +167,8 @@
 				E2A17B1200000000000000B2 /* test.ods */,
 				E2A17B1300000000000000B3 /* test.odp */,
 				E2A17B1500000000000000B5 /* test.csv */,
+				E2A17B1700000000000000B7 /* test.pdf */,
+				E2A17B1900000000000000B9 /* test-encrypted.pdf */,
 				E22B252E2557F0E2001D0C52 /* OpenDocumentReaderTests.swift */,
 				E2A17B0300000000000000A3 /* PageTabBarTests.swift */,
 				E22B25302557F0E2001D0C52 /* Info.plist */,
@@ -353,6 +359,8 @@
 				E2A17B1000000000000000B0 /* test.ods in Resources */,
 				E2A17B1100000000000000B1 /* test.odp in Resources */,
 				E2A17B1400000000000000B4 /* test.csv in Resources */,
+				E2A17B1600000000000000B6 /* test.pdf in Resources */,
+				E2A17B1800000000000000B8 /* test-encrypted.pdf in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};
diff --git a/OpenDocumentReader/CoreWrapper.swift b/OpenDocumentReader/CoreWrapper.swift
index 331c06f..42f6d3c 100644
--- a/OpenDocumentReader/CoreWrapper.swift
+++ b/OpenDocumentReader/CoreWrapper.swift
@@ -7,7 +7,7 @@ let CoreWrapperErrorDomain = "app.opendocument.CoreWrapperErrorDomain"
 @objc enum CoreWrapperError: Int {
     case unknown = 1
     case wrongPassword = 2
-    /// Not a document odrcore can translate. PDFs land here on purpose.
+    /// Not something odrcore renders for us — see the guard in `translate`.
     case unsupportedFileType = 3
 }
 
@@ -107,11 +107,6 @@ private func isCsv(_ file: DecodedFile) -> Bool { file.fileType == .commaSeparat
         guard !fileTypes.isEmpty else {
             throw coreWrapperError(.unsupportedFileType, "odrcore does not recognise this file type")
         }
-        // PDFs are handed to WKWebView instead, which renders them natively
-        guard !fileTypes.contains(NSNumber(value: FileType.portableDocumentFormat.rawValue)) else {
-            throw coreWrapperError(
-                .unsupportedFileType, "PDF is rendered by the web view, not by odrcore")
-        }
 
         var file = try DecodedFile.decode(path: inputPath)
         if file.isPasswordEncrypted {
@@ -124,8 +119,11 @@ private func isCsv(_ file: DecodedFile) -> Bool { file.fileType == .commaSeparat
             }
         }
 
-        guard file.isDocumentFile || isCsv(file) else {
-            throw coreWrapperError(.unsupportedFileType, "not a document file")
+        // odrcore also translates images, media and fonts, but only into an
+        // `<img>` or a `<video>` the web view decodes anyway. Those go to the
+        // system instead, through the fallback in `DocumentViewController`.
+        guard file.isDocumentFile || file.isPdfFile || isCsv(file) else {
+            throw coreWrapperError(.unsupportedFileType, "not a document, a pdf or a csv")
         }
 
         // the same answers OpenDocument.droid gives odrcore, so a document is
@@ -161,8 +159,10 @@ private func isCsv(_ file: DecodedFile) -> Bool { file.fileType == .commaSeparat
             service = try HtmlTranslator.translate(
                 document: document, cachePath: cachePath, config: config)
         } else {
-            // not `.spreadsheet`, though a csv is one: that asks for a tab per
-            // sheet, and a csv's single sheet is called "csv"
+            // a csv and a pdf have no document behind them to open or to edit.
+            // `.unknown` keeps the combined view for both; not `.spreadsheet`,
+            // though a csv is one, because that asks for a tab per sheet and a
+            // csv's single sheet is called "csv"
             documentType = .unknown
             openedDocument = nil
             service = try HtmlTranslator.translate(
diff --git a/OpenDocumentReader/DocumentViewController.swift b/OpenDocumentReader/DocumentViewController.swift
index 8921c36..995e560 100644
--- a/OpenDocumentReader/DocumentViewController.swift
+++ b/OpenDocumentReader/DocumentViewController.swift
@@ -32,7 +32,10 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
         }
     }
 
-    private let EXTENSION_WHITELIST = [
+    /// The fallback for what odrcore does not render: what WKWebView and the
+    /// system decoders can show on their own. Not derived from odrcore's format
+    /// table — this is the other side of it.
+    private let systemRenderedExtensions = [
         "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "rtf", "rtfd.zip", "csv", "txt", "jpg", "jpeg", "png",
         "gif", "svg", "pages", "pages.zip", "numbers", "numbers.zip", "key", "key.zip", "mp3", "mp4", "flv", "mkv",
         "3gp", "aac", "bmp", "css", "htm", "html", "js", "json", "mpeg", "oga", "ogv", "sh", "tif", "tiff", "weba",
@@ -52,12 +55,27 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
     @IBOutlet weak var barButtonItem: UIBarButtonItem!
     @IBOutlet weak var searchButton: UIBarButtonItem!
     @IBOutlet weak var editButton: UIBarButtonItem!
+    /// The gaps behind those two. A button that leaves the bar takes its gap
+    /// with it, or what stays drifts off the trailing edge.
+    @IBOutlet weak var editButtonSpacer: UIBarButtonItem!
+    @IBOutlet weak var searchButtonSpacer: UIBarButtonItem!
 
-    /// The bar as the storyboard has it, and the same without the edit button.
-    /// Taken before anything is removed, since that is the only moment both are
-    /// there to be read.
+    /// The bar as the storyboard has it, taken before anything is removed, since
+    /// that is the only moment every button is there to be read.
     private lazy var toolBarItems: [UIBarButtonItem] = toolBar.items ?? []
-    private lazy var toolBarItemsWithoutEdit: [UIBarButtonItem] = toolBarItems.filter { $0 !== editButton }
+
+    /// Whether the document on screen can be edited and searched. Neither button
+    /// stays in the bar when it cannot be used.
+    private var canEdit = false { didSet { updateToolBar() } }
+    private var canSearch = false {
+        didSet {
+            updateToolBar()
+
+            if !canSearch {
+                hideSearchBar()
+            }
+        }
+    }
 
     /// What OpenDocument.droid gets from `loadWithOverviewMode`, which iOS has
     /// no setting for: a page wider than the screen is zoomed out until it fits
@@ -160,8 +178,8 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
         barButtonItem.accessibilityLabel = NSLocalizedString("back_to_documents", comment: "")
         editButton.accessibilityLabel = NSLocalizedString("menu_edit", comment: "")
 
-        // nothing is editable until a document says so
-        showEditButton(false)
+        // nothing is editable or searchable until a page says so
+        updateToolBar()
 
         setUpHouseAd()
     }
@@ -208,6 +226,10 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
         documentLoadingError(doc, error: DocumentError.pageNotServed)
     }
 
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        updateSearchButton()
+    }
+
     override func traitCollectionDidChange(_ previousTraitCollection: UITraitCollection?) {
         super.traitCollectionDidChange(previousTraitCollection)
 
@@ -395,14 +417,33 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
         editDocument()
     }
 
-    /// In the bar for the documents that can be edited, and only while they are
-    /// not being edited already. Every other document keeps the room for itself.
-    private func showEditButton(_ show: Bool) {
-        toolBar.items = show ? toolBarItems : toolBarItemsWithoutEdit
+    private func updateToolBar() {
+        toolBar.items = toolBarItems.filter { item in
+            if item === editButton || item === editButtonSpacer {
+                return canEdit
+            }
+            if item === searchButton || item === searchButtonSpacer {
+                return canSearch
+            }
+
+            return true
+        }
     }
 
+    /// Offered for the documents that can be edited, and only while they are not
+    /// being edited already.
     private func updateEditButton() {
-        showEditButton((document?.isEditable ?? false) && !(document?.edit ?? false))
+        canEdit = (document?.isEditable ?? false) && !(document?.edit ?? false)
+    }
+
+    /// Asked of the page rather than guessed from the format: odrcore writes the
+    /// `odr` object into what it renders as a document or as text, and into
+    /// nothing else — a pdf picks the button up on its own once it does.
+    private func updateSearchButton() {
+        webview.evaluateJavaScript("typeof odr === 'object' && typeof odr.search === 'function'") {
+            [weak self] available, _ in
+            self?.canSearch = available as? Bool ?? false
+        }
     }
 
     @IBAction func searchButton(_ sender: UIBarButtonItem) {
@@ -678,12 +719,12 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
         let fileType = doc.fileURL.pathExtension.lowercased()
 
         let fileName = doc.fileURL.absoluteString.lowercased()
-        if EXTENSION_WHITELIST.contains(where: fileName.hasSuffix) {
+        if systemRenderedExtensions.contains(where: fileName.hasSuffix) {
             // not odrcore's to render, but the web view knows the format
             self.webview.loadFileURL(doc.fileURL, allowingReadAccessTo: doc.fileURL)
 
-            searchButton.isEnabled = false
-            showEditButton(false)
+            canEdit = false
+            canSearch = false
 
             AnalyticsManager.shared.report(
                 "load_success",
@@ -712,12 +753,9 @@ class DocumentViewController: UIViewController, DocumentDelegate, UISearchBarDel
         progressBar.isHidden = false
         progressBar.observedProgress = doc.loadProgress
 
-        // only what odrcore translated is searchable, and a later parse — after
-        // a password, say — may well get there
-        searchButton.isEnabled = true
-
-        // whether this one can be edited is not known until it is parsed
-        showEditButton(false)
+        // neither is known until the page it produces is loaded
+        canEdit = false
+        canSearch = false
     }
 
     func documentLoadingCompleted(_ doc: Document) {
diff --git a/OpenDocumentReader/Main.storyboard b/OpenDocumentReader/Main.storyboard
index 850dd95..9b589da 100644
--- a/OpenDocumentReader/Main.storyboard
+++ b/OpenDocumentReader/Main.storyboard
@@ -107,11 +107,13 @@
                         <outlet property="bannerSlotHeight" destination="eXE-Ks-sQc" id="yQ1-l7-wiV"/>
                         <outlet property="barButtonItem" destination="yhO-7V-lbn" id="ach-z7-H9P"/>
                         <outlet property="editButton" destination="Ed1-tP-enc" id="Ed3-tP-enc"/>
+                        <outlet property="editButtonSpacer" destination="Ed4-tP-enc" id="Ed5-tP-enc"/>
                         <outlet property="menuButton" destination="Vsd-IL-ujz" id="GoN-tp-egn"/>
                         <outlet property="pageTabBar" destination="sIx-zo-9kG" id="pCn-x0-Z01"/>
                         <outlet property="progressBar" destination="ePk-bQ-fV8" id="nz6-qw-ouf"/>
                         <outlet property="searchBar" destination="A5V-8n-dvk" id="AIb-1s-JO6"/>
                         <outlet property="searchButton" destination="fGi-i7-iOR" id="77J-cW-TAe"/>
+                        <outlet property="searchButtonSpacer" destination="Di6-gg-JT6" id="Di7-gg-JT6"/>
                         <outlet property="toolBar" destination="N1x-QM-Qks" id="db4-aA-GH6"/>
                         <outlet property="webview" destination="VF5-Do-xh9" id="25W-hb-tHy"/>
                     </connections>
diff --git a/OpenDocumentReaderTests/OpenDocumentReaderTests.swift b/OpenDocumentReaderTests/OpenDocumentReaderTests.swift
index eb5c483..b5e9721 100644
--- a/OpenDocumentReaderTests/OpenDocumentReaderTests.swift
+++ b/OpenDocumentReaderTests/OpenDocumentReaderTests.swift
@@ -21,18 +21,18 @@ class OpenDocumentReaderTests: XCTestCase {
 
     /// Out of the read-only test bundle, and away from the temporary directory
     /// translating uses for its cache and output.
-    private func copyFixture(ofType pathExtension: String) throws -> URL {
+    private func copyFixture(ofType pathExtension: String, named name: String = "test") throws -> URL {
         let documentsURL = try FileManager.default.url(
             for: .documentDirectory,
             in: .userDomainMask,
             appropriateFor: nil,
             create: false)
 
-        let url = documentsURL.appendingPathComponent("test." + pathExtension)
+        let url = documentsURL.appendingPathComponent(name + "." + pathExtension)
         try? FileManager.default.removeItem(at: url)
 
         let bundlePath = try XCTUnwrap(
-            Bundle(for: Self.self).path(forResource: "test", ofType: pathExtension))
+            Bundle(for: Self.self).path(forResource: name, ofType: pathExtension))
         try FileManager.default.copyItem(at: URL(fileURLWithPath: bundlePath), to: url)
 
         return url
@@ -93,6 +93,86 @@ class OpenDocumentReaderTests: XCTestCase {
         XCTAssertEqual(wrapper.pageNames, ["document"])
     }
 
+    /// odrcore renders these now; they used to be handed to the web view.
+    func testPdfIsTranslated() throws {
+        let wrapper = CoreWrapper()
+        let url = try copyFixture(ofType: "pdf")
+
+        try wrapper.translate(
+            url.path, cache: temporaryDirectory, into: temporaryDirectory, with: nil, editable: false)
+
+        XCTAssertEqual(wrapper.pageNames, ["document"])
+    }
+
+    /// Its text has to reach the page, or there is nothing for search to walk.
+    func testPdfPageCarriesItsText() throws {
+        let wrapper = CoreWrapper()
+        let url = try copyFixture(ofType: "pdf")
+
+        try wrapper.translate(
+            url.path, cache: temporaryDirectory, into: temporaryDirectory, with: nil, editable: false)
+
+        let (data, _) = try fetch(try XCTUnwrap(wrapper.pageURLs.first))
+        let html = try XCTUnwrap(String(data: data, encoding: .utf8))
+
+        XCTAssertTrue(html.contains("First"), html)
+        XCTAssertTrue(html.contains("Second"), html)
+    }
+
+    /// `wrongPassword` rather than `unsupportedFileType`, because that is what
+    /// `Document.parse` turns into the prompt instead of the error page.
+    func testEncryptedPdfAsksForItsPassword() throws {
+        let wrapper = CoreWrapper()
+        let url = try copyFixture(ofType: "pdf", named: "test-encrypted")
+
+        for password in [nil, "wrong"] {
+            XCTAssertThrowsError(
+                try wrapper.translate(
+                    url.path, cache: temporaryDirectory, into: temporaryDirectory, with: password, editable: false)
+            ) { error in
+                XCTAssertEqual((error as NSError).code, CoreWrapperError.wrongPassword.rawValue)
+            }
+        }
+    }
+
+    func testEncryptedPdfOpensWithItsPassword() throws {
+        let wrapper = CoreWrapper()
+        let url = try copyFixture(ofType: "pdf", named: "test-encrypted")
+
+        try wrapper.translate(
+            url.path, cache: temporaryDirectory, into: temporaryDirectory, with: "secret", editable: false)
+
+        XCTAssertEqual(wrapper.pageNames, ["document"])
+
+        let (data, _) = try fetch(try XCTUnwrap(wrapper.pageURLs.first))
+        XCTAssertTrue(try XCTUnwrap(String(data: data, encoding: .utf8)).contains("First"))
+    }
+
+    func testPdfIsNotEditable() throws {
+        let wrapper = CoreWrapper()
+        let url = try copyFixture(ofType: "pdf")
+
+        try wrapper.translate(
+            url.path, cache: temporaryDirectory, into: temporaryDirectory, with: nil, editable: true)
+
+        XCTAssertFalse(wrapper.isEditable)
+    }
+
+    /// A png is one of the formats odrcore translates but we leave to the system.
+    func testImageIsLeftToTheSystem() throws {
+        let wrapper = CoreWrapper()
+
+        let image = URL(fileURLWithPath: temporaryDirectory).appendingPathComponent("test.png")
+        try Data([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]).write(to: image)
+
+        XCTAssertThrowsError(
+            try wrapper.translate(
+                image.path, cache: temporaryDirectory, into: temporaryDirectory, with: nil, editable: false)
+        ) { error in
+            XCTAssertEqual((error as NSError).code, CoreWrapperError.unsupportedFileType.rawValue)
+        }
+    }
+
     /// And it has no document behind it, so the menu must not offer to edit one.
     func testCsvIsNotEditable() throws {
         let wrapper = CoreWrapper()
diff --git a/OpenDocumentReaderTests/fixtures/make-fixtures.py b/OpenDocumentReaderTests/fixtures/make-fixtures.py
index 8e09181..99e46dd 100644
--- a/OpenDocumentReaderTests/fixtures/make-fixtures.py
+++ b/OpenDocumentReaderTests/fixtures/make-fixtures.py
@@ -8,9 +8,15 @@
     python3 OpenDocumentReaderTests/fixtures/make-fixtures.py
 """
 
+import shutil
+import subprocess
 import zipfile
 from pathlib import Path
 
+# what test-encrypted.pdf is locked with
+USER_PASSWORD = "secret"
+OWNER_PASSWORD = "owner"
+
 NAMESPACES = " ".join(
     [
         'xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0"',
@@ -81,6 +87,75 @@ def presentation(slides: list[str]) -> str:
     return content(f"  <office:presentation>\n{pages}\n  </office:presentation>")
 
 
+def pdf(pages: list[str]) -> bytes:
+    """A page per string, each showing it in Helvetica.
+
+    Assembled by hand rather than with a library, because the trailer carries the
+    byte offset of every object and nothing else about the file is hard.
+    """
+    font = 3
+    # 1 catalog, 2 pages, 3 font, then a page and its content stream each
+    page_numbers = [4 + 2 * index for index in range(len(pages))]
+
+    kids = " ".join(f"{number} 0 R" for number in page_numbers)
+    bodies = [
+        "<< /Type /Catalog /Pages 2 0 R >>",
+        f"<< /Type /Pages /Kids [{kids}] /Count {len(pages)} >>",
+        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>",
+    ]
+
+    for number, text in zip(page_numbers, pages):
+        stream = f"BT /F1 24 Tf 72 700 Td ({text}) Tj ET"
+        bodies.append(
+            f"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842]"
+            f" /Resources << /Font << /F1 {font} 0 R >> >>"
+            f" /Contents {number + 1} 0 R >>"
+        )
+        bodies.append(f"<< /Length {len(stream)} >>\nstream\n{stream}\nendstream")
+
+    out = bytearray(b"%PDF-1.4\n")
+    offsets = []
+    for number, body in enumerate(bodies, start=1):
+        offsets.append(len(out))
+        out += f"{number} 0 obj\n{body}\nendobj\n".encode("latin-1")
+
+    startxref = len(out)
+    out += f"xref\n0 {len(bodies) + 1}\n".encode("latin-1")
+    out += b"0000000000 65535 f \n"
+    for offset in offsets:
+        out += f"{offset:010d} 00000 n \n".encode("latin-1")
+    out += (
+        f"trailer\n<< /Size {len(bodies) + 1} /Root 1 0 R >>\n"
+        f"startxref\n{startxref}\n%%EOF\n"
+    ).encode("latin-1")
+
+    return bytes(out)
+
+
+def encrypt_pdf(source: Path, target: Path) -> None:
+    """AES-256, the standard security handler odrcore reads as `V 5`, `R 6`.
+
+    Through qpdf rather than by hand: AES is not in the standard library, and
+    R6 derives its key with it. Needs `brew install qpdf` to rerun.
+    """
+    if shutil.which("qpdf") is None:
+        raise SystemExit("qpdf not found; it writes the encrypted pdf fixture")
+
+    subprocess.run(
+        [
+            "qpdf",
+            "--encrypt",
+            f"--user-password={USER_PASSWORD}",
+            f"--owner-password={OWNER_PASSWORD}",
+            "--bits=256",
+            "--",
+            str(source),
+            str(target),
+        ],
+        check=True,
+    )
+
+
 def write(path: Path, mimetype: str, content_xml: str) -> None:
     with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as package:
         # first and uncompressed, or the package is only recognised by sniffing
@@ -107,6 +182,14 @@ def main() -> None:
         presentation(["Intro", "Outro"]),
     )
 
+    path = here.parent / "test.pdf"
+    path.write_bytes(pdf(["First", "Second"]))
+    print(f"wrote {path}")
+
+    encrypted = here.parent / "test-encrypted.pdf"
+    encrypt_pdf(path, encrypted)
+    print(f"wrote {encrypted}")
+
 
 if __name__ == "__main__":
     main()
diff --git a/OpenDocumentReaderTests/test-encrypted.pdf b/OpenDocumentReaderTests/test-encrypted.pdf
new file mode 100644
index 0000000..b9106ff
Binary files /dev/null and b/OpenDocumentReaderTests/test-encrypted.pdf differ
diff --git a/OpenDocumentReaderTests/test.pdf b/OpenDocumentReaderTests/test.pdf
new file mode 100644
index 0000000..2daf127
Binary files /dev/null and b/OpenDocumentReaderTests/test.pdf differ
diff --git a/fastlane/metadata/en-US/changelogs/1.41.txt b/fastlane/metadata/en-US/changelogs/1.41.txt
new file mode 100644
index 0000000..db64c34
--- /dev/null
+++ b/fastlane/metadata/en-US/changelogs/1.41.txt
@@ -0,0 +1,2 @@
+- PDFs are drawn by the app's own engine, so they fit the screen and behave like every other document
+- The search and edit buttons are there only for documents that can be searched or edited