diff --git a/CHANGELOG.md b/CHANGELOG.md
index 07f7992..2eee696 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,12 @@ All notable changes to kage are recorded here. The format follows
 
 ## [Unreleased]
 
+### Fixed
+
+- Saved pages no longer re-root relative URLs against the live origin via a leftover `<base href>`, and active content that escaped the script stripper is neutralized: `iframe` `srcdoc` and `data:text/html` sources, live remote frames, and HTML/SVG `object`/`embed` carriers.
+- Relative links on pages that redirected are resolved against the browser's final URL (and any document `<base href>`), while the page is still written under the discovered URL so existing offline links keep working.
+- Non-UTF-8 `<meta charset>` / Content-Type charset declarations are rewritten to `utf-8`, since kage always serialises pages as UTF-8 ([#16](https://github.com/tamnd/kage/issues/16)).
+
 ## [0.3.9] - 2026-07-08
 
 ### Fixed
diff --git a/README.md b/README.md
index 76195d2..fa478e9 100644
--- a/README.md
+++ b/README.md
@@ -259,7 +259,7 @@ cmd/kage/   thin main: pins the main thread, then hands off to cli.Execute
 cli/        the cobra command tree and flag wiring
 clone/      the crawl: frontier, render workers, asset workers, resume state
 browser/    headless Chrome control and DOM snapshotting
-sanitize/   strip scripts, handlers, and javascript: URLs from the DOM
+sanitize/   strip scripts, handlers, active frames, and javascript: URLs
 asset/      download and localise CSS, images, and fonts
 urlx/       the deterministic URL-to-path mapping
 zim/        a pure-Go ZIM reader and writer
diff --git a/clone/cloner.go b/clone/cloner.go
index 2940e77..4c507b6 100644
--- a/clone/cloner.go
+++ b/clone/cloner.go
@@ -19,6 +19,7 @@ import (
 	"github.com/tamnd/kage/sanitize"
 	"github.com/tamnd/kage/urlx"
 	"golang.org/x/net/html"
+	"golang.org/x/net/html/atom"
 	"golang.org/x/time/rate"
 )
 
@@ -302,6 +303,13 @@ func (c *Cloner) processPage(ctx context.Context, j pageItem) {
 		return
 	}
 
+	// Resolve references against the post-redirect URL (and any <base href>),
+	// but keep writing the page under the discovered URL so existing offline
+	// links that pointed at /old still resolve. Cross-host redirects leave the
+	// resolve base as the final location for relative refs; scope checks still
+	// use that absolute URL.
+	resolveBase := pageResolveBase(j.u, res.FinalURL, root)
+
 	localFile := urlx.LocalPath(c.seedHost, j.u, urlx.Page, c.cfg.Reserved)
 	fileDir := urlx.Dir(localFile)
 
@@ -324,7 +332,7 @@ func (c *Cloner) processPage(ctx context.Context, j pageItem) {
 		}
 	}
 
-	asset.RewriteHTML(root, j.u, sink)
+	asset.RewriteHTML(root, resolveBase, sink)
 	sanitize.CleanTree(root, sanitize.Options{
 		KeepNoscript:   c.cfg.KeepNoscript,
 		MobileReadable: c.cfg.MobileReadable,
@@ -354,6 +362,55 @@ func (c *Cloner) waitForCrawlDelay(ctx context.Context) bool {
 	return c.crawlLimiter.Wait(ctx) == nil
 }
 
+// pageResolveBase picks the URL against which relative references on a rendered
+// page should resolve. Preference order:
+//  1. A document <base href> (the live page's own base);
+//  2. The browser's final URL after redirects;
+//  3. The URL that was enqueued.
+//
+// The page is still written under the enqueued URL so offline links discovered
+// as /old keep working when the server redirected /old → /new.
+func pageResolveBase(enqueued *url.URL, finalURL string, root *html.Node) *url.URL {
+	base := enqueued
+	if finalURL != "" {
+		if u, err := url.Parse(finalURL); err == nil && u.Scheme != "" && u.Host != "" {
+			// Drop fragment; keep query/path as the browser shows them.
+			u.Fragment = ""
+			base = u
+		}
+	}
+	if href := documentBaseHref(root); href != "" {
+		if u, err := urlx.Normalize(base, href); err == nil {
+			return u
+		}
+	}
+	return base
+}
+
+// documentBaseHref returns the first <base href> in document order, or "".
+func documentBaseHref(root *html.Node) string {
+	var found string
+	var walk func(*html.Node)
+	walk = func(n *html.Node) {
+		if found != "" || n == nil {
+			return
+		}
+		if n.Type == html.ElementNode && n.DataAtom == atom.Base {
+			for _, a := range n.Attr {
+				if strings.EqualFold(a.Key, "href") && strings.TrimSpace(a.Val) != "" {
+					found = strings.TrimSpace(a.Val)
+					return
+				}
+			}
+		}
+		for c := n.FirstChild; c != nil && found == ""; c = c.NextSibling {
+			walk(c)
+		}
+	}
+	walk(root)
+	return found
+}
+
 // processAsset downloads one asset, rewriting CSS references on the way, and
 // writes it to its deterministic local path.
 func (c *Cloner) processAsset(ctx context.Context, j assetItem) {
diff --git a/clone/resolve_test.go b/clone/resolve_test.go
new file mode 100644
index 0000000..42d59dc
--- /dev/null
+++ b/clone/resolve_test.go
@@ -0,0 +1,45 @@
+package clone
+
+import (
+	"net/url"
+	"strings"
+	"testing"
+
+	"golang.org/x/net/html"
+)
+
+func TestPageResolveBaseUsesFinalURL(t *testing.T) {
+	enqueued, _ := url.Parse("https://ex.com/old")
+	root, err := html.Parse(strings.NewReader(`<html><head></head><body><a href="next">n</a></body></html>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	base := pageResolveBase(enqueued, "https://ex.com/new/", root)
+	if base.String() != "https://ex.com/new/" {
+		t.Fatalf("resolve base = %q, want final URL", base)
+	}
+}
+
+func TestPageResolveBasePrefersDocumentBase(t *testing.T) {
+	enqueued, _ := url.Parse("https://ex.com/page")
+	root, err := html.Parse(strings.NewReader(
+		`<html><head><base href="https://ex.com/dir/"></head><body></body></html>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	base := pageResolveBase(enqueued, "https://ex.com/page", root)
+	if base.String() != "https://ex.com/dir/" {
+		t.Fatalf("resolve base = %q, want document <base>", base)
+	}
+}
+
+func TestDocumentBaseHref(t *testing.T) {
+	root, err := html.Parse(strings.NewReader(
+		`<html><head><base href="/subdir/"><base href="https://ignored.example/"></head></html>`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := documentBaseHref(root); got != "/subdir/" {
+		t.Fatalf("documentBaseHref = %q, want first base", got)
+	}
+}
diff --git a/docs/content/reference/release-notes.md b/docs/content/reference/release-notes.md
index a26b83a..62e01f1 100644
--- a/docs/content/reference/release-notes.md
+++ b/docs/content/reference/release-notes.md
@@ -6,6 +6,11 @@ weight: 40
 
 The authoritative, commit-level history lives in [`CHANGELOG.md`](https://github.com/tamnd/kage/blob/main/CHANGELOG.md) and on the [releases page](https://github.com/tamnd/kage/releases). This page summarises each version.
 
+## Unreleased
+
+- **Inert-snapshot gaps closed.** `<base href>`, `iframe` `srcdoc` / `data:text/html`, live remote frames, and HTML/SVG `object`/`embed` no longer reintroduce live or executable content.
+- **Redirects resolve correctly.** Relative links use the post-redirect URL and any document `<base href>`, and non-UTF-8 charset metas are rewritten to UTF-8.
+
 ## v0.3.9
 
 A fix for the antivirus warning some Windows users hit when installing kage.
diff --git a/sanitize/sanitize.go b/sanitize/sanitize.go
index b01333f..940346e 100644
--- a/sanitize/sanitize.go
+++ b/sanitize/sanitize.go
@@ -2,10 +2,12 @@
 // the saved page is inert: a photograph, not a program.
 //
 // It parses with golang.org/x/net/html, walks the tree, and deletes scripts,
-// event handlers, javascript: URLs, downlevel IE conditional comments (which
-// can smuggle a <script> past an element-only walk), and the dead
-// preconnect/preload hints that mean nothing offline — while leaving styles,
-// images, fonts, forms, and all semantic markup untouched so the layout
+// event handlers, javascript: URLs, active iframe/object/embed carriers
+// (srcdoc, data:text/html, live remote frames), document <base href> tags that
+// would re-root relative URLs against the live origin, downlevel IE conditional
+// comments (which can smuggle a <script> past an element-only walk), and the
+// dead preconnect/preload hints that mean nothing offline — while leaving
+// styles, images, fonts, forms, and all semantic markup untouched so the layout
 // survives intact.
 package sanitize
 
@@ -49,7 +51,9 @@ type Report struct {
 	MetaRefreshRemoved  int
 	DeadLinksRemoved    int
 	CondCommentsRemoved int
-	CharsetAdded        bool
+	ActiveFramesRemoved int
+	BaseTagsRemoved     int
+	CharsetFixed        bool // true when a charset meta was inserted or rewritten to utf-8
 }
 
 // jsURLAttrs are attributes whose value may be a javascript: URL.
@@ -79,7 +83,7 @@ func Strip(doc []byte, opts Options) ([]byte, Report, error) {
 func CleanTree(root *html.Node, opts Options) Report {
 	var rep Report
 	clean(root, opts, &rep)
-	rep.CharsetAdded = ensureCharset(root)
+	rep.CharsetFixed = ensureCharset(root)
 	if opts.MobileReadable {
 		ensureViewport(root)
 		injectMobileCSS(root)
@@ -134,6 +138,24 @@ func clean(n *html.Node, opts Options, rep *Report) {
 					rep.DeadLinksRemoved++
 					continue
 				}
+			case atom.Base:
+				// A live <base href> re-roots every relative URL against the live
+				// origin after the page is saved, undoing mirror-relative rewrites.
+				// Drop the element so the offline document keeps the rewritten paths.
+				n.RemoveChild(c)
+				rep.BaseTagsRemoved++
+				continue
+			case atom.Iframe, atom.Frame:
+				neutralizeActiveFrame(c, rep)
+			case atom.Object, atom.Embed:
+				// Same-domain HTML/SVG served through object/embed executes
+				// scripts offline when localised as a raw asset. Drop active
+				// carriers (HTML, SVG, or anything with a script-bearing data
+				// URL) so the inert-snapshot promise holds.
+				if neutralizePlugin(c, rep) {
+					n.RemoveChild(c)
+					continue
+				}
 			}
 			stripHandlers(c, rep)
 			neutralizeJSURLs(c, rep)
@@ -142,6 +164,147 @@ func clean(n *html.Node, opts Options, rep *Report) {
 	}
 }
 
+// neutralizeActiveFrame strips iframe/frame carriers that would still run code
+// offline: srcdoc markup (not walked by the element sanitizer), data:text/html
+// URLs, remote http(s) sources left pointing at the live web, and localised
+// raw assets that execute script inside a frame (.svg, .xml). The element
+// itself stays behind as an empty, inert shell.
+func neutralizeActiveFrame(n *html.Node, rep *Report) {
+	// srcdoc holds raw HTML that never enters the element walk — drop the
+	// attribute so nothing executable remains.
+	if attr(n, "srcdoc") != "" {
+		removeAttr(n, "srcdoc")
+		rep.ActiveFramesRemoved++
+	}
+	src := strings.TrimSpace(attr(n, "src"))
+	if src == "" {
+		return
+	}
+	low := strings.ToLower(src)
+	switch {
+	case strings.HasPrefix(low, "javascript:"):
+		removeAttr(n, "src")
+		rep.JSURLsNeutralized++
+	case strings.HasPrefix(low, "data:"):
+		// data:text/html, data:image/svg+xml, etc. can carry scripts.
+		if isActiveDataURL(low) {
+			removeAttr(n, "src")
+			rep.ActiveFramesRemoved++
+		}
+	case strings.HasPrefix(low, "http://"), strings.HasPrefix(low, "https://"), strings.HasPrefix(low, "//"):
+		// An external live frame would phone home and run its own JS. Drop the
+		// src so the offline page cannot embed active third-party content.
+		// Same-host frames are rewritten to local paths by the asset layer
+		// before sanitize runs, so by the time we see an absolute URL here it
+		// is either external or was left remote intentionally.
+		removeAttr(n, "src")
+		rep.ActiveFramesRemoved++
+	default:
+		// A relative src is a localised file. Same-host pages (…/index.html)
+		// were rendered and sanitized, so they stay; but .svg/.xml took the raw
+		// asset path (never sanitized) and still run script inside a frame —
+		// drop those, mirroring the object/embed carrier policy.
+		path := low
+		if i := strings.IndexAny(path, "?#"); i >= 0 {
+			path = path[:i]
+		}
+		if strings.HasSuffix(path, ".svg") || strings.HasSuffix(path, ".xml") {
+			removeAttr(n, "src")
+			rep.ActiveFramesRemoved++
+		}
+	}
+}
+
+// neutralizePlugin reports whether an object/embed should be removed entirely
+// because its data/src would execute offline (HTML, SVG, active data URLs, or a
+// still-live remote URL that can run its own code).
+func neutralizePlugin(n *html.Node, rep *Report) bool {
+	ref := strings.TrimSpace(attr(n, "data"))
+	if ref == "" {
+		ref = strings.TrimSpace(attr(n, "src"))
+	}
+	if ref == "" {
+		return false
+	}
+	low := strings.ToLower(ref)
+	if strings.HasPrefix(low, "javascript:") {
+		rep.JSURLsNeutralized++
+		rep.ActiveFramesRemoved++
+		return true
+	}
+	if strings.HasPrefix(low, "data:") && isActiveDataURL(low) {
+		rep.ActiveFramesRemoved++
+		return true
+	}
+	// A remote object/embed left on the live web can run scripts when the offline
+	// page is opened online. Drop it. Same-host resources have already been
+	// rewritten to relative local paths by the asset layer.
+	if strings.HasPrefix(low, "http://") || strings.HasPrefix(low, "https://") || strings.HasPrefix(low, "//") {
+		rep.ActiveFramesRemoved++
+		return true
+	}
+	// Extension-based: localised .html/.htm/.svg/.xhtml through object/embed
+	// reintroduce scripts. MIME type attributes that declare HTML/SVG too.
+	typeAttr := strings.ToLower(attr(n, "type"))
+	if strings.Contains(typeAttr, "html") || strings.Contains(typeAttr, "svg") ||
+		strings.Contains(typeAttr, "xml") {
+		rep.ActiveFramesRemoved++
+		return true
+	}
+	// Strip query/fragment for extension check.
+	path := low
+	if i := strings.IndexAny(path, "?#"); i >= 0 {
+		path = path[:i]
+	}
+	for _, ext := range []string{".html", ".htm", ".xhtml", ".svg", ".xml"} {
+		if strings.HasSuffix(path, ext) {
+			rep.ActiveFramesRemoved++
+			return true
+		}
+	}
+	return false
+}
+
+// isActiveDataURL reports whether a data: URL can carry executable markup.
+func isActiveDataURL(low string) bool {
+	// low is already lowercased.
+	if !strings.HasPrefix(low, "data:") {
+		return false
+	}
+	// Only the mediatype token before the first comma decides; the payload
+	// (base64 or percent-encoded text) may contain these substrings by chance.
+	mime := low[len("data:"):]
+	if i := strings.IndexByte(mime, ','); i >= 0 {
+		mime = mime[:i]
+	}
+	// data:text/html,...  data:image/svg+xml,...  data:application/xhtml+xml,...
+	return strings.Contains(mime, "text/html") ||
+		strings.Contains(mime, "image/svg") ||
+		strings.Contains(mime, "xhtml") ||
+		strings.Contains(mime, "xml")
+}
+
+func setAttr(n *html.Node, key, val string) {
+	for i := range n.Attr {
+		if strings.EqualFold(n.Attr[i].Key, key) {
+			n.Attr[i].Val = val
+			return
+		}
+	}
+	n.Attr = append(n.Attr, html.Attribute{Key: key, Val: val})
+}
+
+func removeAttr(n *html.Node, key string) {
+	kept := n.Attr[:0]
+	for _, a := range n.Attr {
+		if strings.EqualFold(a.Key, key) {
+			continue
+		}
+		kept = append(kept, a)
+	}
+	n.Attr = kept
+}
+
 // stripHandlers removes every on* event-handler attribute from n.
 func stripHandlers(n *html.Node, rep *Report) {
 	kept := n.Attr[:0]
@@ -241,22 +404,19 @@ func unwrapNoscript(parent, ns *html.Node) {
 	parent.RemoveChild(ns)
 }
 
-// ensureCharset guarantees the document declares UTF-8, inserting a
-// <meta charset="utf-8"> at the top of <head> when none is present, and reports
-// whether it added one. kage renders every saved page as UTF-8, but a source
-// that set its charset only in the HTTP Content-Type header, with no <meta>
-// charset in the markup, loses that signal once the page is a standalone file.
-// A reader then serving the bytes without a charset falls back to its locale
-// encoding and mojibakes every multibyte character (curly quotes, dashes, a
-// non-breaking space). Declaring the charset in the markup makes the page
-// self-describing in any reader, kage's own viewer and Kiwix alike.
+// ensureCharset guarantees the document declares UTF-8. kage always serialises
+// pages as UTF-8, so a source that advertised ISO-8859-1 (or any other charset)
+// only in a <meta> would lie about the on-disk bytes and mojibake in a reader
+// (issue #16). Missing declarations are inserted; non-UTF-8 declarations are
+// rewritten. Returns true when the document was changed.
 func ensureCharset(root *html.Node) bool {
 	head := findElement(root, atom.Head)
 	if head == nil {
 		return false
 	}
-	if hasCharsetMeta(head) {
-		return false
+	found, changed := fixCharsetMetas(head)
+	if found {
+		return changed
 	}
 	meta := &html.Node{
 		Type:     html.ElementNode,
@@ -270,23 +430,62 @@ func ensureCharset(root *html.Node) bool {
 	return true
 }
 
-// hasCharsetMeta reports whether head already declares a character encoding,
-// either as <meta charset="..."> or the older <meta http-equiv="Content-Type"
-// content="...; charset=...">.
-func hasCharsetMeta(head *html.Node) bool {
+// fixCharsetMetas rewrites existing charset declarations to utf-8. found is
+// true when a declaration was already present (so the caller should not insert
+// another); changed is true when a non-utf-8 value was rewritten in place.
+func fixCharsetMetas(head *html.Node) (found, changed bool) {
 	for c := head.FirstChild; c != nil; c = c.NextSibling {
 		if c.Type != html.ElementNode || c.DataAtom != atom.Meta {
 			continue
 		}
-		if attr(c, "charset") != "" {
-			return true
+		if ch := attr(c, "charset"); ch != "" {
+			found = true
+			if !strings.EqualFold(ch, "utf-8") {
+				setAttr(c, "charset", "utf-8")
+				changed = true
+			}
+			continue
 		}
-		if strings.EqualFold(attr(c, "http-equiv"), "content-type") &&
-			strings.Contains(strings.ToLower(attr(c, "content")), "charset=") {
-			return true
+		if strings.EqualFold(attr(c, "http-equiv"), "content-type") {
+			content := attr(c, "content")
+			low := strings.ToLower(content)
+			if strings.Contains(low, "charset=") {
+				found = true
+				if !strings.Contains(low, "charset=utf-8") {
+					setAttr(c, "content", rewriteContentTypeCharset(content))
+					changed = true
+				}
+			}
 		}
 	}
-	return false
+	return found, changed
+}
+
+// rewriteContentTypeCharset forces charset=utf-8 inside a Content-Type content
+// value, preserving any other parameters.
+func rewriteContentTypeCharset(content string) string {
+	parts := strings.Split(content, ";")
+	out := make([]string, 0, len(parts))
+	saw := false
+	for i, p := range parts {
+		p = strings.TrimSpace(p)
+		if i == 0 {
+			out = append(out, p)
+			continue
+		}
+		if strings.HasPrefix(strings.ToLower(p), "charset=") {
+			out = append(out, "charset=utf-8")
+			saw = true
+			continue
+		}
+		if p != "" {
+			out = append(out, p)
+		}
+	}
+	if !saw {
+		out = append(out, "charset=utf-8")
+	}
+	return strings.Join(out, "; ")
 }
 
 // findElement returns the first element node of the given atom in document
diff --git a/sanitize/sanitize_test.go b/sanitize/sanitize_test.go
index b0e04d0..70421a1 100644
--- a/sanitize/sanitize_test.go
+++ b/sanitize/sanitize_test.go
@@ -177,8 +177,8 @@ func TestCharsetAddedWhenMissing(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	if !rep.CharsetAdded {
-		t.Error("CharsetAdded = false, want true")
+	if !rep.CharsetFixed {
+		t.Error("CharsetFixed = false, want true")
 	}
 	s := string(out)
 	if !strings.Contains(strings.ToLower(s), `<meta charset="utf-8"/>`) {
@@ -266,21 +266,123 @@ func TestMobileReadableSkipsExistingViewport(t *testing.T) {
 }
 
 func TestCharsetNotDuplicated(t *testing.T) {
-	// A page that already declares a charset, in either form, is left alone.
-	cases := []string{
-		`<html><head><meta charset="utf-8"><title>x</title></head><body></body></html>`,
-		`<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>x</title></head><body></body></html>`,
-	}
-	for _, in := range cases {
-		out, rep, err := Strip([]byte(in), Options{})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if rep.CharsetAdded {
-			t.Errorf("CharsetAdded = true for a page that already declares one:\n%s", in)
-		}
-		if n := strings.Count(strings.ToLower(string(out)), "charset"); n != 1 {
-			t.Errorf("charset count = %d, want 1:\n%s", n, out)
-		}
+	// A page that already declares utf-8 is left alone.
+	in := `<html><head><meta charset="utf-8"><title>x</title></head><body></body></html>`
+	out, rep, err := Strip([]byte(in), Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if rep.CharsetFixed {
+		t.Error("CharsetFixed = true for a page that already declares utf-8")
+	}
+	if n := strings.Count(strings.ToLower(string(out)), "charset"); n != 1 {
+		t.Errorf("charset count = %d, want 1:\n%s", n, out)
+	}
+}
+
+func TestCharsetRewritesNonUTF8(t *testing.T) {
+	// Output is always UTF-8; a stale ISO-8859-1 declaration must be rewritten
+	// so a reader does not mojibake the file (issue #16).
+	in := `<html><head><meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"><title>x</title></head><body></body></html>`
+	out, rep, err := Strip([]byte(in), Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !rep.CharsetFixed {
+		t.Error("CharsetFixed = false, want true")
+	}
+	s := strings.ToLower(string(out))
+	if strings.Contains(s, "iso-8859-1") {
+		t.Errorf("ISO-8859-1 declaration survived:\n%s", out)
+	}
+	if !strings.Contains(s, "charset=utf-8") {
+		t.Errorf("expected charset=utf-8 rewrite:\n%s", out)
+	}
+}
+
+func TestActiveContentEscapesRemoved(t *testing.T) {
+	in := `<!doctype html><html><head><base href="https://evil.example/"></head><body>
+<iframe srcdoc="<script>alert(1)</script>"></iframe>
+<iframe src="data:text/html,<script>alert(1)</script>"></iframe>
+<iframe src="https://tracker.example/frame"></iframe>
+<object data="/widget.html" type="text/html"></object>
+<embed src="https://cdn.example/player.html">
+<object data="/logo.png" type="image/png"></object>
+</body></html>`
+	out, rep, err := Strip([]byte(in), Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	if strings.Contains(s, "<base") {
+		t.Error("<base> survived")
+	}
+	if strings.Contains(s, "srcdoc") {
+		t.Error("srcdoc survived")
+	}
+	if strings.Contains(strings.ToLower(s), "data:text/html") {
+		t.Error("data:text/html iframe survived")
+	}
+	if strings.Contains(s, "tracker.example") {
+		t.Error("external iframe src survived")
+	}
+	if strings.Contains(s, "widget.html") || strings.Contains(s, "player.html") {
+		t.Error("HTML object/embed survived")
+	}
+	// A non-script image object must survive.
+	if !strings.Contains(s, "logo.png") {
+		t.Error("image object should survive")
+	}
+	if rep.BaseTagsRemoved < 1 {
+		t.Errorf("BaseTagsRemoved = %d, want >= 1", rep.BaseTagsRemoved)
+	}
+	if rep.ActiveFramesRemoved < 1 {
+		t.Errorf("ActiveFramesRemoved = %d, want >= 1", rep.ActiveFramesRemoved)
+	}
+}
+
+func TestLocalisedSVGFrameNeutralized(t *testing.T) {
+	// A same-host SVG takes the raw asset path — downloaded, never sanitized —
+	// yet a frame pointing at the localised copy would run its scripts offline.
+	in := `<html><head></head><body><iframe src="../assets/ex.com/img/icon.svg"></iframe></body></html>`
+	out, rep, err := Strip([]byte(in), Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(string(out), "icon.svg") {
+		t.Errorf("localised .svg frame src survived:\n%s", out)
+	}
+	if rep.ActiveFramesRemoved < 1 {
+		t.Errorf("ActiveFramesRemoved = %d, want >= 1", rep.ActiveFramesRemoved)
+	}
+}
+
+func TestInertDataImageFrameKept(t *testing.T) {
+	// Only the mediatype token decides: a base64 payload that happens to
+	// contain the text "xml" must not strip an inert data:image iframe.
+	in := `<html><head></head><body><iframe src="data:image/png;base64,AAAAxmlBBBB"></iframe></body></html>`
+	out, _, err := Strip([]byte(in), Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(string(out), "data:image/png") {
+		t.Errorf("inert data:image/png frame lost its src:\n%s", out)
+	}
+}
+
+func TestLocalisedInertFramesKept(t *testing.T) {
+	// Same-host frames localised by the rewrite pipeline stay: an image asset
+	// (inert in a frame) and a rendered, sanitized page.
+	in := `<html><head></head><body><iframe src="../assets/ex.com/img/logo.png"></iframe><iframe src="../about/index.html"></iframe></body></html>`
+	out, _, err := Strip([]byte(in), Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	if !strings.Contains(s, "logo.png") {
+		t.Errorf("image frame should survive:\n%s", out)
+	}
+	if !strings.Contains(s, "../about/index.html") {
+		t.Errorf("sanitized page frame should survive:\n%s", out)
 	}
 }