diff --git a/docs/how-to/use-local-files-and-urls.md b/docs/how-to/use-local-files-and-urls.md
index 09dab78..9535944 100644
--- a/docs/how-to/use-local-files-and-urls.md
+++ b/docs/how-to/use-local-files-and-urls.md
@@ -89,7 +89,7 @@ URLs are cached the same way as PMID and DOI references:
 
 ### Title Extraction
 
-For HTML pages, the title is extracted from the `<title>` tag. For other content types, the URL itself is used as the title.
+For HTML pages, the title is the `citation_title` meta tag when present, then the `<title>` tag. For PDFs, the validator tries a publisher landing page's `citation_title` and then the PDF's embedded title. When neither is found, and for other content types, the URL itself is used as the title. See [Validating URLs](validate-urls.md#titles).
 
 ### Example: Validating Against a Web Page
 
@@ -145,6 +145,6 @@ Both file and URL references work in LinkML data files:
 
 ## Limitations
 
-- **PDF files**: Not yet supported (planned for future)
+- **Local PDF files**: Not yet supported as `file:` references. PDFs fetched by `url:` are supported.
 - **Authentication**: URLs requiring login are not supported
 - **Dynamic content**: JavaScript-rendered pages may not work
diff --git a/docs/how-to/validate-urls.md b/docs/how-to/validate-urls.md
index 2fb3ccc..c57d059 100644
--- a/docs/how-to/validate-urls.md
+++ b/docs/how-to/validate-urls.md
@@ -15,8 +15,8 @@ The linkml-reference-validator supports validating references that point to web
 When a reference field contains a URL, the validator:
 
 1. Fetches the web page content
-2. Extracts the page title from `<title>` tag (for HTML)
-3. Caches the content for future validations
+2. Extracts the page title (see [Titles](#titles))
+3. Sanitizes HTML and caches the content for future validations
 4. Validates your supporting text against the page content
 
 ## URL Format
@@ -79,14 +79,45 @@ When the validator encounters a URL reference, it:
 
 The fetcher stores:
 
-- **Title**: Extracted from the `<title>` tag (for HTML pages)
-- **Content**: The raw page content as received
-- **Content type**: Marked as `url` to distinguish from other reference types
-
-Note: The validator stores raw page content without HTML-to-text conversion.
-HTML tags remain in the cached file, and tag names can surface during
-normalization. If validation fails because tags interrupt the text, consider
-extracting plain text and validating against a local `file:` reference instead.
+- **Title**: See [Titles](#titles)
+- **Content**: Sanitized HTML for HTML pages; plain text and XML as received;
+  extracted text for PDFs
+- **Content type**: `url` for pages, `full_text_pdf` for PDFs with text
+
+HTML is sanitized before it is cached, because caches are often committed to
+public repositories and page scripts routinely carry signed asset URLs and API
+keys. `<script>`, `<style>`, `<noscript>` and `<template>` elements and HTML
+comments are removed. So are `<meta>`, `<link>` and `<base>`, which hold nothing
+but attributes. Every other tag attribute is removed except `rowspan`,
+`colspan` and `scope`, which carry table structure. Body markup and text are
+kept. There is no HTML-to-text conversion, so tag names can still surface
+during normalization. If validation fails because tags interrupt the text,
+consider extracting plain text and validating against a local `file:`
+reference instead.
+
+#### Titles
+
+For HTML pages the title is the `citation_title` meta tag when present (the
+Highwire / Google Scholar convention, which names the article rather than the
+site), then the `<title>` tag.
+
+For PDFs the validator tries, in order:
+
+1. The `citation_title` of the publisher's landing page, where a known rule
+   maps the PDF URL to it. Currently J-STAGE: `.../_pdf` becomes
+   `.../_article`.
+2. The PDF's embedded `/Title` metadata, ignoring placeholders such as
+   `Microsoft Word - draft.doc`, bare filenames and `Untitled`.
+3. The URL itself.
+
+So a PDF entry whose `title` equals its URL is one for which no title was
+found.
+
+The landing-page rules and the placeholder titles are kept in
+`src/linkml_reference_validator/etl/rules.py`, with the other publisher and
+site rules. Each rule sits beside examples of what it must and must not match.
+To support another publisher, add a rule there with at least one example;
+`tests/test_rules.py` fails for a rule without one.
 
 ### 3. Caching
 
@@ -104,9 +135,9 @@ content_type: url
 ## Content
 
 <html>
-  <head>
-    <title>Chapter 3: Cell Structure and Function</title>
-  </head>
+<head>
+<title>Chapter 3: Cell Structure and Function</title>
+</head>
   ...
 ```
 
@@ -145,9 +176,10 @@ URL validation is designed for static web pages. It may not work well with:
 
 ### Raw Content
 
-The validator stores raw page content. For HTML pages:
+The validator stores sanitized page markup, not extracted text. For HTML pages:
 
-- HTML tags are preserved in the cache
+- HTML tags are preserved in the cache, without attributes other than
+  `rowspan`, `colspan` and `scope`
 - The text normalization during validation handles most cases
 - Complex HTML layouts may require careful text extraction
 
diff --git a/docs/troubleshooting.md b/docs/troubleshooting.md
index 5488a65..c368dd5 100644
--- a/docs/troubleshooting.md
+++ b/docs/troubleshooting.md
@@ -902,6 +902,24 @@ rather than as `unavailable`, so it falls outside this stamp and is not
 re-tested. Clear such entries by hand if you were running that setting before
 this version.
 
+`url:` entries carry their own stamp, `url_source_version: 1`. Version 1 is
+two URLSource changes: HTML is sanitized before caching, so page scripts,
+comments and attributes stop reaching the cache (issue #92), and a PDF's title
+is recovered from a publisher landing page or its embedded metadata rather than
+set to its URL (issue #93). A `url:` entry with a missing or older stamp is
+re-fetched once on the next validation fetch. If the page cannot be reached,
+the old entry is still served and is not rewritten, so a later run retries.
+Other sources are unaffected. With `trust_cached_entries` set, old entries are
+served as they are and are not refreshed.
+
+**A quote that verified against a `url:` page can fail after that refresh.**
+Sanitizing removes `<noscript>` and `<template>` elements with their text.
+Some publisher pages put a fallback copy of the abstract inside `<noscript>`,
+for readers without JavaScript. A quote that only ever matched that copy will
+stop matching once the entry is re-fetched. If the same text appears elsewhere
+on the page, nothing changes. If it does not, cite a source that carries it,
+such as the `PMID:` or `DOI:` of the article.
+
 **A cache-wide refresh adds one line to every enriched entry.** Both index
 providers now set `access_type` where they previously left it unset, so a
 refreshed public entry gains a `full_text_access_type: open` line. It means the
diff --git a/src/linkml_reference_validator/etl/extract/html.py b/src/linkml_reference_validator/etl/extract/html.py
index 8ee76d4..7c8a3ec 100644
--- a/src/linkml_reference_validator/etl/extract/html.py
+++ b/src/linkml_reference_validator/etl/extract/html.py
@@ -10,9 +10,10 @@
 import re
 from typing import Optional, Union
 
-from bs4 import BeautifulSoup, Tag  # type: ignore
+from bs4 import BeautifulSoup, Comment, Tag  # type: ignore
 
 from linkml_reference_validator.etl.extract.base import Extractor, ExtractorRegistry
+from linkml_reference_validator.etl.rules import ARTICLE_BODY_SELECTORS
 
 logger = logging.getLogger(__name__)
 
@@ -27,13 +28,54 @@
     "table", "td", "th", "tr", "ul",
 )
 
-# Explicit article-body containers; generic layout IDs such as #body are not
-# evidence that a page contains an article.
-ARTICLE_BODY_SELECTOR = (
-    '[itemprop="articleBody"], .article-text, #artText, '
-    '.article-body, .article__body, .c-article-body'
-)
+#: One CSS selector list for the article-body containers in
+#: :data:`~linkml_reference_validator.etl.rules.ARTICLE_BODY_SELECTORS`.
+ARTICLE_BODY_SELECTOR = ", ".join(ARTICLE_BODY_SELECTORS)
+
+
+#: Elements that never hold reference text. Page scripts routinely carry signed
+#: asset URLs and API-key parameters, which must not reach a committed cache.
+#: ``meta``, ``link`` and ``base`` hold nothing but attributes, so once those
+#: are stripped they would remain only as empty tags.
+NON_CONTENT_TAGS = ("script", "style", "noscript", "template", "meta", "link", "base")
+
+#: The only attributes that carry meaning for a quoted excerpt: table structure.
+KEPT_ATTRIBUTES = frozenset({"rowspan", "colspan", "scope"})
+
 
+def sanitize_html(content: str) -> str:
+    """Strip an HTML page to its body markup and text, for caching.
+
+    Drops ``NON_CONTENT_TAGS`` and comments, and every attribute not in
+    ``KEPT_ATTRIBUTES``. Markup is kept, unlike :class:`HTMLExtractor`, which
+    flattens to plain text; this is for ``url:`` pages stored as HTML.
+
+    Examples:
+        >>> sanitize_html('<p class="x" onclick="f()">Hi<script>k=1</script><!-- c --></p>')
+        '<p>Hi</p>'
+        >>> sanitize_html('<head><meta charset="utf-8"><link rel="x"><title>T</title></head>')
+        '<head><title>T</title></head>'
+        >>> sanitize_html('<td rowspan="2" style="s">A</td>')
+        '<td rowspan="2">A</td>'
+        >>> sanitize_html("<pre><b>x</b>    <b>y</b></pre>")
+        '<pre><b>x</b>    <b>y</b></pre>'
+    """
+    soup = BeautifulSoup(content, "html.parser")
+    for tag in soup.find_all(NON_CONTENT_TAGS):
+        if not tag.decomposed:  # already gone with an enclosing non-content tag
+            tag.decompose()
+    for comment in soup.find_all(string=lambda text: isinstance(text, Comment)):
+        comment.extract()
+    for tag in soup.find_all(True):
+        tag.attrs = {k: v for k, v in tag.attrs.items() if k in KEPT_ATTRIBUTES}
+    # Removed elements leave runs of indentation behind. Collapse each
+    # whitespace-only gap to one break so a second pass changes nothing.
+    soup.smooth()
+    for text in soup.find_all(string=True):
+        if text.strip() or text in ("\n", " ") or text.find_parent("pre"):
+            continue
+        text.replace_with("\n" if "\n" in text else " ")
+    return str(soup)
 
 @ExtractorRegistry.register
 class HTMLExtractor(Extractor):
diff --git a/src/linkml_reference_validator/etl/extract/pdf.py b/src/linkml_reference_validator/etl/extract/pdf.py
index e89e54b..90c46b3 100644
--- a/src/linkml_reference_validator/etl/extract/pdf.py
+++ b/src/linkml_reference_validator/etl/extract/pdf.py
@@ -9,6 +9,7 @@
 from typing import Optional, Protocol, Union
 
 from linkml_reference_validator.etl.extract.base import Extractor, ExtractorRegistry
+from linkml_reference_validator.etl.rules import PDF_PLACEHOLDER_TITLE
 
 logger = logging.getLogger(__name__)
 
@@ -20,6 +21,10 @@ def extract_text(self, data: bytes) -> str:
         """Return extracted plain text for the given PDF bytes."""
         ...
 
+    def extract_title(self, data: bytes) -> Optional[str]:
+        """Return the embedded document title, or None if there is none."""
+        ...
+
 
 class PypdfBackend:
     """Default PDF backend using ``pypdf`` (BSD-licensed, pure-python).
@@ -35,6 +40,54 @@ def extract_text(self, data: bytes) -> str:
         reader = PdfReader(io.BytesIO(data))
         return "\n\n".join(page.extract_text() or "" for page in reader.pages)
 
+    def extract_title(self, data: bytes) -> Optional[str]:
+        """Read ``/Title`` from the document information dictionary.
+
+        Examples:
+            >>> PypdfBackend().extract_title(b"%PDF-1.4 truncated") is None
+            True
+        """
+        from pypdf import PdfReader
+        from pypdf.errors import PyPdfError
+
+        try:  # external data: a PDF can carry text yet have a broken trailer
+            metadata = PdfReader(io.BytesIO(data)).metadata
+        except PyPdfError as e:
+            logger.debug(f"Could not read PDF metadata: {e}")
+            return None
+        if metadata is None:
+            return None
+        # pypdf returns /Title as whatever object it holds; only text is a title.
+        title = metadata.title
+        return str(title) if isinstance(title, str) else None
+
+
+def clean_pdf_title(title: Optional[str]) -> Optional[str]:
+    """Return ``title`` stripped, or None if it is empty or a known placeholder.
+
+    Placeholders are :data:`~linkml_reference_validator.etl.rules.PDF_PLACEHOLDER_TITLE`.
+
+    Examples:
+        >>> clean_pdf_title("  Canine Distemper in Dogs ")
+        'Canine Distemper in Dogs'
+        >>> clean_pdf_title("Microsoft Word - draft_v3.doc") is None
+        True
+        >>> clean_pdf_title("paper.pdf") is None
+        True
+        >>> clean_pdf_title("Untitled") is None
+        True
+        >>> clean_pdf_title("") is None
+        True
+        >>> clean_pdf_title(None) is None
+        True
+    """
+    if title is None:
+        return None
+    title = " ".join(title.split())
+    if not title or PDF_PLACEHOLDER_TITLE.match(title):
+        return None
+    return title
+
 
 _BACKENDS: dict[str, type] = {
     "pypdf": PypdfBackend,
@@ -72,3 +125,12 @@ def extract(
             raise TypeError("PDF extraction requires bytes, not decoded text")
         text = self._backend.extract_text(data)
         return text if text and text.strip() else None
+
+    def extract_title(self, data: bytes) -> Optional[str]:
+        """Return the PDF's embedded title, or None if absent or a placeholder.
+
+        Examples:
+            >>> PDFExtractor().extract_title(b"%PDF-1.4 truncated") is None
+            True
+        """
+        return clean_pdf_title(self._backend.extract_title(data))
diff --git a/src/linkml_reference_validator/etl/extract/xml.py b/src/linkml_reference_validator/etl/extract/xml.py
index 463fa25..46e52b0 100644
--- a/src/linkml_reference_validator/etl/extract/xml.py
+++ b/src/linkml_reference_validator/etl/extract/xml.py
@@ -12,23 +12,12 @@
 from bs4 import BeautifulSoup, CData, NavigableString, Tag  # type: ignore
 
 from linkml_reference_validator.etl.extract.base import Extractor, ExtractorRegistry
+from linkml_reference_validator.etl.rules import STUB_NOTICE_PHRASES
 
 logger = logging.getLogger(__name__)
 
-#: Phrases appearing in the placeholder documents PMC serves in place of an
-#: article whose full text it cannot supply. Deliberately broad, because the
-#: length gate below - not the wording - is what keeps matching safe. PMC
-#: phrases these notices several ways ("access to this article is
-#: restricted", "full text is restricted", ...), and an exhaustive list would
-#: trade the old false positives for false negatives.
-STUB_NOTICE_PHRASES = (
-    "restricted",
-    "does not allow downloading",
-    "cannot be obtained",
-    "not available from pmc",
-)
-
-#: Longest a placeholder notice can plausibly be. Stub phrases are only
+#: Longest a placeholder notice can plausibly be. Stub phrases
+#: (:data:`~linkml_reference_validator.etl.rules.STUB_NOTICE_PHRASES`) are only
 #: honoured below this length: a real article runs to tens of thousands of
 #: characters and may legitimately use the same words - Morris 2019 restricts
 #: an analysis "to up to 13,977,204 high quality HRC imputed variants", and a
diff --git a/src/linkml_reference_validator/etl/fulltext/pmc.py b/src/linkml_reference_validator/etl/fulltext/pmc.py
index 6d1c304..ee9bf7f 100644
--- a/src/linkml_reference_validator/etl/fulltext/pmc.py
+++ b/src/linkml_reference_validator/etl/fulltext/pmc.py
@@ -24,6 +24,7 @@
 from linkml_reference_validator.etl.extract.html import HTMLExtractor
 from linkml_reference_validator.etl.extract import MIN_FULLTEXT_CHARS
 from linkml_reference_validator.etl.extract.xml import XMLExtractor
+from linkml_reference_validator.etl.rules import PMC_ARTICLE_BODY_CLASSES
 
 logger = logging.getLogger(__name__)
 
@@ -42,17 +43,6 @@ class TransientFullTextError(RuntimeError):
 #: serves now, on a ``<section>``; the two ``div`` classes are the older markup
 #: and are kept so entries cached against them still re-extract.
 #:
-#: Deliberately not ``body``, which PMC pairs with ``main-article-body`` on the
-#: same element. Matching it alone would match every page's ``<body>``, and the
-#: structural test is the only thing standing between this fetch and caching a
-#: bot-check interstitial served on an HTTP 200.
-#:
-#: Order is a priority order, not an alphabetical one: the first match wins, so
-#: the current wrapper is tried before the legacy ones. It matters for a legacy
-#: page carrying several ``tsec`` sections, where only the first is returned --
-#: the previous code behaved the same way, so this is a known limit rather than
-#: a regression, but reordering the tuple would change which section that is.
-PMC_ARTICLE_BODY_CLASSES = ("main-article-body", "article-body", "tsec")
 
 
 def find_pmc_article_body(soup: BeautifulSoup) -> Optional[Any]:
diff --git a/src/linkml_reference_validator/etl/reference_fetcher.py b/src/linkml_reference_validator/etl/reference_fetcher.py
index af0a6d1..177205d 100644
--- a/src/linkml_reference_validator/etl/reference_fetcher.py
+++ b/src/linkml_reference_validator/etl/reference_fetcher.py
@@ -113,6 +113,15 @@
 #: fix to any source will want, and it is still a 3% refresh against 100%.
 ABSENT_CONTENT_CACHE_VERSION = 1
 
+#: Version what URLSource writes, scoped to ``url:`` entries. Version 1: HTML
+#: is sanitized before caching, so page scripts and attributes stop reaching
+#: committed caches (#92), and a PDF's title is recovered rather than set to its
+#: URL (#93). Neither fix rewrites an entry already written, and both kinds of
+#: entry carry a current ``extractor_version``, so without this they would be
+#: served as they are forever. Stamped from ``reference.metadata``, like the
+#: HTML stamp, and only on a fresh URLSource fetch.
+URL_SOURCE_CACHE_VERSION = 1
+
 #: A cache file's frontmatter delimiter: a line that is exactly ``---``.
 #: Splitting on the bare string instead lets any *value* containing ``---`` - a
 #: URL reference_id, a title - truncate the block, which loses every field after
@@ -388,6 +397,11 @@ def fetch_with_provenance(
                 content.metadata or {}, xml_extraction_version=XML_EXTRACTION_CACHE_VERSION
             )
 
+        if content and normalized_reference_id.startswith("url:"):
+            content.metadata = dict(
+                content.metadata or {}, url_source_version=URL_SOURCE_CACHE_VERSION
+            )
+
         if content and self.config.fetch_full_text and self.needs_full_text(content):
             content = self._enrich_with_full_text(content)
 
@@ -1349,6 +1363,9 @@ def _save_to_disk(
         xml_version = (reference.metadata or {}).get("xml_extraction_version")
         if reference.content_type == "full_text_xml" and type(xml_version) is int:
             lines.append(f"xml_extraction_version: {xml_version}")
+        url_version = (reference.metadata or {}).get("url_source_version")
+        if type(url_version) is int:
+            lines.append(f"url_source_version: {url_version}")
         # Written from the constant, unlike the HTML and XML stamps, which come
         # from `reference.metadata` so a metadata-only rewrite preserves the
         # original. The invariant that makes that safe: nothing reaches a save
@@ -1703,6 +1720,13 @@ def _is_stale_cache_entry(cls, content_text: str) -> bool:
             if type(xml_version) is not int or xml_version < XML_EXTRACTION_CACHE_VERSION:
                 return True
 
+        if isinstance(metadata, dict) and str(metadata.get("reference_id", "")).startswith(
+            "url:"
+        ):
+            url_version = metadata.get("url_source_version")
+            if type(url_version) is not int or url_version < URL_SOURCE_CACHE_VERSION:
+                return True
+
         # Scoped to `unavailable`, which leaves one gap: with
         # `source_extra_fields["PMID"]` configured, a record with no abstract is
         # stored as `summary` carrying the extra-fields blob, so an
@@ -1762,6 +1786,8 @@ def _load_markdown_format(
             metadata["xml_extraction_version"] = frontmatter["xml_extraction_version"]
         if "html_full_text_version" in frontmatter:
             metadata["html_full_text_version"] = frontmatter["html_full_text_version"]
+        if "url_source_version" in frontmatter:
+            metadata["url_source_version"] = frontmatter["url_source_version"]
         if "extra_fields_captured" in frontmatter:
             metadata["extra_fields_captured"] = frontmatter["extra_fields_captured"]
 
diff --git a/src/linkml_reference_validator/etl/rules.py b/src/linkml_reference_validator/etl/rules.py
new file mode 100644
index 0000000..e966a18
--- /dev/null
+++ b/src/linkml_reference_validator/etl/rules.py
@@ -0,0 +1,195 @@
+"""Publisher and site rules, kept in one place.
+
+These are the rules that change when a publisher changes its pages: where a
+PDF's landing page lives, which containers hold an article body, how PMC words
+a placeholder notice, what an authoring tool stamps in place of a PDF title.
+Each rule sits beside its examples, which are what it must match, and its
+counterexamples, which are what it must not. The tests read both from here and
+from nowhere else, so updating a rule is one edit in one file.
+
+To add a rule, add it and at least one example. ``tests/test_rules.py`` fails
+for a rule that has no example, and checks every example and counterexample
+against the code that uses the rule.
+
+Generic format rules (which HTML elements are never content, which attributes
+survive sanitizing) are not publisher rules and stay with their extractors.
+
+Examples:
+    >>> sorted(LANDING_PAGE_RULES)
+    ['J-STAGE']
+    >>> PMC_ARTICLE_BODY_CLASSES[0]
+    'main-article-body'
+"""
+
+import re
+
+# --- PDF landing pages -----------------------------------------------------
+
+#: Publishers that serve a PDF at one URL and its metadata page at a
+#: predictable sibling, as ``name -> (pattern, replacement)`` for ``re.sub``
+#: on the PDF URL. The landing page is consulted only for its
+#: ``citation_title`` meta tag.
+LANDING_PAGE_RULES: dict[str, tuple[str, str]] = {
+    # .../<article>/_pdf[/-char/ja] -> .../<article>/_article[/-char/ja]
+    "J-STAGE": (
+        r"^(https?://www\.jstage\.jst\.go\.jp/article/.+)/_pdf(/.*)?$",
+        r"\1/_article\2",
+    ),
+}
+
+#: ``name -> ((pdf_url, landing_url), ...)``.
+LANDING_PAGE_EXAMPLES: dict[str, tuple[tuple[str, str], ...]] = {
+    "J-STAGE": (
+        (
+            "https://www.jstage.jst.go.jp/article/jvms/64/1/64_1_1/_pdf/-char/ja",
+            "https://www.jstage.jst.go.jp/article/jvms/64/1/64_1_1/_article/-char/ja",
+        ),
+        (
+            "https://www.jstage.jst.go.jp/article/jvms/64/1/64_1_1/_pdf",
+            "https://www.jstage.jst.go.jp/article/jvms/64/1/64_1_1/_article",
+        ),
+    ),
+}
+
+#: PDF URLs no rule may map to a landing page.
+LANDING_PAGE_COUNTEREXAMPLES: tuple[str, ...] = (
+    "https://example.org/files/paper.pdf",
+    # Another host must never be rewritten, even with J-STAGE's path shape.
+    "https://evil.example.org/article/jvms/64/1/64_1_1/_pdf",
+)
+
+# --- Placeholder PDF titles ------------------------------------------------
+
+#: What authoring tools stamp into a PDF's ``/Title`` in place of a real one.
+#: A filename counts only when bare (no spaces), so a real title ending in
+#: ".pdf" is kept.
+PDF_PLACEHOLDER_TITLE = re.compile(
+    r"^(untitled(\s+document)?"
+    r"|microsoft (word|powerpoint) - .*"
+    r"|\S+\.(pdf|docx?|rtf|odt|tex|indd))$",
+    re.IGNORECASE,
+)
+
+#: Titles that are placeholders and must be rejected.
+PDF_PLACEHOLDER_TITLE_EXAMPLES: tuple[str, ...] = (
+    "untitled",
+    "Untitled",
+    "Untitled Document",
+    "Microsoft Word - draft_v3.doc",
+    "Microsoft Word - 64_1_1.doc",
+    "paper.pdf",
+    "manuscript.docx",
+)
+
+#: Real titles that must be kept, including ones that look like placeholders.
+PDF_PLACEHOLDER_TITLE_COUNTEREXAMPLES: tuple[str, ...] = (
+    "Canine Distemper in Dogs",
+    "Converting LaTeX Manuscripts to report.pdf",
+    "Why we stopped using .docx",
+)
+
+# --- Article body containers in HTML full text -----------------------------
+
+#: CSS selectors for explicit article-body containers. Generic layout IDs such
+#: as ``#body`` are not evidence that a page contains an article.
+ARTICLE_BODY_SELECTORS: tuple[str, ...] = (
+    '[itemprop="articleBody"]',
+    ".article-text",
+    "#artText",
+    ".article-body",
+    ".article__body",
+    ".c-article-body",
+)
+
+#: ``selector -> markup it must find``.
+ARTICLE_BODY_EXAMPLES: dict[str, str] = {
+    '[itemprop="articleBody"]': '<div itemprop="articleBody">{body}</div>',
+    ".article-text": '<div class="article-text">{body}</div>',
+    "#artText": '<div id="artText">{body}</div>',
+    ".article-body": '<div class="article-body">{body}</div>',
+    ".article__body": '<div class="article__body">{body}</div>',
+    ".c-article-body": '<div class="c-article-body">{body}</div>',
+}
+
+#: Markup no selector may take for an article body.
+ARTICLE_BODY_COUNTEREXAMPLES: tuple[str, ...] = (
+    '<div id="body">{body}</div>',
+    '<div class="page-body">{body}</div>',
+)
+
+# --- PMC article containers ------------------------------------------------
+
+#: Classes of PMC's article-body element. PMC moved its article from
+#: ``div.article-body``/``div.tsec`` to ``section.main-article-body``, and the
+#: fallback declined every article until this list caught up
+#: (monarch-initiative/dismech#12672). Deliberately not ``body``, which PMC
+#: pairs with ``main-article-body`` on the same element. Matching it alone
+#: would match every page's ``<body>``, and the structural test is the only
+#: thing standing between this fetch and caching a bot-check interstitial
+#: served on an HTTP 200.
+#:
+#: Order is a priority order, not an alphabetical one: the first match wins,
+#: so the current wrapper is tried before the legacy ones. It matters for a
+#: legacy page carrying several ``tsec`` sections, where only the first is
+#: returned. The previous code behaved the same way, so this is a known limit
+#: rather than a regression, but reordering the tuple would change which
+#: section that is.
+PMC_ARTICLE_BODY_CLASSES: tuple[str, ...] = ("main-article-body", "article-body", "tsec")
+
+#: ``class -> markup it must find``. ``{body}`` stands for real article prose.
+PMC_ARTICLE_BODY_EXAMPLES: dict[str, tuple[str, ...]] = {
+    "main-article-body": (
+        '<section class="body main-article-body">{body}</section>',  # current PMC
+        '<section class="main-article-body">{body}</section>',  # without "body"
+    ),
+    "article-body": ('<div class="article-body">{body}</div>',),  # legacy
+    "tsec": ('<div class="tsec">{body}</div>',),  # legacy
+}
+
+#: Pages that carry no article and must be declined.
+PMC_ARTICLE_BODY_COUNTEREXAMPLES: tuple[str, ...] = (
+    "<html><body><p>Checking your browser before accessing.</p></body></html>",
+    "<html><body><nav><a href='/'>Home</a></nav></body></html>",
+    "<html><body><div class='usa-banner'>An official website</div></body></html>",
+    # <body> is on every page, so class="body" alone must not count.
+    "<html><body>{body}</body></html>",
+    # PMC's challenge page carries a classed <body>. None of its classes may
+    # overlap the list, or a bot-check page is cached as full text.
+    '<html><body class="usa-page bot-check">'
+    "<h1>Checking your browser before accessing</h1>"
+    "<p>Enable JavaScript and cookies to continue.</p>"
+    "</body></html>",
+)
+
+# --- PMC placeholder notices -----------------------------------------------
+
+#: Phrases appearing in the placeholder documents PMC serves in place of an
+#: article whose full text it cannot supply. Deliberately broad, because the
+#: length gate in :mod:`linkml_reference_validator.etl.extract.xml`
+#: (``MAX_STUB_NOTICE_CHARS``), not the wording, is what keeps matching safe.
+#: PMC phrases these notices several ways ("access to this article is
+#: restricted", "full text is restricted", ...), and an exhaustive list would
+#: trade the old false positives for false negatives.
+STUB_NOTICE_PHRASES: tuple[str, ...] = (
+    "restricted",
+    "does not allow downloading",
+    "cannot be obtained",
+    "not available from pmc",
+)
+
+#: ``phrase -> notices it must catch``.
+STUB_NOTICE_EXAMPLES: dict[str, tuple[str, ...]] = {
+    "restricted": (
+        "Access to the full text is restricted by the publisher.",
+        # Wordings an exhaustive phrase list would miss; the length gate is
+        # what lets a broad "restricted" catch them safely.
+        "Access to this article is restricted.",
+        "Full text is restricted.",
+    ),
+    "does not allow downloading": (
+        "The publisher of this article does not allow downloading of the full "
+        "text in XML form from PMC.",
+    ),
+    "cannot be obtained": ("The full text of this article cannot be obtained from PMC.",),
+    "not available from pmc": ("This article is not available from PMC.",),
+}
diff --git a/src/linkml_reference_validator/etl/sources/url.py b/src/linkml_reference_validator/etl/sources/url.py
index 384e945..358830d 100644
--- a/src/linkml_reference_validator/etl/sources/url.py
+++ b/src/linkml_reference_validator/etl/sources/url.py
@@ -10,24 +10,37 @@
     True
 """
 
+import html
 import logging
 import re
 from typing import Optional
 
+import requests
+
 from linkml_reference_validator.models import ReferenceContent, ReferenceValidationConfig
 from linkml_reference_validator.etl.sources.base import ReferenceSource, ReferenceSourceRegistry
-from linkml_reference_validator.etl.acquire import ContentAcquirer
+from linkml_reference_validator.etl.acquire import ContentAcquirer, sniff_format
+from linkml_reference_validator.etl.extract.html import sanitize_html
 from linkml_reference_validator.etl.extract.pdf import PDFExtractor
+from linkml_reference_validator.etl.rules import LANDING_PAGE_RULES
 
 logger = logging.getLogger(__name__)
 
+_META_TAG = re.compile(r"<meta\b[^>]*>", re.IGNORECASE)
+# Attribute names follow whitespace. A \b boundary would also match inside
+# data-name= and data-content=, since "-" is a word boundary.
+_META_NAME = re.compile(r"""(?<=\s)name\s*=\s*["']citation_title["']""", re.IGNORECASE)
+_META_CONTENT = re.compile(r"""(?<=\s)content\s*=\s*(["'])(.*?)\1""", re.IGNORECASE | re.DOTALL)
+
 
 @ReferenceSourceRegistry.register
 class URLSource(ReferenceSource):
     """Fetch reference content from web URLs.
 
-    Fetches HTML and plain text content. HTML is returned as-is (no parsing).
-    Content is cached to disk like other sources.
+    Fetches HTML and plain text content. HTML keeps its markup but is
+    sanitized (see :func:`sanitize_html`) so page scripts and attributes do not
+    reach the cache. Plain text and XML are stored as fetched. Content is cached
+    to disk like other sources.
 
     Examples:
         >>> source = URLSource()
@@ -71,7 +84,11 @@ def fetch(
         # Stream through ContentAcquirer so the size cap, rate-limit delay, and
         # User-Agent are applied uniformly. A url: pointing at a large PDF would
         # otherwise be buffered entirely into memory by a plain requests.get.
-        data, content_type = ContentAcquirer().fetch_bytes(url, config)
+        try:  # external system boundary: requests raises when offline or on timeout
+            data, content_type = ContentAcquirer().fetch_bytes(url, config)
+        except requests.RequestException as e:
+            logger.warning(f"Failed to fetch {url}: {e}")
+            return None
         if data is None:
             # non-200 or the size cap was exceeded (the acquirer logs the reason)
             return None
@@ -85,14 +102,17 @@ def fetch(
             )
             return ReferenceContent(
                 reference_id=f"url:{url}",
-                title=url,
+                title=self._recover_pdf_title(url, data, config),
                 content=text,
                 content_type="full_text_pdf" if text else "unavailable",
                 full_text_url=url,
             )
 
         content = self._decode(data, content_type_header)
+        # Before sanitizing: citation_title lives in a <meta> attribute.
         title = self._extract_title(content, url)
+        if "html" in content_type_header or self._looks_like_html(data):
+            content = sanitize_html(content)
 
         return ReferenceContent(
             reference_id=f"url:{url}",
@@ -101,6 +121,103 @@ def fetch(
             content_type="url",
         )
 
+    def _recover_pdf_title(
+        self, url: str, data: bytes, config: ReferenceValidationConfig
+    ) -> str:
+        """Find a real title for a PDF, falling back to its URL.
+
+        Tries, in order: the ``citation_title`` of a landing page found by
+        ``LANDING_PAGE_RULES``, then the PDF's embedded ``/Title``. When both
+        fail the URL is returned, so ``title == url`` still means none was found.
+        """
+        landing = self._landing_page_url(url)
+        if landing is not None:
+            title = self._landing_page_title(landing, config)
+            if title:
+                return title
+            logger.debug(f"No citation_title at landing page {landing} for {url}")
+
+        embedded = PDFExtractor(backend=config.pdf_backend).extract_title(data)
+        return embedded or url
+
+    def _landing_page_title(
+        self, landing: str, config: ReferenceValidationConfig
+    ) -> Optional[str]:
+        """Return the ``citation_title`` of a landing page, or None if it cannot be had."""
+        try:  # external system boundary: the title is best-effort, the PDF is not
+            page, content_type = ContentAcquirer().fetch_bytes(landing, config)
+        except requests.RequestException as e:
+            logger.debug(f"Landing page {landing} could not be fetched: {e}")
+            return None
+        if page is None:
+            return None
+        return self._citation_title(self._decode(page, (content_type or "").lower()))
+
+    @staticmethod
+    def _landing_page_url(url: str) -> Optional[str]:
+        """Return the landing page for a PDF URL, if a rule in ``LANDING_PAGE_RULES`` matches.
+
+        Examples:
+            >>> URLSource._landing_page_url(
+            ...     "https://www.jstage.jst.go.jp/article/jvms/64/1/64_1_1/_pdf/-char/ja")
+            'https://www.jstage.jst.go.jp/article/jvms/64/1/64_1_1/_article/-char/ja'
+            >>> URLSource._landing_page_url("https://example.org/paper.pdf") is None
+            True
+        """
+        for pattern, replacement in LANDING_PAGE_RULES.values():
+            if re.match(pattern, url):
+                return re.sub(pattern, replacement, url)
+        return None
+
+    @staticmethod
+    def _citation_title(content: str) -> Optional[str]:
+        """Return the ``citation_title`` meta tag's content, if present.
+
+        Examples:
+            >>> URLSource._citation_title('<meta name="citation_title" content="A &amp; B">')
+            'A & B'
+            >>> URLSource._citation_title("<meta content='Reversed' name='citation_title'>")
+            'Reversed'
+            >>> URLSource._citation_title("<title>Only a title</title>") is None
+            True
+        """
+        for tag in _META_TAG.findall(content):
+            if _META_NAME.search(tag):
+                match = _META_CONTENT.search(tag)
+                if match:
+                    title = " ".join(html.unescape(match.group(2)).split())
+                    if title:
+                        return title
+        return None
+
+    @staticmethod
+    def _looks_like_html(data: bytes) -> bool:
+        """Report whether a body is an HTML page, whatever its content type said.
+
+        Skips a UTF-8 byte order mark and leading comments (a saved page often
+        begins with one), then accepts a doctype, ``<html>``, ``<head>`` or
+        ``<body>``. Text that merely mentions a tag is not a page.
+
+        Examples:
+            >>> URLSource._looks_like_html(b"\\xef\\xbb\\xbf<!DOCTYPE html><html>")
+            True
+            >>> URLSource._looks_like_html(b"<!-- saved -->\\n<html><body>")
+            True
+            >>> URLSource._looks_like_html(b"<head><title>T</title></head>")
+            True
+            >>> URLSource._looks_like_html(b"Notes on the <html> element")
+            False
+            >>> URLSource._looks_like_html(b'<?xml version="1.0"?><record/>')
+            False
+        """
+        head = data[:8192].removeprefix(b"\xef\xbb\xbf").lstrip()
+        while head.startswith(b"<!--"):
+            end = head.find(b"-->")
+            if end == -1:
+                return False
+            head = head[end + 3 :].lstrip()
+        return sniff_format(head) == "html" or head[:5].lower() in (b"<head", b"<body")
+
     def _decode(self, data: bytes, content_type: str) -> str:
         """Decode HTML/text bytes using the content-type charset, defaulting to UTF-8.
 
@@ -123,7 +240,7 @@ def _decode(self, data: bytes, content_type: str) -> str:
     def _extract_title(self, content: str, url: str) -> str:
         """Extract title from HTML content or use URL.
 
-        Looks for <title> tag in HTML. Falls back to URL.
+        Prefers a ``citation_title`` meta tag, then the <title> tag. Falls back to URL.
 
         Args:
             content: Page content
@@ -136,9 +253,17 @@ def _extract_title(self, content: str, url: str) -> str:
             >>> source = URLSource()
             >>> source._extract_title("<html><title>Page Title</title></html>", "https://x.com")
             'Page Title'
+            >>> source._extract_title(
+            ...     '<title>Journal | Home</title><meta name="citation_title" content="Article">',
+            ...     "https://x.com")
+            'Article'
             >>> source._extract_title("plain text", "https://example.com/doc.txt")
             'https://example.com/doc.txt'
         """
+        citation_title = self._citation_title(content)
+        if citation_title:
+            return citation_title
+
         # Look for HTML title tag (simple regex, no BeautifulSoup)
         match = re.search(r"<title[^>]*>([^<]+)</title>", content, re.IGNORECASE)
         if match:
diff --git a/tests/test_extractor_fidelity.py b/tests/test_extractor_fidelity.py
index b5636f4..1308ca2 100644
--- a/tests/test_extractor_fidelity.py
+++ b/tests/test_extractor_fidelity.py
@@ -20,6 +20,7 @@
 
 import pytest
 
+from linkml_reference_validator.etl import rules
 from linkml_reference_validator.etl.extract.html import HTMLExtractor
 from linkml_reference_validator.etl.extract.xml import (
     MAX_STUB_NOTICE_CHARS,
@@ -129,28 +130,21 @@ def test_non_utf8_encoded_article_is_extracted():
     assert "François" in text
 
 
-@pytest.mark.parametrize(
-    "notice",
-    [
-        "The publisher of this article does not allow downloading of the full "
-        "text in XML form from PMC.",
-        "The full text of this article cannot be obtained from PMC.",
-        "This article is not available from PMC.",
-        "Access to the full text is restricted by the publisher.",
-        # Wordings an exhaustive phrase list would miss; the length gate is
-        # what lets a broad "restricted" catch them safely.
-        "Access to this article is restricted.",
-        "Full text is restricted.",
-    ],
-)
+#: Every notice filed in etl/rules.py, as one flat list.
+STUB_NOTICES = [n for notices in rules.STUB_NOTICE_EXAMPLES.values() for n in notices]
+CANNOT_BE_OBTAINED = rules.STUB_NOTICE_EXAMPLES["cannot be obtained"][0]
+DOES_NOT_ALLOW = rules.STUB_NOTICE_EXAMPLES["does not allow downloading"][0]
+
+
+@pytest.mark.parametrize("notice", STUB_NOTICES)
 def test_short_stub_notice_is_rejected(notice):
-    """Genuine PMC placeholder documents must still be discarded."""
+    """Genuine PMC placeholder documents must still be discarded, as whole JATS."""
     assert XMLExtractor().extract(_jats(notice), content_type="application/xml") is None
 
 
 def test_is_stub_notice_requires_short_text():
     """A stub is short by definition; length is what makes the phrases safe."""
-    notice = "The full text of this article cannot be obtained from PMC."
+    notice = CANNOT_BE_OBTAINED
 
     assert is_stub_notice(notice) is True
     assert is_stub_notice(notice + " " + "x" * MAX_STUB_NOTICE_CHARS) is False
@@ -194,10 +188,7 @@ def test_pmc_xml_fetch_keeps_article_mentioning_restricted(mock_efetch):
 def test_pmc_xml_fetch_still_rejects_stub(mock_efetch):
     """A real placeholder response is still recognised as having no full text."""
     handle = MagicMock()
-    handle.read.return_value = _jats(
-        "The publisher of this article does not allow downloading of the full "
-        "text in XML form from PMC."
-    ).decode()
+    handle.read.return_value = _jats(DOES_NOT_ALLOW).decode()
     mock_efetch.return_value = handle
 
     text = PMIDSource()._fetch_pmc_xml(
diff --git a/tests/test_jats_tables.py b/tests/test_jats_tables.py
index d2c6a9a..f65650d 100644
--- a/tests/test_jats_tables.py
+++ b/tests/test_jats_tables.py
@@ -4,6 +4,7 @@
 
 import pytest
 
+from linkml_reference_validator.etl import rules
 from linkml_reference_validator.etl.extract.xml import XMLExtractor
 from linkml_reference_validator.etl.reference_fetcher import ReferenceFetcher
 from linkml_reference_validator.models import (
@@ -91,7 +92,8 @@ def test_row_cap(count):
 
 def test_stub_is_checked_before_tables():
     """Table size cannot disguise a restricted body notice."""
-    xml = "<article><body><p>Text cannot be obtained from PMC.</p></body><table-wrap><table>"
+    notice = rules.STUB_NOTICE_EXAMPLES["cannot be obtained"][0]
+    xml = f"<article><body><p>{notice}</p></body><table-wrap><table>"
     xml += "<tr><td>Data</td></tr>" * 200 + "</table></table-wrap></article>"
     assert XMLExtractor().extract(xml) is None
 
diff --git a/tests/test_pdf_url_title.py b/tests/test_pdf_url_title.py
new file mode 100644
index 0000000..12adb89
--- /dev/null
+++ b/tests/test_pdf_url_title.py
@@ -0,0 +1,228 @@
+"""A PDF fetched by URL should carry a real title where one can be found (issue #93).
+
+Before this, ``URLSource`` set ``title=url`` on every PDF, so a consumer that
+reads ``title`` as bibliographic metadata got the address back as the name.
+The recovery order is: a publisher landing page found by a documented rule
+(``citation_title``), then the PDF's embedded ``/Title``, then the URL.
+"""
+
+import io
+from unittest.mock import patch
+
+import pytest
+import requests
+from pypdf import PdfWriter
+
+from linkml_reference_validator.etl import rules
+from linkml_reference_validator.etl.extract.pdf import PDFExtractor
+from linkml_reference_validator.etl.sources.url import URLSource
+from linkml_reference_validator.models import ReferenceValidationConfig
+
+# Rule examples live in etl/rules.py; tests/test_rules.py runs them all. These
+# tests take one from there to exercise the fetch around the rule.
+JSTAGE_PDF, JSTAGE_ARTICLE = rules.LANDING_PAGE_EXAMPLES["J-STAGE"][0]
+WORD_PLACEHOLDER = next(
+    t for t in rules.PDF_PLACEHOLDER_TITLE_EXAMPLES if t.startswith("Microsoft Word")
+)
+
+
+def _pdf(title=None) -> bytes:
+    """Build a blank one-page PDF, optionally with an embedded ``/Title``."""
+    writer = PdfWriter()
+    writer.add_blank_page(width=100, height=100)
+    if title is not None:
+        writer.add_metadata({"/Title": title})
+    buf = io.BytesIO()
+    writer.write(buf)
+    return buf.getvalue()
+
+
+@pytest.fixture
+def config(tmp_path):
+    return ReferenceValidationConfig(cache_dir=tmp_path / "cache", rate_limit_delay=0.0)
+
+
+def _fetch(url, responses, config):
+    """Fetch ``url`` with the acquirer answering from ``responses``.
+
+    Each value is ``(bytes, content_type)``, or an exception to raise, as
+    ``requests`` does on a timeout or a refused connection.
+    """
+
+    def answer(u, _config):
+        response = responses.get(u, (None, None))
+        if isinstance(response, Exception):
+            raise response
+        return response
+
+    with patch("linkml_reference_validator.etl.sources.url.ContentAcquirer") as MockAcquirer:
+        MockAcquirer.return_value.fetch_bytes.side_effect = answer
+        result = URLSource().fetch(url, config)
+        requested = [c.args[0] for c in MockAcquirer.return_value.fetch_bytes.call_args_list]
+    return result, requested
+
+
+# --- embedded PDF metadata -------------------------------------------------
+
+
+def test_extractor_title_absent_is_none():
+    assert PDFExtractor().extract_title(_pdf()) is None
+
+
+@pytest.mark.parametrize(
+    "junk",
+    ["", "   ", *rules.PDF_PLACEHOLDER_TITLE_EXAMPLES],
+)
+def test_extractor_ignores_placeholder_titles(junk):
+    """Authoring tools stamp filenames and placeholders into /Title. Those are not titles."""
+    assert PDFExtractor().extract_title(_pdf(junk)) is None
+
+
+def _pdf_with_raw_title(raw: bytes) -> bytes:
+    """Build a PDF whose /Title is the literal PDF object ``raw``.
+
+    ``add_metadata`` turns every value into a string, so the object is written
+    over a same-length placeholder in the file, which keeps the xref offsets.
+    """
+    placeholder = b"(" + b"X" * 20 + b")"
+    data = _pdf("X" * 20)
+    assert placeholder in data and len(raw) <= len(placeholder)
+    return data.replace(placeholder, raw.ljust(len(placeholder)))
+
+
+@pytest.mark.parametrize(
+    "raw", [b"5", b"[(a)]", b"<< /A 1 >>"], ids=["number", "array", "dictionary"]
+)
+def test_extractor_ignores_a_title_that_is_not_text(raw):
+    """pypdf returns /Title as whatever object it holds. A number is not a title."""
+    assert PDFExtractor().extract_title(_pdf_with_raw_title(raw)) is None
+
+
+def test_raw_title_helper_writes_a_readable_title():
+    """The helper itself: a string written the same way is read back."""
+    assert PDFExtractor().extract_title(_pdf_with_raw_title(b"(Real Title)")) == "Real Title"
+
+
+def test_extractor_title_on_unparseable_bytes_is_none():
+    assert PDFExtractor().extract_title(b"%PDF-1.4 not really a pdf") is None
+
+
+def test_pdf_url_uses_embedded_title(config):
+    url = "https://example.org/files/paper.pdf"
+    result, _ = _fetch(url, {url: (_pdf("A Real Paper Title"), "application/pdf")}, config)
+    assert result is not None
+    assert result.title == "A Real Paper Title"
+
+
+def test_pdf_url_without_any_title_falls_back_to_url(config):
+    """With nothing to recover, the URL stays, so ``title == url`` still means 'none found'."""
+    url = "https://example.org/files/paper.pdf"
+    result, requested = _fetch(url, {url: (_pdf(), "application/pdf")}, config)
+    assert result is not None
+    assert result.title == url
+    assert requested == [url], "no landing-page rule matches, so nothing else is fetched"
+
+
+# --- landing page discovery ------------------------------------------------
+
+
+def test_jstage_pdf_takes_citation_title_from_article_page(config):
+    article = (
+        b'<html><head><title>J-STAGE</title>'
+        b'<meta name="citation_title" content="Feline Infectious Peritonitis &amp; Its Diagnosis">'
+        b"</head><body></body></html>"
+    )
+    result, requested = _fetch(
+        JSTAGE_PDF,
+        {
+            JSTAGE_PDF: (_pdf(WORD_PLACEHOLDER), "application/pdf"),
+            JSTAGE_ARTICLE: (article, "text/html; charset=utf-8"),
+        },
+        config,
+    )
+    assert result is not None
+    assert result.title == "Feline Infectious Peritonitis & Its Diagnosis"
+    assert result.content_type == "unavailable"  # blank page, no text: unchanged behavior
+    assert requested == [JSTAGE_PDF, JSTAGE_ARTICLE]
+
+
+def test_landing_page_title_beats_embedded_title(config):
+    """The publisher's page is authoritative. Embedded /Title is often stale."""
+    article = b'<meta content="The Published Title" name="citation_title">'
+    result, _ = _fetch(
+        JSTAGE_PDF,
+        {
+            JSTAGE_PDF: (_pdf("Submitted Draft Title"), "application/pdf"),
+            JSTAGE_ARTICLE: (article, "text/html"),
+        },
+        config,
+    )
+    assert result.title == "The Published Title"
+
+
+def test_landing_page_without_citation_title_falls_through_to_embedded(config):
+    """A bare <title> on a landing page is often the site name, so it is not used."""
+    article = b"<html><head><title>J-STAGE</title></head></html>"
+    result, _ = _fetch(
+        JSTAGE_PDF,
+        {
+            JSTAGE_PDF: (_pdf("Embedded Title"), "application/pdf"),
+            JSTAGE_ARTICLE: (article, "text/html"),
+        },
+        config,
+    )
+    assert result.title == "Embedded Title"
+
+
+@pytest.mark.parametrize(
+    "error", [requests.Timeout("slow"), requests.ConnectionError("refused")]
+)
+def test_landing_page_error_keeps_the_pdf(config, error):
+    """The title is best-effort. A failed landing page must not cost the PDF."""
+    result, requested = _fetch(
+        JSTAGE_PDF,
+        {JSTAGE_PDF: (_pdf("Embedded Title"), "application/pdf"), JSTAGE_ARTICLE: error},
+        config,
+    )
+    assert requested == [JSTAGE_PDF, JSTAGE_ARTICLE]
+    assert result is not None
+    assert result.full_text_url == JSTAGE_PDF
+    assert result.title == "Embedded Title"
+
+
+def test_landing_page_fetch_failure_falls_through_to_url(config):
+    result, _ = _fetch(JSTAGE_PDF, {JSTAGE_PDF: (_pdf(), "application/pdf")}, config)
+    assert result is not None
+    assert result.title == JSTAGE_PDF
+
+
+# --- citation_title on ordinary HTML fetches -------------------------------
+
+
+def test_html_prefers_citation_title_over_title_tag(config):
+    url = "https://example.org/article/1"
+    page = (
+        b"<html><head><title>Example Journal | Home</title>"
+        b'<meta name="citation_title" content="Actual Article Title"></head></html>'
+    )
+    result, _ = _fetch(url, {url: (page, "text/html")}, config)
+    assert result.title == "Actual Article Title"
+
+
+@pytest.mark.parametrize(
+    "page",
+    [
+        '<meta data-name="citation_title" content="Wrong"><meta name="citation_title" content="Right">',
+        '<meta name="citation_title" data-content="Wrong" content="Right">',
+        '<meta\nname="citation_title"\ncontent="Right">',
+    ],
+)
+def test_citation_title_ignores_look_alike_attributes(page):
+    """``data-name`` and ``data-content`` are other attributes, not ``name`` and ``content``."""
+    assert URLSource._citation_title(page) == "Right"
+
+
+@pytest.mark.parametrize("title", rules.PDF_PLACEHOLDER_TITLE_COUNTEREXAMPLES)
+def test_extractor_keeps_a_real_title(title):
+    """Through a real PDF: only a bare filename is a placeholder, not a title ending in one."""
+    assert PDFExtractor().extract_title(_pdf(title)) == title
diff --git a/tests/test_pmc_modern_container.py b/tests/test_pmc_modern_container.py
deleted file mode 100644
index 00ace8a..0000000
--- a/tests/test_pmc_modern_container.py
+++ /dev/null
@@ -1,75 +0,0 @@
-"""PMC's current article markup must be recognised by the HTML fallback.
-
-The fallback looked for ``div.article-body`` or ``div.tsec``. PMC serves neither
-today: the article sits in ``<section class="body main-article-body">`` -- a
-different element *and* a different class. So the path declined for every PMC
-article, and the "retry when the source serves full text again to repair it"
-advice printed when a stale ``full_text_html`` entry is withheld pointed at a
-route that could never succeed (reported downstream as monarch-initiative/dismech#12672).
-
-The structural test is what makes this fetch safe -- a bot-check interstitial
-arrives on an HTTP 200 and carries no article container -- so widening the
-selector must not widen it to something an interstitial or a navigation page
-would satisfy.
-"""
-
-from __future__ import annotations
-
-import pytest
-from bs4 import BeautifulSoup
-
-from linkml_reference_validator.etl.fulltext.pmc import find_pmc_article_body
-
-BODY = "<p>" + ("Real article prose. " * 40) + "</p>"
-
-
-@pytest.mark.parametrize(
-    "markup,label",
-    [
-        (f'<section class="body main-article-body">{BODY}</section>', "current PMC"),
-        (f'<div class="article-body">{BODY}</div>', "legacy div.article-body"),
-        (f'<div class="tsec">{BODY}</div>', "legacy div.tsec"),
-        (f'<section class="main-article-body">{BODY}</section>', "class without 'body'"),
-    ],
-)
-def test_article_containers_are_found(markup, label):
-    soup = BeautifulSoup(markup, "html.parser")
-    assert find_pmc_article_body(soup) is not None, f"{label} should be recognised"
-
-
-@pytest.mark.parametrize(
-    "markup,label",
-    [
-        ("<html><body><p>Checking your browser before accessing.</p></body></html>",
-         "bot-check interstitial"),
-        ("<html><body><nav><a href='/'>Home</a></nav></body></html>", "navigation page"),
-        ("<html><body><div class='usa-banner'>An official website</div></body></html>",
-         "banner chrome only"),
-    ],
-)
-def test_pages_without_an_article_container_are_declined(markup, label):
-    soup = BeautifulSoup(markup, "html.parser")
-    assert find_pmc_article_body(soup) is None, f"{label} must not be accepted"
-
-
-def test_a_bare_body_element_is_not_an_article_container():
-    """``<body>`` is on every page, so matching class="body" alone would accept
-    an interstitial. Only the article-body classes count."""
-    soup = BeautifulSoup(f"<html><body>{BODY}</body></html>", "html.parser")
-    assert find_pmc_article_body(soup) is None
-
-
-def test_a_challenge_page_carrying_a_classed_body_is_still_declined():
-    """The interstitial arrives on an HTTP 200, so this selector is the only check.
-
-    PMC's challenge page carries a classed ``<body>``. None of its classes may
-    overlap the article-body list, or a bot-check page gets cached as full text.
-    """
-    markup = (
-        '<html><body class="usa-page bot-check">'
-        "<h1>Checking your browser before accessing</h1>"
-        "<p>Enable JavaScript and cookies to continue.</p>"
-        "</body></html>"
-    )
-    soup = BeautifulSoup(markup, "html.parser")
-    assert find_pmc_article_body(soup) is None
diff --git a/tests/test_reference_fetcher.py b/tests/test_reference_fetcher.py
index aa76162..bb47195 100644
--- a/tests/test_reference_fetcher.py
+++ b/tests/test_reference_fetcher.py
@@ -1384,9 +1384,17 @@ def test_entry_whose_id_contains_a_horizontal_rule_is_not_perpetually_stale(fetc
     re-fetched, be rewritten with the same id, and read as unstamped again on
     every single run.
     """
+    from linkml_reference_validator.etl.reference_fetcher import URL_SOURCE_CACHE_VERSION
+
     reference_id = "url:https://example.com/a---b"
+    # Stamped as a fresh URLSource fetch would be. The stamp is written below
+    # reference_id, so a truncated block would hide it too.
     fetcher._save_to_disk(
-        ReferenceContent(reference_id=reference_id, content="Body text.")
+        ReferenceContent(
+            reference_id=reference_id,
+            content="Body text.",
+            metadata={"url_source_version": URL_SOURCE_CACHE_VERSION},
+        )
     )
 
     assert not fetcher._is_stale_cache_entry(_cached_text(fetcher, reference_id))
diff --git a/tests/test_rules.py b/tests/test_rules.py
new file mode 100644
index 0000000..e77bfea
--- /dev/null
+++ b/tests/test_rules.py
@@ -0,0 +1,129 @@
+"""Every publisher rule in ``etl.rules`` has examples, and the code honours them.
+
+The examples live in ``etl/rules.py`` beside their rules. This file only runs
+them, through the code that consumes each rule rather than the rule alone, so
+an example that passes here passes where it matters.
+"""
+
+import pytest
+from bs4 import BeautifulSoup
+
+from linkml_reference_validator.etl import rules
+from linkml_reference_validator.etl.extract import html, pdf, xml
+from linkml_reference_validator.etl.extract.pdf import clean_pdf_title
+from linkml_reference_validator.etl.extract.xml import is_stub_notice
+from linkml_reference_validator.etl.fulltext import pmc
+from linkml_reference_validator.etl.fulltext.pmc import find_pmc_article_body
+from linkml_reference_validator.etl.sources import url
+from linkml_reference_validator.etl.sources.url import URLSource
+
+#: Stands in for ``{body}`` in markup examples: long enough to be an article.
+BODY = "<p>" + ("Real article prose. " * 40) + "</p>"
+
+
+# --- every rule has an example ---------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "rule_names,examples",
+    [
+        (set(rules.LANDING_PAGE_RULES), rules.LANDING_PAGE_EXAMPLES),
+        (set(rules.ARTICLE_BODY_SELECTORS), rules.ARTICLE_BODY_EXAMPLES),
+        (set(rules.PMC_ARTICLE_BODY_CLASSES), rules.PMC_ARTICLE_BODY_EXAMPLES),
+        (set(rules.STUB_NOTICE_PHRASES), rules.STUB_NOTICE_EXAMPLES),
+    ],
+    ids=["landing-page", "article-body", "pmc-article-body", "stub-notice"],
+)
+def test_every_rule_has_an_example(rule_names, examples):
+    assert set(examples) == rule_names
+    assert all(examples.values())
+
+
+def test_placeholder_titles_have_examples():
+    assert rules.PDF_PLACEHOLDER_TITLE_EXAMPLES
+    assert rules.PDF_PLACEHOLDER_TITLE_COUNTEREXAMPLES
+
+
+# --- consumers use the rules, not copies ------------------------------------
+
+
+def test_consumers_import_the_rules():
+    assert url.LANDING_PAGE_RULES is rules.LANDING_PAGE_RULES
+    assert pdf.PDF_PLACEHOLDER_TITLE is rules.PDF_PLACEHOLDER_TITLE
+    assert pmc.PMC_ARTICLE_BODY_CLASSES is rules.PMC_ARTICLE_BODY_CLASSES
+    assert xml.STUB_NOTICE_PHRASES is rules.STUB_NOTICE_PHRASES
+    assert html.ARTICLE_BODY_SELECTOR == ", ".join(rules.ARTICLE_BODY_SELECTORS)
+
+
+# --- landing pages -----------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "pdf_url,landing",
+    [pair for pairs in rules.LANDING_PAGE_EXAMPLES.values() for pair in pairs],
+)
+def test_landing_page_example(pdf_url, landing):
+    assert URLSource._landing_page_url(pdf_url) == landing
+
+
+@pytest.mark.parametrize("pdf_url", rules.LANDING_PAGE_COUNTEREXAMPLES)
+def test_landing_page_counterexample(pdf_url):
+    assert URLSource._landing_page_url(pdf_url) is None
+
+
+# --- placeholder PDF titles -------------------------------------------------
+
+
+@pytest.mark.parametrize("title", rules.PDF_PLACEHOLDER_TITLE_EXAMPLES)
+def test_placeholder_title_example(title):
+    assert clean_pdf_title(title) is None
+
+
+@pytest.mark.parametrize("title", rules.PDF_PLACEHOLDER_TITLE_COUNTEREXAMPLES)
+def test_placeholder_title_counterexample(title):
+    assert clean_pdf_title(title) == title
+
+
+# --- article body containers ------------------------------------------------
+
+
+@pytest.mark.parametrize("selector,markup", sorted(rules.ARTICLE_BODY_EXAMPLES.items()))
+def test_article_body_example(selector, markup):
+    soup = BeautifulSoup(markup.format(body=BODY), "html.parser")
+    assert soup.select_one(html.ARTICLE_BODY_SELECTOR) is not None, selector
+
+
+@pytest.mark.parametrize("markup", rules.ARTICLE_BODY_COUNTEREXAMPLES)
+def test_article_body_counterexample(markup):
+    soup = BeautifulSoup(markup.format(body=BODY), "html.parser")
+    assert soup.select_one(html.ARTICLE_BODY_SELECTOR) is None
+
+
+# --- PMC article containers --------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "markup",
+    [m for examples in rules.PMC_ARTICLE_BODY_EXAMPLES.values() for m in examples],
+)
+def test_pmc_article_body_example(markup):
+    soup = BeautifulSoup(markup.format(body=BODY), "html.parser")
+    assert find_pmc_article_body(soup) is not None
+
+
+@pytest.mark.parametrize("markup", rules.PMC_ARTICLE_BODY_COUNTEREXAMPLES)
+def test_pmc_article_body_counterexample(markup):
+    soup = BeautifulSoup(markup.format(body=BODY), "html.parser")
+    assert find_pmc_article_body(soup) is None
+
+
+# --- PMC placeholder notices --------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "phrase,notice",
+    [(p, n) for p, notices in rules.STUB_NOTICE_EXAMPLES.items() for n in notices],
+)
+def test_stub_notice_example(phrase, notice):
+    assert phrase in notice.lower(), "an example must show the phrase it is filed under"
+    assert is_stub_notice(notice)
diff --git a/tests/test_url_html_sanitize.py b/tests/test_url_html_sanitize.py
new file mode 100644
index 0000000..6288113
--- /dev/null
+++ b/tests/test_url_html_sanitize.py
@@ -0,0 +1,161 @@
+"""HTML fetched by ``URLSource`` is sanitized before it is cached (issue #92).
+
+``URLSource`` used to store the response body verbatim, so page scripts,
+comments and tag attributes (signed asset URLs, API-key parameters) went
+into caches that projects commit to public repositories. Now HTML keeps its
+body markup and text, loses ``script``/``style``/``noscript``/``template``
+and comments, drops ``meta``/``link``/``base`` (they hold nothing but
+attributes), and keeps only the table-structural attributes ``rowspan``,
+``colspan`` and ``scope``. Plain text and XML are stored as before.
+"""
+
+from unittest.mock import patch
+
+import pytest
+
+from linkml_reference_validator.etl.extract.html import sanitize_html
+from linkml_reference_validator.etl.sources.url import URLSource
+from linkml_reference_validator.models import ReferenceValidationConfig
+
+PAGE = b"""<!DOCTYPE html>
+<html lang="en">
+<head>
+  <title>Journal | Home</title>
+  <base href="https://example.org/">
+  <meta name="citation_title" content="Mitochondrial Disease in Children">
+  <link rel="stylesheet" href="https://cdn.example.org/site.css?token=T">
+  <style>.hidden { display: none }</style>
+  <script>var apiKey = "SECRET-KEY-123";</script>
+  <script src="https://cdn.example.org/app.js?Signature=abc&Expires=2147483647"></script>
+</head>
+<body class="article" data-token="SIGNED-TOKEN">
+  <!-- build 4f2a; internal note -->
+  <p id="p1" onclick="track()">Patients showed <a href="https://x.org/?api_key=K">lactic acidosis</a>.</p>
+  <noscript><img src="https://tracker.example.org/pixel.gif"></noscript>
+  <template><p>Template body</p></template>
+  <table class="t">
+    <tr><th scope="col" style="color:red">Gene</th><th colspan="2">Finding</th></tr>
+    <tr><td rowspan="2" data-x="1">POLG</td><td>A</td><td>B</td></tr>
+  </table>
+</body>
+</html>
+"""
+
+
+@pytest.fixture
+def config(tmp_path):
+    return ReferenceValidationConfig(cache_dir=tmp_path / "cache", rate_limit_delay=0.0)
+
+
+def _fetch(url, body, content_type, config):
+    with patch("linkml_reference_validator.etl.sources.url.ContentAcquirer") as MockAcquirer:
+        MockAcquirer.return_value.fetch_bytes.return_value = (body, content_type)
+        return URLSource().fetch(url, config)
+
+
+@pytest.fixture
+def cached(config):
+    result = _fetch("https://example.org/article/1", PAGE, "text/html; charset=utf-8", config)
+    assert result is not None
+    return result
+
+
+@pytest.mark.parametrize(
+    "gone",
+    [
+        "SECRET-KEY-123",
+        "Signature=abc",
+        ".hidden",
+        "tracker.example.org",
+        "Template body",
+        "<script",
+        "<style",
+        "<noscript",
+        "<template",
+        "<meta",
+        "<link",
+        "<base",
+    ],
+)
+def test_non_content_elements_are_dropped(cached, gone):
+    assert gone not in cached.content
+
+
+def test_comments_are_dropped(cached):
+    assert "internal note" not in cached.content
+    assert "<!--" not in cached.content
+
+
+@pytest.mark.parametrize(
+    "gone",
+    ["SIGNED-TOKEN", "api_key=K", "onclick", 'class="', 'id="', 'style="', "data-x", 'lang="'],
+)
+def test_attributes_are_dropped(cached, gone):
+    assert gone not in cached.content
+
+
+@pytest.mark.parametrize("kept", ['scope="col"', 'colspan="2"', 'rowspan="2"'])
+def test_table_structure_attributes_are_kept(cached, kept):
+    assert kept in cached.content
+
+
+def test_body_text_and_markup_survive(cached):
+    assert "<p>Patients showed <a>lactic acidosis</a>.</p>" in cached.content
+    assert "<td>POLG</td>" not in cached.content  # rowspan kept on it
+    assert "POLG" in cached.content
+    assert cached.content_type == "url"
+
+
+def test_title_is_read_before_attributes_are_stripped(cached):
+    """citation_title lives in a <meta> attribute, so it must be read from the raw page."""
+    assert cached.title == "Mitochondrial Disease in Children"
+
+
+def test_html_is_sniffed_without_a_content_type(config):
+    result = _fetch("https://example.org/a", PAGE, None, config)
+    assert "SECRET-KEY-123" not in result.content
+
+
+def test_plain_text_is_left_alone(config):
+    body = b'Plain notes. <script>not really markup</script> <b class="x">'
+    result = _fetch("https://example.org/notes.txt", body, "text/plain", config)
+    assert result.content == body.decode()
+
+
+def test_xml_is_left_alone(config):
+    body = b'<?xml version="1.0"?><record id="7"><!-- c --><title>T</title></record>'
+    result = _fetch("https://example.org/r.xml", body, "application/xml", config)
+    assert result.content == body.decode()
+
+
+def test_sanitize_html_is_idempotent():
+    once = sanitize_html(PAGE.decode())
+    assert sanitize_html(once) == once
+
+
+SCRIPTED = b'<p>Text</p><script>var apiKey = "SECRET-KEY-123";</script>'
+
+
+@pytest.mark.parametrize(
+    "body",
+    [
+        b"\xef\xbb\xbf<!DOCTYPE html><html><body>" + SCRIPTED + b"</body></html>",
+        b"<!-- saved from url=(0042)https://example.org -->\n<html><body>" + SCRIPTED,
+        b"<!-- a -->\n<!-- b -->\n<!DOCTYPE html><html>" + SCRIPTED,
+        b"<head><title>T</title></head><body>" + SCRIPTED,
+        b"\n  <body>" + SCRIPTED,
+    ],
+    ids=["bom", "comment", "two-comments", "head-first", "body-first"],
+)
+@pytest.mark.parametrize("content_type", [None, "text/plain"])
+def test_html_is_recognized_past_a_bom_or_leading_comments(config, body, content_type):
+    """A mislabelled page is still a page. Its scripts must not reach the cache."""
+    result = _fetch("https://example.org/a", body, content_type, config)
+    assert "SECRET-KEY-123" not in result.content
+    assert "Text" in result.content
+
+
+def test_text_that_mentions_html_is_left_alone(config):
+    body = b"Notes on the <html> element and <script> tags."
+    result = _fetch("https://example.org/notes.txt", body, "text/plain", config)
+    assert result.content == body.decode()
diff --git a/tests/test_url_source_cache_version.py b/tests/test_url_source_cache_version.py
new file mode 100644
index 0000000..0643326
--- /dev/null
+++ b/tests/test_url_source_cache_version.py
@@ -0,0 +1,141 @@
+"""``url:`` entries cached before the URLSource fixes must be re-fetched.
+
+Sanitizing HTML (#92) and recovering PDF titles (#93) change what URLSource
+writes, and neither rewrites what it already wrote: raw page scripts and
+URL-as-title entries carry the current ``extractor_version`` and would be
+served forever. ``url_source_version`` is their own staleness stamp, scoped
+the way ``html_full_text_version`` is, so only ``url:`` entries pay the refresh.
+"""
+
+from __future__ import annotations
+
+from unittest.mock import patch
+
+import pytest
+import requests
+
+from linkml_reference_validator.etl.reference_fetcher import (
+    ABSENT_CONTENT_CACHE_VERSION,
+    EXTRACTOR_CACHE_VERSION,
+    URL_SOURCE_CACHE_VERSION,
+    ReferenceFetcher,
+)
+from linkml_reference_validator.models import ReferenceContent, ReferenceValidationConfig
+
+URL = "https://example.org/article/1"
+RAW_PAGE = (
+    '<html><head><title>Journal | Home</title></head><body>'
+    '<script>var apiKey = "SECRET-KEY-123";</script>'
+    "<p>Patients showed lactic acidosis.</p></body></html>"
+)
+
+
+def _entry(
+    reference_id: str, content_type: str, *, url_version: int | None = None, body: str = ""
+) -> str:
+    """A cache entry current in every respect except the stamp a test varies."""
+    lines = [
+        "---",
+        f"reference_id: {reference_id}",
+        f"extractor_version: {EXTRACTOR_CACHE_VERSION}",
+    ]
+    if url_version is not None:
+        lines.append(f"url_source_version: {url_version}")
+    if content_type == "unavailable":
+        lines.append(f"absent_content_version: {ABSENT_CONTENT_CACHE_VERSION}")
+    lines += [f"content_type: {content_type}", "---", "", "## Content", "", body]
+    return "\n".join(lines)
+
+
+@pytest.mark.parametrize("content_type", ["url", "full_text_pdf", "unavailable"])
+def test_unstamped_url_entry_is_stale(content_type):
+    assert ReferenceFetcher._is_stale_cache_entry(_entry(f"url:{URL}", content_type))
+
+
+@pytest.mark.parametrize("content_type", ["url", "full_text_pdf", "unavailable"])
+def test_current_url_entry_is_fresh(content_type):
+    entry = _entry(f"url:{URL}", content_type, url_version=URL_SOURCE_CACHE_VERSION)
+    assert not ReferenceFetcher._is_stale_cache_entry(entry)
+
+
+def test_a_newer_stamp_is_not_stale():
+    entry = _entry(f"url:{URL}", "url", url_version=URL_SOURCE_CACHE_VERSION + 1)
+    assert not ReferenceFetcher._is_stale_cache_entry(entry)
+
+
+def test_other_sources_are_untouched():
+    assert not ReferenceFetcher._is_stale_cache_entry(_entry("PMID:12345", "abstract_only"))
+
+
+@pytest.fixture
+def fetcher(tmp_path):
+    return ReferenceFetcher(ReferenceValidationConfig(cache_dir=tmp_path, rate_limit_delay=0.0))
+
+
+def test_a_fresh_fetch_is_stamped_and_round_trips(fetcher, tmp_path):
+    with patch("linkml_reference_validator.etl.sources.url.ContentAcquirer") as MockAcquirer:
+        MockAcquirer.return_value.fetch_bytes.return_value = (RAW_PAGE.encode(), "text/html")
+        fetcher.fetch(f"url:{URL}")
+
+    written = next(tmp_path.glob("*.md")).read_text()
+    assert f"url_source_version: {URL_SOURCE_CACHE_VERSION}" in written
+    assert not ReferenceFetcher._is_stale_cache_entry(written)
+
+    reloaded = fetcher._load_from_disk(f"url:{URL}")
+    assert reloaded is not None
+    assert reloaded.metadata["url_source_version"] == URL_SOURCE_CACHE_VERSION
+
+
+def test_only_a_fresh_fetch_is_certified(fetcher, tmp_path):
+    """Saving a url: entry that URLSource did not just produce must not stamp it."""
+    fetcher._save_to_disk(
+        ReferenceContent(
+            reference_id=f"url:{URL}", content_type="url", title="t", content=RAW_PAGE
+        )
+    )
+    written = next(tmp_path.glob("*.md")).read_text()
+    assert "url_source_version" not in written
+
+
+def test_old_raw_entry_is_refetched_and_sanitized(fetcher):
+    cache_path = fetcher.get_cache_path(f"url:{URL}")
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    cache_path.write_text(_entry(f"url:{URL}", "url", body=RAW_PAGE))
+
+    with patch("linkml_reference_validator.etl.sources.url.ContentAcquirer") as MockAcquirer:
+        MockAcquirer.return_value.fetch_bytes.return_value = (RAW_PAGE.encode(), "text/html")
+        result = fetcher.fetch(f"url:{URL}")
+
+    assert result is not None
+    assert "SECRET-KEY-123" not in result.content
+    assert "SECRET-KEY-123" not in cache_path.read_text()
+
+
+@pytest.mark.parametrize(
+    "unreachable",
+    [
+        (None, None),  # the acquirer's own refusal: non-200, or over the size cap
+        requests.ConnectionError("network is unreachable"),  # really offline
+        requests.Timeout("timed out"),
+    ],
+)
+def test_old_raw_entry_is_still_served_when_offline(fetcher, unreachable):
+    """Out of date is better than not found. It is not re-saved, so it stays stale.
+
+    Every unstamped url: entry goes back to the network after this change, so
+    the first offline run is where this has to hold.
+    """
+    cache_path = fetcher.get_cache_path(f"url:{URL}")
+    cache_path.parent.mkdir(parents=True, exist_ok=True)
+    cache_path.write_text(_entry(f"url:{URL}", "url", body=RAW_PAGE))
+
+    with patch("linkml_reference_validator.etl.sources.url.ContentAcquirer") as MockAcquirer:
+        if isinstance(unreachable, Exception):
+            MockAcquirer.return_value.fetch_bytes.side_effect = unreachable
+        else:
+            MockAcquirer.return_value.fetch_bytes.return_value = unreachable
+        result = fetcher.fetch(f"url:{URL}")
+
+    assert result is not None
+    assert "lactic acidosis" in result.content
+    assert ReferenceFetcher._is_stale_cache_entry(cache_path.read_text())