diff --git a/AGENTS.md b/AGENTS.md
index a8270b69f..d7b271006 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -63,6 +63,7 @@ bytes ─▶ magic/open_strategy ─▶ DecodedFile ─▶ Document ─▶ Eleme
 | `src/odr/internal/oldms/` | **Legacy MS binary** (.doc/.ppt/.xls). |
 | `src/odr/internal/pdf/` | PDF (own parser). |
 | `src/odr/internal/xml/` | XML, rendered as a source view; see [`xml/AGENTS.md`](src/odr/internal/xml/AGENTS.md). |
+| `src/odr/internal/svg/` | SVG, detected by reading it as xml; see [`svg/AGENTS.md`](src/odr/internal/svg/AGENTS.md). |
 | `src/odr/internal/{csv,json,text,svm}/` | Smaller formats. |
 | `cli/src/` | CLI tools: `translate`, `back_translate`, `meta`, `server`. |
 | `python/` | Python bindings (`pyodr`, pybind11); see [`python/AGENTS.md`](python/AGENTS.md). |
@@ -177,6 +178,15 @@ Dispatch `release.yml` against main, publish the draft that appears —
   drifts from the header fails at **compile** time instead of becoming an obscure
   linker error. (The `util` helpers use the `struct string { static … }` idiom for
   exactly this.) Keep translation-unit-local helpers in an **anonymous namespace**.
+- **The input file never authors the output markup**: we interpret a file and
+  emit our own html — text through `escape_text`, images as an `<img>` we
+  construct. Nothing is passed through as live markup, which is why an svg goes
+  out as a data url rather than inlined ([`svg/AGENTS.md`](src/odr/internal/svg/AGENTS.md))
+  and why the rendered page needs no sanitiser. What is *not* consistent today
+  is link targets: `html/pdf_file.cpp` filters a PDF `/URI` action down to an
+  allowlist of navigable schemes, while a document hyperlink
+  (`html/document_element.cpp`) is only `escape_attribute`d, so a `javascript:`
+  href in an odt reaches the page. Pick one policy before adding a third.
 - **Public API**: value semantics; immutable handles; iterators only for immutable
   traversal (`docs/design/README.md`).
 - **Byte parsing**: read POD structs via `util::byte_stream::read`; assumes host
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c0f152038..eb95cb348 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,6 +18,8 @@ The release run heads these entries with the version and opens a fresh
 
 - An xml file opens as xml and reads as a foldable, highlighted source view
   rather than as one very long line, in the encoding its declaration names.
+- An svg is recognised by reading it rather than by what it is called, so bytes
+  that are not one no longer open as an image that cannot be shown.
 
 ## v6.4.0 - 2026-08-09
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6d1b30001..2c8e480d6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -235,7 +235,7 @@ set(ODR_SOURCE_FILES
         "src/odr/internal/font/sfnt_transform.cpp"
         "src/odr/internal/font/font_file.cpp"
 
-        "src/odr/internal/svg/svg_util.cpp"
+        "src/odr/internal/svg/svg_file.cpp"
 
         "src/odr/internal/svm/svm_file.cpp"
         "src/odr/internal/svm/svm_format.cpp"
diff --git a/src/odr/exceptions.cpp b/src/odr/exceptions.cpp
index 065ca8e05..aaa8d361c 100644
--- a/src/odr/exceptions.cpp
+++ b/src/odr/exceptions.cpp
@@ -70,6 +70,8 @@ NoLegacyMicrosoftFile::NoLegacyMicrosoftFile()
 
 NoXmlFile::NoXmlFile() : Exception("not an xml file") {}
 
+NoSvgFile::NoSvgFile() : Exception("not an svg file") {}
+
 UnsupportedCryptoAlgorithm::UnsupportedCryptoAlgorithm()
     : Exception("unsupported crypto algorithm") {}
 
diff --git a/src/odr/exceptions.hpp b/src/odr/exceptions.hpp
index dac37e653..c9d55fc17 100644
--- a/src/odr/exceptions.hpp
+++ b/src/odr/exceptions.hpp
@@ -147,6 +147,11 @@ struct NoXmlFile final : Exception {
   NoXmlFile();
 };
 
+/// @brief No SVG file exception
+struct NoSvgFile final : Exception {
+  NoSvgFile();
+};
+
 /// @brief Unsupported crypto algorithm exception
 struct UnsupportedCryptoAlgorithm final : Exception {
   UnsupportedCryptoAlgorithm();
diff --git a/src/odr/file.hpp b/src/odr/file.hpp
index 8343a95e7..61ed44c74 100644
--- a/src/odr/file.hpp
+++ b/src/odr/file.hpp
@@ -128,7 +128,8 @@ enum class FileType {
   audio_video_interleave,
 
   // More images that arrive alongside documents, named the same way and for
-  // the same reason as the block above - nothing here is decoded either.
+  // the same reason as the block above - nothing here is decoded either,
+  // except svg, which is xml.
   // https://en.wikipedia.org/wiki/SVG
   scalable_vector_graphics,
   // https://en.wikipedia.org/wiki/ICO_(file_format)
diff --git a/src/odr/internal/encoding/text_encoding_table.cpp b/src/odr/internal/encoding/text_encoding_table.cpp
index 26ec513fc..833438403 100644
--- a/src/odr/internal/encoding/text_encoding_table.cpp
+++ b/src/odr/internal/encoding/text_encoding_table.cpp
@@ -1,8 +1,9 @@
 #include <odr/internal/encoding/text_encoding_table.hpp>
 
+#include <odr/internal/util/string_util.hpp>
+
 #include <algorithm>
 #include <array>
-#include <cctype>
 #include <string>
 
 namespace odr::internal::encoding {
@@ -127,8 +128,7 @@ std::string normalize(const std::string_view name) {
     if (c == '-' || c == '_' || c == ' ') {
       continue;
     }
-    result.push_back(
-        static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
+    result.push_back(util::string::to_lower(c));
   }
   return result;
 }
diff --git a/src/odr/internal/file_type_table.cpp b/src/odr/internal/file_type_table.cpp
index c5063b54c..093ecd948 100644
--- a/src/odr/internal/file_type_table.cpp
+++ b/src/odr/internal/file_type_table.cpp
@@ -606,9 +606,9 @@ constexpr std::array table{
         DocumentType::unknown,
         {.detect_by_content = true, .open = true, .translate_html = true}},
 
-    // Named but not decoded, like the images above. `translate_html` means the
-    // image page is written and the data url labelled, not that every browser
-    // paints it.
+    // Named but not decoded, like the images above — except svg, which is xml
+    // and is parsed. For the rest `translate_html` means the image page is
+    // written and the data url labelled, not that every browser paints it.
     Row{FileType::scalable_vector_graphics,
         "svg"sv,
         svg_extensions,
diff --git a/src/odr/internal/html/media_file.cpp b/src/odr/internal/html/media_file.cpp
index 9cdd26919..f83dab673 100644
--- a/src/odr/internal/html/media_file.cpp
+++ b/src/odr/internal/html/media_file.cpp
@@ -10,9 +10,9 @@
 #include <odr/internal/html/frontend.hpp>
 #include <odr/internal/html/html_service.hpp>
 #include <odr/internal/html/html_writer.hpp>
+#include <odr/internal/util/string_util.hpp>
 
 #include <algorithm>
-#include <cctype>
 #include <filesystem>
 #include <optional>
 #include <span>
@@ -38,9 +38,7 @@ std::string source_extension(const DecodedFile &media_file) {
     std::string extension = std::filesystem::path(*path).extension().string();
     if (!extension.empty()) {
       extension.erase(0, 1); // the dot
-      std::ranges::transform(extension, extension.begin(), [](const char c) {
-        return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-      });
+      extension = util::string::to_lower(extension);
       if (std::ranges::find(extensions, extension) != extensions.end()) {
         return extension;
       }
diff --git a/src/odr/internal/html/pdf_file.cpp b/src/odr/internal/html/pdf_file.cpp
index 5eb75cdd9..ce7e21320 100644
--- a/src/odr/internal/html/pdf_file.cpp
+++ b/src/odr/internal/html/pdf_file.cpp
@@ -186,12 +186,11 @@ bool is_safe_uri(std::string_view uri) {
   for (const char ch : uri) {
     const auto c = static_cast<unsigned char>(ch);
     if (ch == ':') {
-      std::ranges::transform(scheme, scheme.begin(), [](const char s) {
-        return static_cast<char>(std::tolower(static_cast<unsigned char>(s)));
-      });
       static constexpr std::array<std::string_view, 6> allowed = {
           "http", "https", "mailto", "ftp", "ftps", "tel"};
-      return std::ranges::find(allowed, scheme) != allowed.end();
+      return std::ranges::any_of(allowed, [&scheme](const std::string_view s) {
+        return util::string::equals_ignore_case(scheme, s);
+      });
     }
     if (ch == '/' || ch == '?' || ch == '#') {
       return true; // path/query/fragment reached first -> relative reference
diff --git a/src/odr/internal/open_strategy.cpp b/src/odr/internal/open_strategy.cpp
index ccf821428..68a4e2606 100644
--- a/src/odr/internal/open_strategy.cpp
+++ b/src/odr/internal/open_strategy.cpp
@@ -18,12 +18,13 @@
 #include <odr/internal/oldms/oldms_file.hpp>
 #include <odr/internal/ooxml/ooxml_file.hpp>
 #include <odr/internal/pdf/pdf_file.hpp>
-#include <odr/internal/svg/svg_util.hpp>
+#include <odr/internal/svg/svg_file.hpp>
 #include <odr/internal/svm/svm_file.hpp>
 #include <odr/internal/xml/xml_file.hpp>
 #include <odr/internal/zip/zip_file.hpp>
 
 #include <algorithm>
+#include <memory>
 
 namespace odr::internal {
 
@@ -121,6 +122,18 @@ open_file_as(const std::shared_ptr<abstract::File> &file, const FileType as,
     throw NoSvmFile();
   }
 
+  if (as == FileType::scalable_vector_graphics) {
+    ODR_VERBOSE(logger, "open as svg");
+    try {
+      auto text = std::make_shared<text::TextFile>(file);
+      return std::make_unique<svg::SvgFile>(
+          std::make_shared<xml::XmlFile>(text));
+    } catch (...) {
+      ODR_VERBOSE(logger, "failed to open as svg");
+    }
+    throw NoSvgFile();
+  }
+
   // no decoder below: the bytes go to the browser as they are, so only the
   // category has to be right
   const FileCategory category = file_category_by_file_type(as);
@@ -305,14 +318,12 @@ open_strategy::list_file_types(const std::shared_ptr<abstract::File> &file,
       // xml, so both are reported
       try {
         ODR_VERBOSE(logger, "try open as xml");
-        result.push_back(xml::XmlFile(text).file_type());
-
-        try {
-          ODR_VERBOSE(logger, "try open as svg");
-          svg::check_svg_file(*file->stream());
-          result.push_back(FileType::scalable_vector_graphics);
-        } catch (...) {
-          ODR_VERBOSE(logger, "failed to open as svg");
+        auto xml_file = std::make_shared<xml::XmlFile>(text);
+        result.push_back(xml_file->file_type());
+
+        if (svg::is_svg_file(*xml_file)) {
+          ODR_VERBOSE(logger, "open as svg");
+          result.push_back(svg::SvgFile(xml_file).file_type());
         }
       } catch (...) {
         ODR_VERBOSE(logger, "failed to open as xml");
@@ -427,20 +438,22 @@ open_strategy::open_file(const std::shared_ptr<abstract::File> &file,
         ODR_VERBOSE(logger, "failed to open as json");
       }
 
-      // svg first - it is the more specific reading of the same bytes - and
-      // xml last, before the line list
-      try {
-        ODR_VERBOSE(logger, "try open as svg");
-        svg::check_svg_file(*file->stream());
-        return std::make_unique<ImageFile>(file,
-                                           FileType::scalable_vector_graphics);
-      } catch (...) {
-        ODR_VERBOSE(logger, "failed to open as svg");
-      }
-
+      // svg is read off the parse xml already did: it is the more specific
+      // reading of the same bytes, and xml is the last resort before the line
+      // list
       try {
         ODR_VERBOSE(logger, "try open as xml");
-        return std::make_unique<xml::XmlFile>(text);
+        auto xml_file = std::make_unique<xml::XmlFile>(text);
+
+        if (!svg::is_svg_file(*xml_file)) {
+          ODR_VERBOSE(logger, "not an svg");
+          // handed on as it is, so the parse is not repeated
+          return xml_file;
+        }
+
+        ODR_VERBOSE(logger, "open as svg");
+        return std::make_unique<svg::SvgFile>(
+            std::shared_ptr<xml::XmlFile>(std::move(xml_file)));
       } catch (...) {
         ODR_VERBOSE(logger, "failed to open as xml");
       }
diff --git a/src/odr/internal/pdf/pdf_afm.cpp b/src/odr/internal/pdf/pdf_afm.cpp
index 3d6fd02b3..8178ea498 100644
--- a/src/odr/internal/pdf/pdf_afm.cpp
+++ b/src/odr/internal/pdf/pdf_afm.cpp
@@ -1,10 +1,10 @@
 #include <odr/internal/pdf/pdf_afm.hpp>
 
 #include <odr/internal/pdf/pdf_afm_data.hpp>
+#include <odr/internal/util/string_util.hpp>
 
 #include <algorithm>
 #include <array>
-#include <cctype>
 
 namespace odr::internal::pdf {
 
@@ -35,11 +35,7 @@ std::string normalize_name(std::string_view base_font) {
       base_font.remove_prefix(7);
     }
   }
-  std::string result(base_font);
-  for (char &c : result) {
-    c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
-  }
-  return result;
+  return util::string::to_lower(base_font);
 }
 
 bool contains(const std::string &haystack, const std::string_view needle) {
diff --git a/src/odr/internal/svg/AGENTS.md b/src/odr/internal/svg/AGENTS.md
new file mode 100644
index 000000000..85319fd4c
--- /dev/null
+++ b/src/odr/internal/svg/AGENTS.md
@@ -0,0 +1,76 @@
+# AGENTS.md — `internal/svg`
+
+Read the root [`AGENTS.md`](../../../../AGENTS.md) first. This file covers what
+svg does differently, and why.
+
+## An svg is xml
+
+`SvgFile` is an `abstract::ImageFile` over a `std::shared_ptr<xml::XmlFile>`.
+The [xml module](../xml/AGENTS.md) parses, rejects what is not well formed, and
+resolves the encoding from the declaration. What is left is one question — is
+the root element `svg`? — answered by `is_svg_file` against
+`XmlFile::root_name()`, which the xml parse already recorded, so detection costs
+one parse and not two.
+
+pugixml does not process namespaces, so the root name arrives with whatever
+prefix the document bound (`<s:svg>`) and the prefix comes off by hand.
+
+`FileType::scalable_vector_graphics` is therefore no longer a label the generic
+`common::ImageFile` will put on any bytes: `open` as an svg throws `NoSvgFile`
+unless it is one.
+
+`is_svg_file` is a predicate rather than a throwing check because
+`open_strategy` asks the question without wanting the file: an xml that is not
+an svg is handed on as the `XmlFile` already built, so the parse is not
+repeated.
+
+Every layer stays reachable from the one above — `xml_file()`, `text_file()`,
+`file()`, plus `document()` and `text()` forwarded from the xml layer. A
+downstream reader needs neither a second parse nor a second decode. Note that
+`text_file()->text()` decodes with the encoding *detected over the bytes* while
+`text()` uses the one the *declaration* names; for an xml document the latter is
+the right answer.
+
+## It renders as an image, like every other image
+
+The markup goes into the page as `<img src="data:image/svg+xml;base64,…">` —
+`html/image_file.cpp`, the same path as png and jpeg, and the same path an svg
+*inside* a document takes through `translate_image_src`. Nothing in this module
+renders.
+
+That is a deliberate choice and worth keeping on record, because the obvious
+improvement — inline the markup so the drawing scales to the viewport and its
+text is selectable — costs more than it looks:
+
+- **Inside an `<img>` a browser renders svg in secure static mode.** Scripts do
+  not run, external references are not fetched, animation is frozen. That is a
+  browser guarantee, free, and it holds for a file that came from wherever the
+  user got it.
+- **Inlined, the markup is live**, and it is the only path in the library where
+  the input file authors the output DOM. Everywhere else we interpret the file
+  and emit our own markup — text goes through `escape_text`, images become an
+  `<img>` we construct. Inlining means `<script>` inside the svg *is* a script
+  tag, `onload=` fires, `<image href="https://…">` fetches, `<foreignObject>`
+  carries arbitrary html. Our output is displayed in a WebView with a bridge to
+  native (`docs/design/editing.md`).
+- So inlining requires **re-implementing secure static mode by hand** — a scrub
+  of script and embedding elements, event handlers, references that leave the
+  document, SMIL aimed at any of those, and css that reaches outside — plus a
+  `script-src 'none'` policy on the page, plus stripping the prefix a document
+  bound to the svg namespace (the html parser enters foreign content on `svg`,
+  not on `s:svg`). It was written once and removed again; `git log` for
+  `svg_util.cpp` has it, tests included.
+- And a scrub **interferes with the file**: valid, harmless things go — an
+  `<image href="chart.png">`, a webfont, half of SMIL. Someone who opens an
+  animated svg gets a still.
+
+If scalable, selectable svg is wanted later, isolation beats modification:
+serve the file as its own resource in a sandboxed iframe, where the browser
+contains it and the file stays intact.
+
+## The xml layer is not free
+
+`XmlFile` holds the parsed tree for as long as the file is open, and pugixml's
+dom is roughly twice the source. An svg costs that even though nothing reads
+the tree after the root-name check — the price of detecting by reading rather
+than by extension.
diff --git a/src/odr/internal/svg/svg_file.cpp b/src/odr/internal/svg/svg_file.cpp
new file mode 100644
index 000000000..d449ddb72
--- /dev/null
+++ b/src/odr/internal/svg/svg_file.cpp
@@ -0,0 +1,73 @@
+#include <odr/internal/svg/svg_file.hpp>
+
+#include <odr/exceptions.hpp>
+
+#include <string_view>
+#include <utility>
+
+namespace odr::internal {
+
+namespace {
+
+/// pugixml does not process namespaces, so the prefix comes off by hand.
+std::string_view local_name(std::string_view name) {
+  if (const std::size_t colon = name.find(':');
+      colon != std::string_view::npos) {
+    name.remove_prefix(colon + 1);
+  }
+  return name;
+}
+
+} // namespace
+
+bool svg::is_svg_file(const xml::XmlFile &file) {
+  return local_name(file.root_name()) == "svg";
+}
+
+svg::SvgFile::SvgFile(std::shared_ptr<xml::XmlFile> file)
+    : m_file{std::move(file)} {
+  if (!is_svg_file(*m_file)) {
+    throw NoSvgFile();
+  }
+}
+
+std::shared_ptr<abstract::File> svg::SvgFile::file() const noexcept {
+  return m_file->file();
+}
+
+FileType svg::SvgFile::file_type() const noexcept {
+  return FileType::scalable_vector_graphics;
+}
+
+std::string_view svg::SvgFile::mimetype() const noexcept {
+  return "image/svg+xml";
+}
+
+FileMeta svg::SvgFile::file_meta() const noexcept {
+  FileMeta result;
+  result.type = file_type();
+  result.mimetype = mimetype();
+  return result;
+}
+
+bool svg::SvgFile::is_decodable() const noexcept { return false; }
+
+std::shared_ptr<abstract::Image> svg::SvgFile::image() const {
+  throw UnsupportedFileEncoding("generally unsupported");
+}
+
+std::shared_ptr<xml::XmlFile> svg::SvgFile::xml_file() const noexcept {
+  return m_file;
+}
+
+std::shared_ptr<text::TextFile> svg::SvgFile::text_file() const noexcept {
+  return m_file->text_file();
+}
+
+const pugi::xml_document &svg::SvgFile::document() const noexcept {
+  return m_file->document();
+}
+
+std::string svg::SvgFile::text() const { return m_file->text(); }
+
+} // namespace odr::internal
diff --git a/src/odr/internal/svg/svg_file.hpp b/src/odr/internal/svg/svg_file.hpp
new file mode 100644
index 000000000..68cec1453
--- /dev/null
+++ b/src/odr/internal/svg/svg_file.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <odr/file.hpp>
+
+#include <odr/internal/xml/xml_file.hpp>
+
+#include <memory>
+#include <string>
+
+namespace odr::internal::svg {
+
+/// Whether @p file's root element is `svg`, which is all that tells an svg from
+/// any other xml - and what @ref SvgFile's constructor throws on.
+[[nodiscard]] bool is_svg_file(const xml::XmlFile &file);
+
+/// An image whose bytes are an xml document, so the xml decoder is what
+/// recognises it and what resolves its encoding. Nothing is drawn from the
+/// tree - the markup goes into a page as the `<img>` data url every other
+/// image does.
+class SvgFile final : public abstract::ImageFile {
+public:
+  /// @throws NoSvgFile if @p file's root element is not `svg`.
+  explicit SvgFile(std::shared_ptr<xml::XmlFile> file);
+
+  [[nodiscard]] std::shared_ptr<abstract::File> file() const noexcept override;
+
+  [[nodiscard]] FileType file_type() const noexcept override;
+  [[nodiscard]] std::string_view mimetype() const noexcept override;
+  [[nodiscard]] FileMeta file_meta() const noexcept override;
+
+  [[nodiscard]] bool is_decodable() const noexcept override;
+
+  [[nodiscard]] std::shared_ptr<abstract::Image> image() const override;
+
+  /// The xml file underneath, and the text file under that: what parsed the
+  /// markup, and what holds the bytes.
+  [[nodiscard]] std::shared_ptr<xml::XmlFile> xml_file() const noexcept;
+  [[nodiscard]] std::shared_ptr<text::TextFile> text_file() const noexcept;
+
+  /// @ref xml_file's tree.
+  [[nodiscard]] const pugi::xml_document &document() const noexcept;
+
+  /// The document's markup, decoded to utf-8.
+  /// @throws UnsupportedTextEncoding if its encoding cannot be decoded.
+  [[nodiscard]] std::string text() const;
+
+private:
+  std::shared_ptr<xml::XmlFile> m_file;
+};
+
+} // namespace odr::internal::svg
diff --git a/src/odr/internal/svg/svg_util.cpp b/src/odr/internal/svg/svg_util.cpp
deleted file mode 100644
index 8823ec0a5..000000000
--- a/src/odr/internal/svg/svg_util.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <odr/internal/svg/svg_util.hpp>
-
-#include <odr/internal/util/xml_util.hpp>
-
-#include <pugixml.hpp>
-
-#include <stdexcept>
-#include <string_view>
-
-namespace odr::internal {
-
-void svg::check_svg_file(std::istream &in) {
-  const pugi::xml_document document = util::xml::parse(in);
-
-  // pugixml does not process namespaces, so the root element carries whatever
-  // prefix the document bound to the svg namespace
-  std::string_view name = document.document_element().name();
-  if (const std::size_t colon = name.find(':');
-      colon != std::string_view::npos) {
-    name.remove_prefix(colon + 1);
-  }
-
-  if (name != "svg") {
-    throw std::runtime_error("no svg file");
-  }
-}
-
-} // namespace odr::internal
diff --git a/src/odr/internal/svg/svg_util.hpp b/src/odr/internal/svg/svg_util.hpp
deleted file mode 100644
index 61cac5e93..000000000
--- a/src/odr/internal/svg/svg_util.hpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#pragma once
-
-#include <iosfwd>
-
-namespace odr::internal::svg {
-
-/// Throws unless @p in holds an xml document whose root element is `svg`.
-void check_svg_file(std::istream &in);
-
-} // namespace odr::internal::svg
diff --git a/src/odr/internal/util/string_util.cpp b/src/odr/internal/util/string_util.cpp
index 1fa0f33a1..7279f15b2 100644
--- a/src/odr/internal/util/string_util.cpp
+++ b/src/odr/internal/util/string_util.cpp
@@ -4,6 +4,7 @@
 #include <cctype>
 #include <cstdint>
 #include <iomanip>
+#include <iterator>
 #include <sstream>
 #include <stdexcept>
 
@@ -24,6 +25,48 @@ bool string::is_ascii_space(const char c) {
   return std::isspace(static_cast<std::uint8_t>(c)) != 0;
 }
 
+char string::to_lower(const char c) {
+  return static_cast<char>(std::tolower(static_cast<std::uint8_t>(c)));
+}
+
+std::string string::to_lower(const std::string_view string) {
+  std::string result;
+  result.reserve(string.size());
+  std::ranges::transform(string, std::back_inserter(result),
+                         [](const char c) { return to_lower(c); });
+  return result;
+}
+
+bool string::equals_ignore_case(const std::string_view a,
+                                const std::string_view b) {
+  return std::ranges::equal(a, b, [](const char x, const char y) {
+    return to_lower(x) == to_lower(y);
+  });
+}
+
+bool string::starts_with_ignore_case(const std::string_view string,
+                                     const std::string_view prefix) {
+  return string.size() >= prefix.size() &&
+         equals_ignore_case(string.substr(0, prefix.size()), prefix);
+}
+
+std::size_t string::find_ignore_case(const std::string_view string,
+                                     const std::string_view needle,
+                                     const std::size_t from) {
+  if (from > string.size()) {
+    return std::string_view::npos;
+  }
+  const std::string_view rest = string.substr(from);
+  const auto found =
+      std::ranges::search(rest, needle, [](const char x, const char y) {
+        return to_lower(x) == to_lower(y);
+      });
+  if (found.empty()) {
+    return std::string_view::npos;
+  }
+  return from + static_cast<std::size_t>(found.begin() - rest.begin());
+}
+
 void string::ltrim_inplace(std::string &s, const CharPredicate is_space) {
   s.erase(s.begin(), std::ranges::find_if(s, [is_space](const char ch) {
             return !is_space(ch);
diff --git a/src/odr/internal/util/string_util.hpp b/src/odr/internal/util/string_util.hpp
index b3b6f0a58..de62c30aa 100644
--- a/src/odr/internal/util/string_util.hpp
+++ b/src/odr/internal/util/string_util.hpp
@@ -17,6 +17,19 @@ using CharPredicate = bool (*)(char);
 /// `std::isspace` for the default C locale, made safe for any `char` value.
 bool is_ascii_space(char c);
 
+/// `std::tolower` for the default C locale, made safe for any `char` value.
+char to_lower(char c);
+std::string to_lower(std::string_view string);
+
+/// The comparisons below fold case with @ref to_lower, so only ascii letters
+/// are folded and a utf-8 sequence is compared byte for byte.
+bool equals_ignore_case(std::string_view a, std::string_view b);
+bool starts_with_ignore_case(std::string_view string, std::string_view prefix);
+/// The first occurrence of @p needle in @p string at or after @p from, or
+/// `std::string_view::npos`.
+std::size_t find_ignore_case(std::string_view string, std::string_view needle,
+                             std::size_t from = 0);
+
 void ltrim_inplace(std::string &s, CharPredicate is_space = is_ascii_space);
 void rtrim_inplace(std::string &s, CharPredicate is_space = is_ascii_space);
 void trim_inplace(std::string &s, CharPredicate is_space = is_ascii_space);
diff --git a/src/odr/internal/xml/xml_file.cpp b/src/odr/internal/xml/xml_file.cpp
index 6103fbdaf..52bc45ffd 100644
--- a/src/odr/internal/xml/xml_file.cpp
+++ b/src/odr/internal/xml/xml_file.cpp
@@ -78,6 +78,10 @@ bool xml::XmlFile::is_decodable() const noexcept { return false; }
 
 TextEncoding xml::XmlFile::encoding() const noexcept { return m_encoding; }
 
+std::shared_ptr<text::TextFile> xml::XmlFile::text_file() const noexcept {
+  return m_file;
+}
+
 std::string xml::XmlFile::text() const {
   // a parser only ever sees utf-8; there is no handing the bytes on undecoded
   if (!text_encoding_is_decodable(m_encoding)) {
@@ -91,4 +95,8 @@ const pugi::xml_document &xml::XmlFile::document() const noexcept {
   return *m_document;
 }
 
+std::string_view xml::XmlFile::root_name() const noexcept {
+  return m_document->document_element().name();
+}
+
 } // namespace odr::internal
diff --git a/src/odr/internal/xml/xml_file.hpp b/src/odr/internal/xml/xml_file.hpp
index 5b610e276..a43e59d50 100644
--- a/src/odr/internal/xml/xml_file.hpp
+++ b/src/odr/internal/xml/xml_file.hpp
@@ -34,6 +34,10 @@ class XmlFile final : public abstract::TextFile {
   /// bytes were detected as.
   [[nodiscard]] TextEncoding encoding() const noexcept override;
 
+  /// The text file the bytes came from. Its `text()` decodes with the encoding
+  /// detected over the bytes; @ref text uses the one the declaration names.
+  [[nodiscard]] std::shared_ptr<text::TextFile> text_file() const noexcept;
+
   /// The file's bytes decoded to utf-8.
   /// @throws UnsupportedTextEncoding if @ref encoding cannot be decoded.
   [[nodiscard]] std::string text() const;
@@ -46,6 +50,10 @@ class XmlFile final : public abstract::TextFile {
   /// the file — so an `XmlFile` costs that for as long as it is open.
   [[nodiscard]] const pugi::xml_document &document() const noexcept;
 
+  /// The document element's name, prefix and all, read off @ref document so
+  /// telling a dialect apart costs no parse of its own.
+  [[nodiscard]] std::string_view root_name() const noexcept;
+
 private:
   std::shared_ptr<text::TextFile> m_file;
   TextEncoding m_encoding{TextEncoding::unknown};
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index f796f7f82..7389278d5 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -55,6 +55,7 @@ add_executable(odr_test
 
         "src/internal/csv/csv_file_test.cpp"
         "src/internal/encoding/text_encoding_test.cpp"
+        "src/internal/svg/svg_file_test.cpp"
         "src/internal/xml/xml_file_test.cpp"
 
         "src/internal/oldms/doc_test.cpp"
diff --git a/test/src/internal/encoding/text_encoding_test.cpp b/test/src/internal/encoding/text_encoding_test.cpp
index cf3e76d5e..3ffd176bd 100644
--- a/test/src/internal/encoding/text_encoding_test.cpp
+++ b/test/src/internal/encoding/text_encoding_test.cpp
@@ -4,6 +4,7 @@
 
 #include <odr/internal/encoding/detect.hpp>
 #include <odr/internal/encoding/transcode.hpp>
+#include <odr/internal/util/string_util.hpp>
 
 #include <gtest/gtest.h>
 
@@ -36,8 +37,7 @@ TEST(TextEncoding, no_name_is_claimed_twice) {
       std::string normalized;
       for (const char c : name) {
         if (c != '-' && c != '_') {
-          normalized.push_back(
-              static_cast<char>(std::tolower(static_cast<unsigned char>(c))));
+          normalized.push_back(util::string::to_lower(c));
         }
       }
       EXPECT_TRUE(seen.insert(normalized).second)
diff --git a/test/src/internal/svg/svg_file_test.cpp b/test/src/internal/svg/svg_file_test.cpp
new file mode 100644
index 000000000..986d29bde
--- /dev/null
+++ b/test/src/internal/svg/svg_file_test.cpp
@@ -0,0 +1,104 @@
+#include <odr/exceptions.hpp>
+#include <odr/file.hpp>
+#include <odr/html.hpp>
+#include <odr/logger.hpp>
+#include <odr/odr.hpp>
+
+#include <odr/internal/svg/svg_file.hpp>
+#include <odr/internal/text/text_file.hpp>
+#include <odr/internal/xml/xml_file.hpp>
+
+#include <pugixml.hpp>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <sstream>
+#include <string>
+
+using namespace odr;
+using namespace odr::internal;
+using testing::HasSubstr;
+
+namespace {
+
+constexpr const char *svg_open = R"(<svg xmlns="http://www.w3.org/2000/svg">)";
+
+std::shared_ptr<svg::SvgFile> svg_file(const std::string &content) {
+  return std::make_shared<svg::SvgFile>(std::make_shared<xml::XmlFile>(
+      std::make_shared<text::TextFile>(File::from_memory(content).impl())));
+}
+
+} // namespace
+
+TEST(SvgFile, an_svg_opens_as_an_image_that_knows_it_is_one) {
+  const DecodedFile file(File::from_memory(std::string(svg_open) + "</svg>"));
+
+  EXPECT_EQ(file.file_type(), FileType::scalable_vector_graphics);
+  EXPECT_EQ(file.file_category(), FileCategory::image);
+  EXPECT_EQ(file.file_meta().mimetype, "image/svg+xml");
+  EXPECT_TRUE(file.is_image_file());
+  EXPECT_FALSE(file.is_text_file());
+  EXPECT_TRUE(file.capabilities().translate_html);
+}
+
+/// The xml parse plus the root element is what decides the type.
+TEST(SvgFile, only_an_svg_opens_as_one) {
+  EXPECT_THROW(std::ignore = svg_file("<a/>"), NoSvgFile);
+  EXPECT_THROW(std::ignore = svg_file("not xml at all"), NoXmlFile);
+
+  // `open` reports its own failure to find a reading, not the format's
+  EXPECT_THROW(std::ignore =
+                   open(File::from_memory("<a/>"),
+                        FileType::scalable_vector_graphics, Logger::null()),
+               UnknownFileType);
+}
+
+/// pugixml does not process namespaces, so a prefixed root has to be seen for
+/// what it is.
+TEST(SvgFile, a_prefixed_root_element_is_still_an_svg) {
+  EXPECT_NO_THROW(std::ignore = svg_file(
+                      R"(<s:svg xmlns:s="http://www.w3.org/2000/svg"/>)"));
+}
+
+/// Every layer the file was read through stays reachable, so what the parse
+/// already did is not done again downstream.
+TEST(SvgFile, the_layers_it_was_read_through_are_reachable) {
+  const std::string content = std::string(svg_open) + "<rect/></svg>";
+  const std::shared_ptr<svg::SvgFile> file = svg_file(content);
+
+  EXPECT_EQ(file->text(), content);
+  EXPECT_EQ(file->text_file()->text(), content);
+  EXPECT_EQ(file->xml_file()->root_name(), "svg");
+  EXPECT_STREQ(file->document().document_element().name(), "svg");
+  EXPECT_EQ(file->file()->size(), content.size());
+}
+
+/// The encoding comes off the declaration, which is what the xml layer is for.
+TEST(SvgFile, the_declared_encoding_is_what_it_is_decoded_with) {
+  const std::shared_ptr<svg::SvgFile> file =
+      svg_file(R"(<?xml version="1.0" encoding="ISO-8859-1"?>)" +
+               std::string(svg_open) + "<title>\xe4</title></svg>");
+
+  EXPECT_EQ(file->xml_file()->encoding(), TextEncoding::iso_8859_1);
+  EXPECT_THAT(file->text(), HasSubstr("<title>ä</title>"));
+}
+
+/// An svg renders as the `<img>` data url every other image does - inside one
+/// a browser renders svg in secure static mode, and nothing here has to scrub
+/// the markup to earn that.
+TEST(SvgFile, it_renders_as_an_image) {
+  const HtmlService service = odr::html::translate(
+      DecodedFile(svg_file(std::string(svg_open) + "<rect/></svg>")),
+      HtmlConfig(), Logger::null());
+
+  ASSERT_EQ(service.list_views().size(), 1);
+  EXPECT_EQ(service.list_views().front().name(), "image");
+
+  std::ostringstream out;
+  service.write("image.html", out);
+
+  EXPECT_THAT(out.str(), HasSubstr("<img"));
+  EXPECT_THAT(out.str(), HasSubstr("data:image/svg+xml;base64,"));
+}
diff --git a/test/src/internal/util/string_util_test.cpp b/test/src/internal/util/string_util_test.cpp
index b2aaeadc0..e4989551f 100644
--- a/test/src/internal/util/string_util_test.cpp
+++ b/test/src/internal/util/string_util_test.cpp
@@ -128,3 +128,47 @@ TEST(string_util, trim_owning_delegates_to_view) {
   trim_inplace(d, is_dot);
   EXPECT_EQ(d, "abc");
 }
+
+TEST(string_util, to_lower) {
+  EXPECT_EQ(to_lower('A'), 'a');
+  EXPECT_EQ(to_lower('a'), 'a');
+  EXPECT_EQ(to_lower('7'), '7');
+
+  EXPECT_EQ(to_lower("MiXeD Case 42"), "mixed case 42");
+  EXPECT_EQ(to_lower(""), "");
+
+  // Bytes above ascii keep their value - a utf-8 sequence must survive
+  // unchanged rather than be folded byte by byte.
+  EXPECT_EQ(to_lower("ÄÖÜ"), "ÄÖÜ");
+}
+
+TEST(string_util, equals_ignore_case) {
+  EXPECT_TRUE(equals_ignore_case("script", "SCRIPT"));
+  EXPECT_TRUE(equals_ignore_case("", ""));
+  EXPECT_FALSE(equals_ignore_case("script", "scrip"));
+  EXPECT_FALSE(equals_ignore_case("script", "scripts"));
+  EXPECT_FALSE(equals_ignore_case("script", "style"));
+}
+
+TEST(string_util, starts_with_ignore_case) {
+  EXPECT_TRUE(starts_with_ignore_case("DATA:image/png", "data:"));
+  EXPECT_TRUE(starts_with_ignore_case("abc", ""));
+  EXPECT_TRUE(starts_with_ignore_case("abc", "abc"));
+  // A prefix longer than the string matches nothing, empty string included.
+  EXPECT_FALSE(starts_with_ignore_case("ab", "abc"));
+  EXPECT_FALSE(starts_with_ignore_case("", "a"));
+  EXPECT_FALSE(starts_with_ignore_case("xabc", "abc"));
+}
+
+TEST(string_util, find_ignore_case) {
+  EXPECT_EQ(find_ignore_case("a @IMPORT b", "@import"), 2);
+  EXPECT_EQ(find_ignore_case("abc", "d"), std::string_view::npos);
+
+  // The search starts at `from`, and the result is an index into the whole
+  // string.
+  EXPECT_EQ(find_ignore_case("url(url(", "URL(", 1), 4);
+  EXPECT_EQ(find_ignore_case("url(url(", "URL(", 5), std::string_view::npos);
+
+  // `from` past the end is not an out-of-range read.
+  EXPECT_EQ(find_ignore_case("abc", "a", 99), std::string_view::npos);
+}