gloomberb 0.13.2 → 0.14.0

package/src/plugins/builtin/news/wire/news/detail-view.tsx

@@ -5,83 +5,125 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import type { MarketNewsItem, NewsStoryItem } from "../../../../../types/news-source";
 import { colors } from "../../../../../theme/colors";
 import { TickerBadge } from "../../../../../components/ticker/badge";
-import { ExternalLink, ExternalLinkText } from "../../../../../components/ui";
+import { ExternalLinkText } from "../../../../../components/ui";
 import { collectNewsDisplayTickers } from "../../../../../news/ticker-symbols";
 import { useInlineTickers } from "../../../../../state/hooks/inline-tickers";
 import { isPlainKey } from "../../../../../utils/keyboard";
 import { wrapTextLines } from "../../../../../utils/text-wrap";
 import { formatDetailDate } from "../../../../../utils/datetime-format";
+import { mergeNewsArticle } from "../../../../../news/news-model";
+import { usePluginPaneState } from "../../../../runtime";
 import { formatNewsCategory } from "../categories";
 
 function hasStoryItems(article: MarketNewsItem | null): boolean {
   return (article?.items?.length ?? 0) > 0;
 }
 
-function mergeLoadedArticle(base: MarketNewsItem, loaded: MarketNewsItem | null | undefined): MarketNewsItem {
-  if (!loaded) return base;
-  return {
-    ...base,
-    ...loaded,
-    items: hasStoryItems(loaded) ? loaded.items : base.items,
-  };
-}
-
+/**
+ * The open story is pane state, not component state: it is part of what the
+ * pane shows, so it survives a relaunch and travels with a shared pane. A
+ * receiver's feed may no longer list the story, so an id the feed cannot
+ * explain is fetched by id before it is given up on.
+ */
 export function useNewsArticleDetail(
   articles: MarketNewsItem[],
   loadArticleDetail?: (articleId: string) => Promise<MarketNewsItem | null>,
+  stateKey = "openArticleId",
 ) {
-  const [detailArticleId, setDetailArticleId] = useState<string | null>(null);
-  const [loadedArticles, setLoadedArticles] = useState<Map<string, MarketNewsItem>>(() => new Map());
-  const requestedArticleIds = useRef<Set<string>>(new Set());
-  const baseDetailArticle = useMemo(
-    () => (
-      detailArticleId
-        ? articles.find((article) => article.id === detailArticleId) ?? null
-        : null
-    ),
+  const [detailArticleId, setDetailArticleId] = usePluginPaneState<string | null>(stateKey, null);
+  const [request, setRequest] = useState<{
+    base: MarketNewsItem;
+    article?: MarketNewsItem;
+    loading: boolean;
+    error: string | null;
+  } | null>(null);
+  const [standalone, setStandalone] = useState<{
+    id: string;
+    article: MarketNewsItem | null;
+    loading: boolean;
+    error: string | null;
+  } | null>(null);
+  const requestedArticle = useRef<MarketNewsItem | null>(null);
+  const standaloneRequestId = useRef<string | null>(null);
+  const listedDetailArticle = useMemo(
+    () => articles.find((article) => article.id === detailArticleId) ?? null,
     [articles, detailArticleId],
   );
-  const detailArticle = useMemo(() => (
-    baseDetailArticle && detailArticleId
-      ? mergeLoadedArticle(baseDetailArticle, loadedArticles.get(detailArticleId))
-      : baseDetailArticle
-  ), [baseDetailArticle, detailArticleId, loadedArticles]);
+  const currentStandalone = standalone?.id === detailArticleId ? standalone : null;
+  const baseDetailArticle = listedDetailArticle ?? currentStandalone?.article ?? null;
+  // The service owns cached stories. A local completion only belongs to the
+  // exact feed revision that requested it; it must never cover a newer update.
+  const currentRequest = request?.base === baseDetailArticle ? request : null;
+  const detailArticle = currentRequest?.article ?? baseDetailArticle;
 
   useEffect(() => {
-    if (detailArticleId && !baseDetailArticle) {
+    if (!detailArticleId || listedDetailArticle) {
+      standaloneRequestId.current = null;
+      return;
+    }
+    if (currentStandalone) {
+      if (!currentStandalone.loading && !currentStandalone.article) setDetailArticleId(null);
+      return;
+    }
+    if (!loadArticleDetail) {
       setDetailArticleId(null);
+      return;
     }
-  }, [baseDetailArticle, detailArticleId]);
+    const id = detailArticleId;
+    // The pending marker re-runs this effect; the request it belongs to must
+    // not be cancelled by that re-run, only by a change of story.
+    if (standaloneRequestId.current === id) return;
+    standaloneRequestId.current = id;
+    setStandalone({ id, article: null, loading: true, error: null });
+    void loadArticleDetail(id)
+      .then((article) => {
+        if (standaloneRequestId.current !== id) return;
+        setStandalone({ id, article: article?.id === id ? article : null, loading: false, error: null });
+      })
+      .catch((error: unknown) => {
+        if (standaloneRequestId.current !== id) return;
+        setStandalone({ id, article: null, loading: false, error: error instanceof Error ? error.message : "Story detail unavailable." });
+      });
+  }, [currentStandalone, detailArticleId, listedDetailArticle, loadArticleDetail, setDetailArticleId]);
 
   useEffect(() => {
-    if (!detailArticleId || !baseDetailArticle || hasStoryItems(detailArticle)) return;
-    if (!loadArticleDetail || requestedArticleIds.current.has(detailArticleId)) return;
-
-    requestedArticleIds.current.add(detailArticleId);
-    void loadArticleDetail(detailArticleId)
-      .then((loadedArticle) => {
-        if (!loadedArticle) return;
-        setLoadedArticles((current) => {
-          const next = new Map(current);
-          next.set(detailArticleId, loadedArticle);
-          return next;
-        });
+    if (!baseDetailArticle || hasStoryItems(baseDetailArticle) || !loadArticleDetail) return;
+    // A story fetched by id is already the detail; asking again adds nothing.
+    if (baseDetailArticle === currentStandalone?.article) return;
+    if (requestedArticle.current === baseDetailArticle) return;
+    requestedArticle.current = baseDetailArticle;
+    let active = true;
+    setRequest({ base: baseDetailArticle, loading: true, error: null });
+    void loadArticleDetail(baseDetailArticle.id)
+      .then((article) => {
+        if (!active) return;
+        if (article && article.id !== baseDetailArticle.id) throw new Error("Story detail identity mismatch.");
+        setRequest({ base: baseDetailArticle, article: article ? mergeNewsArticle(baseDetailArticle, article) : undefined, loading: false, error: null });
       })
-      .catch(() => {
-        requestedArticleIds.current.delete(detailArticleId);
+      .catch((error: unknown) => {
+        if (!active) return;
+        setRequest({ base: baseDetailArticle, loading: false, error: error instanceof Error ? error.message : "Story detail unavailable." });
       });
-  }, [baseDetailArticle, detailArticle, detailArticleId, loadArticleDetail]);
+    return () => { active = false; };
+  }, [baseDetailArticle, currentStandalone?.article, loadArticleDetail]);
 
   const openArticle = useCallback((article: MarketNewsItem) => {
+    requestedArticle.current = null;
+    standaloneRequestId.current = null;
     setDetailArticleId(article.id);
-  }, []);
-
+  }, [setDetailArticleId]);
   const closeDetail = useCallback(() => {
+    requestedArticle.current = null;
+    standaloneRequestId.current = null;
     setDetailArticleId(null);
-  }, []);
+    setRequest(null);
+    setStandalone(null);
+  }, [setDetailArticleId]);
 
   return {
     detailArticle,
+    detailLoading: (currentRequest?.loading ?? false) || (currentStandalone?.loading ?? false),
+    detailError: currentRequest?.error ?? currentStandalone?.error ?? null,
     openArticle,
     closeDetail,
   };
@@ -198,8 +240,11 @@ export function NewsDetailView({ item, focused, width, showTitle = true }: {
     () => item.categories.map(formatNewsCategory).filter(Boolean).join(" · "),
     [item.categories],
   );
-  const lastUpdatedAt = timelineItems[0]?.publishedAt ?? item.publishedAt;
-  const lastUpdatedStr = formatDetailDate(storyItemDate(lastUpdatedAt));
+  const lastUpdatedAt = new Date(Math.max(
+    storyItemDate(item.publishedAt).getTime(),
+    storyItemDate(timelineItems[0]?.publishedAt ?? item.publishedAt).getTime(),
+  ));
+  const lastUpdatedStr = formatDetailDate(lastUpdatedAt);
 
   const scrollBy = useCallback((delta: number) => {
     const scrollBox = scrollRef.current;
@@ -303,7 +348,6 @@ export function NewsDetailView({ item, focused, width, showTitle = true }: {
               ))}
             </Box>
           )}
-          <ExternalLink url={item.url} color={colors.textDim} />
         </Box>
       </ScrollBox>
     </Box>

package/src/plugins/builtin/news/wire/news/footer.ts

@@ -8,14 +8,13 @@ import { isPlainKey } from "../../../../../utils/keyboard";
 import { useCloudAccessFooter } from "../../../shared/cloud-upgrade";
 import { CLOUD_NEWS_DELAY_HOURS } from "../../../shared/plan-access";
 import { usePaneStatusLinkFooter } from "../../../shared/pane-footer";
-import { usePublicShare } from "../../../shared/public-share";
+import { usePluginAppActions } from "../../../../runtime";
+import { useOptionalPaneInstanceId } from "../../../../../state/app/context";
 
 interface NewsFooterArticle {
   title?: string | null;
-  summary?: string | null;
   source?: string | null;
   url?: string | null;
-  items?: Array<{ title?: string | null; summary?: string | null }>;
 }
 
 interface UseNewsArticleFooterOptions {
@@ -37,29 +36,21 @@ export function useNewsArticleFooter({
 }: UseNewsArticleFooterOptions) {
   const language = useAppLanguage();
   const { publicSharing } = useUiCapabilities();
-  const createPublicShare = usePublicShare();
+  const { sharePane } = usePluginAppActions();
+  const paneInstanceId = useOptionalPaneInstanceId();
+  // The open story is pane state, so sharing the pane shares the story: the
+  // receiver's terminal opens on the same article.
   const shareArticle = useCallback(() => {
-    if (!article?.title) return;
-    const text = [
-      article.summary,
-      ...(article.items ?? []).map((item) => item.summary || item.title),
-    ].filter((value): value is string => !!value?.trim()).join("\n\n").slice(0, 50_000);
-    void createPublicShare({
-      kind: "article",
-      data: {
-        title: article.title,
-        text,
-        ...(article.url ? { sourceUrl: article.url } : {}),
-      },
-    });
-  }, [article, createPublicShare]);
+    if (!article?.title || !paneInstanceId) return;
+    sharePane(paneInstanceId);
+  }, [article?.title, paneInstanceId, sharePane]);
   useShortcut((event) => {
     if (!focused || !publicSharing || !article?.title || !isPlainKey(event, "y")) return;
     event.preventDefault();
     event.stopPropagation();
     shareArticle();
   });
-  const { access, segment } = useCloudAccessFooter({
+  const { access, hint: upgradeHint, segment } = useCloudAccessFooter({
     delayLabel: tf("{count}h", { count: CLOUD_NEWS_DELAY_HOURS }),
     focused,
     segmentId: "news-access",
@@ -80,9 +71,13 @@ export function useNewsArticleFooter({
     url: article?.url,
     source: article?.source,
     info: footerInfo,
-    hints: publicSharing && article?.title
-      ? [{ id: "share", key: "y", label: " share", onPress: shareArticle }]
-      : undefined,
+    // [o]pen is appended after these, so the story's own actions stay rightmost.
+    hints: [
+      ...(upgradeHint ? [upgradeHint] : []),
+      ...(publicSharing && article?.title && paneInstanceId
+        ? [{ id: "share", key: "y", label: " share", onPress: shareArticle }]
+        : []),
+    ],
     showOpenHint: true,
     loading,
     error,

package/src/plugins/builtin/news/wire/news/preset-pane.tsx

@@ -54,15 +54,19 @@ export function NewsPresetPane({
     ? sortPreference
     : defaultSort;
   const loadNewsStory = useLoadNewsStory();
-  const { detailArticle, openArticle, closeDetail } = useNewsArticleDetail(articles, loadNewsStory);
+  const { detailArticle, detailLoading, detailError, openArticle, closeDetail } = useNewsArticleDetail(
+    articles,
+    loadNewsStory,
+    `${paneKey}:openArticleId`,
+  );
   const { readArticleIds, markArticleRead } = useNewsReadState();
 
   useNewsArticleFooter({
     registrationId: `news-wire:${paneKey}`,
     focused,
     article: detailArticle,
-    loading: loading && articles.length > 0,
-    error,
+    loading: detailLoading || (loading && articles.length > 0),
+    error: [error, detailError].filter(Boolean).join(" ") || null,
   });
 
   const detailContent = detailArticle ? (

package/src/plugins/builtin/news/wire/news/table.tsx

@@ -13,6 +13,7 @@ import { TABLE_COLUMN_GAP, tableColumnWidth } from "../../../../../components/ui
 import type { MarketNewsItem } from "../../../../../types/news-source";
 import { colors } from "../../../../../theme/colors";
 import { collectNewsDisplayTickers } from "../../../../../news/ticker-symbols";
+import { useLoadNewsStory } from "../../../../../news/hooks";
 import { formatRelativeTime } from "../../../../../utils/datetime-format";
 import { truncateWithEllipsis } from "../../../../../utils/text-wrap";
 import { formatNewsCategory } from "../categories";
@@ -248,6 +249,15 @@ export function NewsArticleStackView({
     onArticleRead?.(article.id);
     onOpenArticle(article);
   }, [onArticleRead, onOpenArticle]);
+  // The service merges a fetched story into the feed's article, and the
+  // detail skips its own fetch once the article carries story items, so a
+  // story warmed while the cursor rests on its row opens without a wait.
+  // Nothing else happens here: read state is only marked on open.
+  const loadNewsStory = useLoadNewsStory();
+  const prefetchStory = useCallback((article: MarketNewsItem) => {
+    if ((article.items?.length ?? 0) > 0) return;
+    void loadNewsStory(article.id).catch(() => {});
+  }, [loadNewsStory]);
 
   useEffect(() => {
     if (sortedArticles.length === 0) {
@@ -293,7 +303,6 @@ export function NewsArticleStackView({
               symbols={tickers}
               width={column.width}
               fallbackColor={selectedColor ?? colors.textBright}
-              liveQuote={false}
             />
           ),
           color: selectedColor ?? colors.textBright,
@@ -339,6 +348,7 @@ export function NewsArticleStackView({
         onChange: (id) => setSelectedArticleId(id),
       }}
       onActivate={openArticle}
+      prefetchDetail={prefetchStory}
       rootBefore={rootBefore}
       rootHeight={rootHeight}
       onRootKeyDown={onRootKeyDown}

package/src/plugins/builtin/news/wire/persisted-articles.ts

@@ -1,6 +1,6 @@
 import { useEffect, useMemo } from "react";
 import type { MarketNewsItem, NewsStoryItem } from "../../../../types/news-source";
-import { usePluginPaneState } from "../../../runtime";
+import { usePluginPaneState, usePrunePluginPaneState } from "../../../runtime";
 
 const MAX_PERSISTED_ARTICLES = 200;
 const EMPTY_PERSISTED_ARTICLES: PersistedNewsArticle[] = [];
@@ -75,11 +75,32 @@ function storyItemsSignature(items: PersistedNewsStoryItem[] | undefined): strin
   return items?.map((item) => `${item.id}:${item.publishedAt}`).join("|") ?? "";
 }
 
-export function usePersistedNewsArticles(key: string, articles: MarketNewsItem[]): MarketNewsItem[] {
+/**
+ * The last fetched articles for `key`, kept in pane state so the pane has
+ * something to show on restart before the feed answers.
+ *
+ * A `keyFamily` names a prefix under which the pane keys one entry per symbol
+ * it visits. Only the current member is kept: the feed cache already covers a
+ * revisit within the session, and the copy on disk is only ever read for the
+ * symbol the pane restarts on. Left alone, a ticker pane accumulated tens of
+ * kilobytes per symbol that every pane-state update then copied into the
+ * saved layout.
+ */
+export function usePersistedNewsArticles(
+  key: string,
+  articles: MarketNewsItem[],
+  options: { keyFamily?: string } = {},
+): MarketNewsItem[] {
   const [persistedArticles, setPersistedArticles] = usePluginPaneState<PersistedNewsArticle[]>(
     key,
     EMPTY_PERSISTED_ARTICLES,
   );
+  const pruneSiblings = usePrunePluginPaneState();
+  const { keyFamily } = options;
+  useEffect(() => {
+    if (!keyFamily) return;
+    pruneSiblings((candidate) => candidate !== key && candidate.startsWith(keyFamily));
+  }, [key, keyFamily, pruneSiblings]);
   const restoredArticles = useMemo(
     () => persistedArticles.map(restoreArticle).filter((article): article is MarketNewsItem => !!article),
     [persistedArticles],

package/src/plugins/builtin/news/wire/rss/feed-xml.ts

@@ -0,0 +1,104 @@
+import { decodeHtmlEntities } from "../../../../../utils/html-entities";
+
+export interface FeedElement {
+  name: string;
+  localName: string;
+  namespace: string;
+  namespaces: Record<string, string>;
+  attributes: Record<string, string>;
+  base: string;
+  content: (FeedElement | string)[];
+  innerStart: number;
+  innerEnd: number;
+}
+
+export function resolveFeedUrl(value: string, base: string): string {
+  if (!value.trim()) return "";
+  try { return new URL(value.trim(), base).href; } catch { return ""; }
+}
+
+// Read the structure of a syndication document without executing declarations or
+// resolving entities. Descendant source/content metadata must not impersonate
+// an entry's direct children. This is deliberately not a validating XML parser.
+export function parseFeedXml(xml: string, base: string): FeedElement | null {
+  const tokens = /<!DOCTYPE(?:[^<>"'\[]|"[^"]*"|'[^']*')*>|<!--[\s\S]*?-->|<!\[CDATA\[[\s\S]*?\]\]>|<\?[\s\S]*?\?>|<\/?[A-Za-z_][\w.:-]*(?:[^<>"']|"[^"]*"|'[^']*')*>|[^<]+/g;
+  const stack: FeedElement[] = [];
+  let root: FeedElement | null = null;
+  let offset = 0;
+  for (const match of xml.matchAll(tokens)) {
+    if (match.index !== offset) return null;
+    const token = match[0];
+    offset += token.length;
+    if (token.startsWith("<!--") || token.startsWith("<?") || token.startsWith("<!DOCTYPE")) continue;
+    if (token.startsWith("<![CDATA[")) {
+      if (!stack.length) return null;
+      stack.at(-1)!.content.push(token.slice(9, -3));
+      continue;
+    }
+    if (!token.startsWith("<")) {
+      if (stack.length) stack.at(-1)!.content.push(decodeHtmlEntities(token));
+      else if (token.trim()) return null;
+      continue;
+    }
+    if (token.startsWith("</")) {
+      const node = stack.pop();
+      if (!node || token.slice(2, -1).trim() !== node.name) return null;
+      node.innerEnd = match.index;
+      continue;
+    }
+    const opening = token.match(/^<([A-Za-z_][\w.:-]*)/)!;
+    const name = opening[1]!;
+    const selfClosing = token.endsWith("/>");
+    const rawAttributes = token.slice(opening[0].length, selfClosing ? -2 : -1);
+    const attributes: Record<string, string> = Object.create(null);
+    const attributePattern = /\s+([A-Za-z_][\w.:-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/gy;
+    let cursor = 0;
+    while (cursor < rawAttributes.length && rawAttributes.slice(cursor).trim()) {
+      attributePattern.lastIndex = cursor;
+      const attr = attributePattern.exec(rawAttributes);
+      if (!attr || Object.hasOwn(attributes, attr[1]!)) return null;
+      attributes[attr[1]!] = decodeHtmlEntities(attr[2] ?? attr[3]!);
+      cursor = attributePattern.lastIndex;
+    }
+    const parent = stack.at(-1);
+    const namespaces: Record<string, string> = { ...parent?.namespaces };
+    for (const [key, value] of Object.entries(attributes)) {
+      if (key === "xmlns") namespaces[""] = value;
+      else if (key.startsWith("xmlns:")) namespaces[key.slice(6)] = value;
+    }
+    const colon = name.indexOf(":");
+    const prefix = colon < 0 ? "" : name.slice(0, colon);
+    if (prefix && !namespaces[prefix]) return null;
+    const inheritedBase = parent?.base ?? base;
+    const node: FeedElement = {
+      name,
+      localName: colon < 0 ? name : name.slice(colon + 1),
+      namespace: namespaces[prefix] ?? "",
+      namespaces,
+      attributes,
+      base: attributes["xml:base"] != null
+        ? resolveFeedUrl(attributes["xml:base"], inheritedBase) || inheritedBase
+        : inheritedBase,
+      content: [],
+      innerStart: offset,
+      innerEnd: offset,
+    };
+    if (parent) parent.content.push(node);
+    else if (root) return null;
+    else root = node;
+    if (!selfClosing) stack.push(node);
+    if (stack.length > 128) return null;
+  }
+  return offset === xml.length && stack.length === 0 ? root : null;
+}
+
+export function feedChildren(node: FeedElement, name: string, namespace = node.namespace): FeedElement[] {
+  return node.content.filter((child): child is FeedElement => typeof child !== "string"
+    && child.localName === name && child.namespace === namespace);
+}
+
+export function feedText(node: FeedElement | undefined): string {
+  const content = (element: FeedElement): string => element.content
+    .map((part) => typeof part === "string" ? part : content(part)).join("");
+  return node ? content(node).trim() : "";
+}

package/src/plugins/builtin/news/wire/rss/parser.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { parseRssFeed, type RssFeedConfig } from "./parser";
+import { parseRssFeed, parseRssFeedDocument, type RssFeedConfig } from "./parser";
 
 const DEFAULT_CONFIG: RssFeedConfig = {
   id: "test-feed",
@@ -114,3 +114,65 @@ describe("parseRssFeed", () => {
     expect(items[1]!.categories).toContain("markets");
   });
 });
+
+test("Atom chooses direct alternate links with namespaces, bases, quotes and XML entities", () => {
+  const xml = `<a:feed xmlns:a="http://www.w3.org/2005/Atom" xml:base="https://example.com/research/">
+    <!-- <entry><title>Commented story</title></entry> -->
+    <a:entry xml:base='issuer/'>
+      <a:source><a:title>Wrong feed title</a:title><a:link href="wrong"/><a:id>wrong-id</a:id></a:source>
+      <a:title>Cash offer</a:title><a:id>urn:Case:42</a:id><a:updated>2026-09-12T13:00:00Z</a:updated>
+      <a:link rel="self" href="api"/><a:link rel="enclosure" href="audio.mp3"/>
+      <a:link rel="alternate" type="application/pdf" href="notice.pdf"/>
+      <a:link xml:base='../deals/' type='text/html' href='42?a=1&amp;b=2'/>
+    </a:entry></a:feed>`;
+  expect(parseRssFeedDocument(xml, DEFAULT_CONFIG)).toMatchObject([{
+    id: "atom:urn:Case:42", title: "Cash offer", url: "https://example.com/research/deals/42?a=1&b=2",
+  }]);
+  expect(parseRssFeed(xml.replace("urn:Case:42", "urn:case:42"), DEFAULT_CONFIG)[0]!.id)
+    .not.toBe(parseRssFeed(xml, DEFAULT_CONFIG)[0]!.id);
+});
+
+test("Atom correction identity survives title and URL changes and uses publisher update time", () => {
+  const xml = (title: string, url: string, time: string) => `<feed xmlns="http://www.w3.org/2005/Atom"><entry>
+    <id>urn:issuer:42</id><title>${title}</title><link href="${url}"/>
+    <published>2026-09-11T08:00:00Z</published><updated>${time}</updated></entry></feed>`;
+  const first = parseRssFeed(xml("Offer agreed", "https://example.com/deal", "2026-09-12T12:00:00Z"), DEFAULT_CONFIG)[0]!;
+  const next = parseRssFeed(xml("Offer withdrawn", "https://example.com/withdrawal", "2026-09-12T13:00:00Z"), DEFAULT_CONFIG)[0]!;
+  expect(next.id).toBe(first.id);
+  expect(next.publishedAt.toISOString()).toBe("2026-09-12T13:00:00.000Z");
+});
+
+test("Atom text, HTML, XHTML and CDATA retain readable text without nested fake stories", () => {
+  const xml = `<feed xmlns="http://www.w3.org/2005/Atom"><entry><title>Revenue &lt; $10m &amp; cash &gt; $2m</title>
+    <summary type="html">&lt;p&gt;Oil &amp;amp; gas&lt;/p&gt;</summary></entry>
+    <entry><title type="xhtml"><div xmlns="http://www.w3.org/1999/xhtml">Cash <b>offer</b> withdrawn</div></title>
+    <content><![CDATA[<entry><title>Literal content only</title></entry>]]></content></entry></feed>`;
+  const items = parseRssFeedDocument(xml, DEFAULT_CONFIG);
+  expect(items).toHaveLength(2);
+  expect(items[0]).toMatchObject({ title: "Revenue < $10m & cash > $2m", summary: "Oil & gas" });
+  expect(items[1]!.title).toBe("Cash offer withdrawn");
+});
+
+test("feed document failures differ from valid emptiness, and external DTDs are not resolved", () => {
+  expect(parseRssFeedDocument('<feed xmlns="http://www.w3.org/2005/Atom"/>', DEFAULT_CONFIG)).toEqual([]);
+  expect(parseRssFeedDocument('<rss><channel/></rss>', DEFAULT_CONFIG)).toEqual([]);
+  for (const xml of ["", "<html><body>Proxy error</body></html>", "<feed><entry><title>Truncated</title></feed>",
+    '<feed xmlns="urn:other"><entry><title>Foreign</title></entry></feed>']) {
+    expect(() => parseRssFeedDocument(xml, DEFAULT_CONFIG)).toThrow("Invalid or unsupported news feed");
+  }
+  expect(parseRssFeedDocument('<!DOCTYPE rss SYSTEM "https://example.invalid/rss.dtd">' + RSS2_FIXTURE.replace('<?xml version="1.0"?>', ''), DEFAULT_CONFIG)).toHaveLength(3);
+});
+
+test("RSS items with attributes and RDF RSS retain the previously readable article fields", () => {
+  expect(parseRssFeedDocument(RSS2_FIXTURE.replace('<item>', '<item xml:lang="en">'), DEFAULT_CONFIG)).toHaveLength(3);
+  const rdf = '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/"><channel rdf:about="https://example.com/feed"><title>Feed</title></channel><item rdf:about="https://example.com/item"><title>Issuer filing</title><link>https://example.com/item</link></item></rdf:RDF>';
+  expect(parseRssFeedDocument(rdf, DEFAULT_CONFIG)).toMatchObject([{ title: "Issuer filing", url: "https://example.com/item" }]);
+});
+
+test("RSS comment and CDATA markup cannot create additional stories or replace item metadata", () => {
+  const xml = `<rss><channel><!-- <item><title>Commented story</title></item> -->
+    <item><description><![CDATA[<item><title>Example markup</title></item>]]></description>
+      <title>Actual issuer update</title><link>https://example.com/update</link></item></channel></rss>`;
+  expect(parseRssFeedDocument(xml, DEFAULT_CONFIG)).toMatchObject([{ title: "Actual issuer update", url: "https://example.com/update" }]);
+  expect(parseRssFeedDocument(xml, DEFAULT_CONFIG)).toHaveLength(1);
+});