@@ -129,3 +129,87 @@ func TestReplaceJavascriptLinksLeavesNormalAnchors(t *testing.T) {
 		t.Fatalf("normal anchor href should be preserved, got: %s", article.Content)
 	}
 }
+
+// TestFixLazyImagesDropsTinyBase64Placeholder exercises the first pass of
+// fixLazyImages: when src is a small (< 133 chars beyond prefix) base64
+// data URL AND another attribute on the same element looks like an image
+// URL, the placeholder src is dropped so pass 2 can promote the data-*
+// URL into src.
+func TestFixLazyImagesDropsTinyBase64Placeholder(t *testing.T) {
+	html := `<html><body><article>
+<p>This article body has enough useful text to clear the extractor length checks while we exercise the base64 placeholder removal branch and verify the real image URL stored in a sibling data attribute is promoted to src.</p>
+<p>A second paragraph keeps the candidate substantial during conditional cleanup so the recovered image survives long enough for assertions on the final HTML output.</p>
+<img src="data:image/gif;base64,R0lGODlhAQABAAAAACw=" data-src="https://cdn.example.com/real-photo.jpg">
+</article></body></html>`
+
+	article, err := FromReader(strings.NewReader(html), "", nil)
+	if err != nil {
+		t.Fatalf("FromReader: %v", err)
+	}
+	if strings.Contains(article.Content, "data:image/gif;base64") {
+		t.Fatalf("tiny base64 placeholder should be removed, got: %s", article.Content)
+	}
+	if !strings.Contains(article.Content, `src="https://cdn.example.com/real-photo.jpg"`) {
+		t.Fatalf("expected data-src to be promoted to src, got: %s", article.Content)
+	}
+}
+
+// TestFixLazyImagesPreservesSVGDataURL ensures SVG base64 data URLs are
+// kept as-is — they may legitimately be the real image rather than a
+// placeholder.
+func TestFixLazyImagesPreservesSVGDataURL(t *testing.T) {
+	html := `<html><body><article>
+<p>This article body has enough useful text to clear the extractor length checks while we verify SVG data URLs are preserved by the base64 placeholder branch even when other image-shaped attributes are present on the same element.</p>
+<p>A second paragraph keeps the candidate substantial during conditional cleanup so the SVG image survives long enough for assertions to inspect the final HTML output.</p>
+<img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciLz4=" data-src="https://cdn.example.com/other.jpg">
+</article></body></html>`
+
+	article, err := FromReader(strings.NewReader(html), "", nil)
+	if err != nil {
+		t.Fatalf("FromReader: %v", err)
+	}
+	if !strings.Contains(article.Content, "data:image/svg+xml") {
+		t.Fatalf("SVG data URL must be preserved, got: %s", article.Content)
+	}
+}
+
+// TestFixLazyImagesPreservesLargeBase64 confirms large base64 data URLs
+// (≥ 133 chars beyond the prefix) are NOT removed even when a sibling
+// data-* attribute carries an image URL — the heuristic only targets the
+// tiny placeholders typical of lazy-loading templates.
+func TestFixLazyImagesPreservesLargeBase64(t *testing.T) {
+	// 200 chars of base64 payload, well above the 133-char threshold.
+	largePayload := strings.Repeat("A", 200)
+	html := `<html><body><article>
+<p>This article body has enough useful text to clear the extractor length checks while we verify a large base64 data URL is left alone by the placeholder removal heuristic, since it is presumably the real image.</p>
+<p>A second paragraph keeps the candidate substantial during conditional cleanup so the image survives long enough for assertions to inspect the final HTML output verifying preservation.</p>
+<img src="data:image/png;base64,` + largePayload + `" data-src="https://cdn.example.com/other.jpg">
+</article></body></html>`
+
+	article, err := FromReader(strings.NewReader(html), "", nil)
+	if err != nil {
+		t.Fatalf("FromReader: %v", err)
+	}
+	if !strings.Contains(article.Content, "data:image/png;base64") {
+		t.Fatalf("large base64 data URL must be preserved, got: %s", article.Content)
+	}
+}
+
+// TestFixLazyImagesFigureSynthesizesImg verifies the <figure> branch:
+// when a figure has no <img>/<picture> child but carries a data-* image
+// URL, the recovery pass synthesizes a child <img> with src populated.
+func TestFixLazyImagesFigureSynthesizesImg(t *testing.T) {
+	html := `<html><body><article>
+<p>This article body has enough useful text to clear the extractor length checks while we exercise the figure recovery branch that synthesizes a child img element when a data attribute carries a single image URL.</p>
+<p>A second paragraph keeps the candidate substantial during conditional cleanup so the synthesized image survives long enough for assertions to inspect the final HTML output.</p>
+<figure data-src="https://cdn.example.com/synthesized.jpg"><figcaption>caption text</figcaption></figure>
+</article></body></html>`
+
+	article, err := FromReader(strings.NewReader(html), "", nil)
+	if err != nil {
+		t.Fatalf("FromReader: %v", err)
+	}
+	if !strings.Contains(article.Content, `src="https://cdn.example.com/synthesized.jpg"`) {
+		t.Fatalf("expected synthesized <img> with src populated, got: %s", article.Content)
+	}
+}
@@ -0,0 +1,171 @@
+package readability
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/PuerkitoBio/goquery"
+)
+
+// TestPreservableMediaCountAudioWithSrc covers the <audio src=…> branch:
+// an audio element with a source URL counts as preservable media even
+// when no other attribute matches the video allow-list.
+func TestPreservableMediaCountAudioWithSrc(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><audio src="https://example.com/podcast.mp3"></audio></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := preservableMediaCount(doc.Find("div"), cfg)
+	if got != 1 {
+		t.Fatalf("preservableMediaCount = %d, want 1 (audio with src)", got)
+	}
+}
+
+// TestPreservableMediaCountAudioWithoutSrc verifies the audio branch
+// requires a non-empty src; bare <audio> tags do not count.
+func TestPreservableMediaCountAudioWithoutSrc(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(`<div><audio></audio></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := preservableMediaCount(doc.Find("div"), cfg)
+	if got != 0 {
+		t.Fatalf("preservableMediaCount = %d, want 0 (audio without src)", got)
+	}
+}
+
+// TestPreservableMediaCountVideoBlobSrc covers the video blob: branch:
+// player elements often surface their bound stream as a blob: URL, which
+// must be treated as legitimate media even though the URL itself is
+// useless to readers.
+func TestPreservableMediaCountVideoBlobSrc(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><video src="blob:https://example.com/abc-123"></video></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := preservableMediaCount(doc.Find("div"), cfg)
+	if got != 1 {
+		t.Fatalf("preservableMediaCount = %d, want 1 (video blob:)", got)
+	}
+}
+
+// TestPreservableMediaCountVideoDataVideoID covers the data-video-id
+// branch: many CMS templates render an empty <video> shell that gets
+// hydrated by JS using data-video-id; this must still count as media.
+func TestPreservableMediaCountVideoDataVideoID(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><video data-video-id="abc123"></video></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := preservableMediaCount(doc.Find("div"), cfg)
+	if got != 1 {
+		t.Fatalf("preservableMediaCount = %d, want 1 (video data-video-id)", got)
+	}
+}
+
+// TestPreservableMediaCountIframeAllowed covers the generic allow-list
+// branch: an iframe whose src matches cfg.videoAllowed counts as
+// preservable media.
+func TestPreservableMediaCountIframeAllowed(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><iframe src="https://www.youtube.com/embed/abc"></iframe></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := preservableMediaCount(doc.Find("div"), cfg)
+	if got != 1 {
+		t.Fatalf("preservableMediaCount = %d, want 1 (iframe in allow-list)", got)
+	}
+}
+
+// TestPreservableMediaCountIframeUnrecognized verifies that iframes
+// whose attributes do NOT match the allow-list are not counted as
+// preservable media — they fall through to removableEmbedCount instead.
+func TestPreservableMediaCountIframeUnrecognized(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><iframe src="https://ads.example.com/banner"></iframe></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := preservableMediaCount(doc.Find("div"), cfg)
+	if got != 0 {
+		t.Fatalf("preservableMediaCount = %d, want 0 (unrecognized iframe)", got)
+	}
+}
+
+// TestRemovableEmbedCountUnrecognized confirms that an iframe outside
+// the allow-list bumps removable embed count, which conditional cleanup
+// uses to push the candidate toward removal.
+func TestRemovableEmbedCountUnrecognized(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><iframe src="https://ads.example.com/banner"></iframe></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := removableEmbedCount(doc.Find("div"), cfg)
+	if got != 1 {
+		t.Fatalf("removableEmbedCount = %d, want 1 (unrecognized iframe)", got)
+	}
+}
+
+// TestRemovableEmbedCountAllowedAttribute confirms that an iframe whose
+// attribute matches the allow-list is NOT counted — preservableMediaCount
+// will pick it up instead.
+func TestRemovableEmbedCountAllowedAttribute(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><iframe src="https://www.youtube.com/embed/abc"></iframe></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := removableEmbedCount(doc.Find("div"), cfg)
+	if got != 0 {
+		t.Fatalf("removableEmbedCount = %d, want 0 (iframe in allow-list)", got)
+	}
+}
+
+// TestRemovableEmbedCountAllowedInnerHTML covers the inner-HTML allow
+// path: an embed/object that holds the recognized URL inside a child
+// node rather than on its own attributes (e.g. <object><param value=…/>
+// </object>) must also be considered allowed.
+func TestRemovableEmbedCountAllowedInnerHTML(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div><object><param name="movie" value="https://www.youtube.com/embed/abc"/></object></div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := removableEmbedCount(doc.Find("div"), cfg)
+	if got != 0 {
+		t.Fatalf("removableEmbedCount = %d, want 0 (allowed via inner HTML)", got)
+	}
+}
+
+// TestRemovableEmbedCountObjectAndEmbed covers the multi-element path:
+// object and embed tags are inspected alongside iframe.
+func TestRemovableEmbedCountObjectAndEmbed(t *testing.T) {
+	doc, err := goquery.NewDocumentFromReader(strings.NewReader(
+		`<div>
+			<object data="https://ads.example.com/x"></object>
+			<embed src="https://ads.example.com/y">
+			<iframe src="https://ads.example.com/z"></iframe>
+		</div>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	cfg := defaultParserConfig()
+	got := removableEmbedCount(doc.Find("div"), cfg)
+	if got != 3 {
+		t.Fatalf("removableEmbedCount = %d, want 3 (three unrecognized embeds)", got)
+	}
+}