@@ -221,10 +221,11 @@ export default class RenderJob {
 	reason: string | undefined;
 	/**
 	 * The URL the page's canonical link names, when a non-indexable render's canonical names ANOTHER URL
-	 * (resolved against the rendered URL, fragment dropped). Unset otherwise, so the key is absent from
-	 * every result that has nothing to say and an older plugin never sees it. The plugin's entity registry
-	 * records it: on a site where every spelling of a product is one document, this is the origin naming
-	 * the product's canonical.
+	 * (resolved against the rendered URL, fragment dropped) — posted whether or not the render produced
+	 * content, so a sitemap target that is serialized anyway carries it too. Unset otherwise, so the key is
+	 * absent from every result that has nothing to say and an older plugin never sees it. The plugin's
+	 * entity registry records it: on a site where every spelling of a product is one document, this is the
+	 * origin naming the product's canonical.
 	 */
 	declaredCanonical: string | undefined;
 
@@ -374,8 +375,10 @@ export default class RenderJob {
 			reason: this.content
 				? undefined
 				: (this.reason ?? (attemptError ? 'error' : this.redirectedTo ? 'redirect' : undefined)),
-			// Under the same rule as `reason`: a render that produced content has no verdict to explain.
-			declaredCanonical: this.content ? undefined : this.declaredCanonical,
+			// With content too: a sitemap target is serialized even when its canonical names another URL, and
+			// that is exactly the re-slugged URL whose new canonical the plugin wants. Not the rule `reason`
+			// follows, because this is not why there is no content; it is what the page said.
+			declaredCanonical: this.declaredCanonical,
 			// The failed attempt's detail — without it the plugin can only log "unknown
 			// prerender error". `phase` separates a navigation that never completed (slow
 			// origin) from a failure in the settle/serialize work. Anything can be thrown, so
@@ -545,7 +548,7 @@ export type VariantMetadata = {
 	documentReused: true | undefined;
 	documentPrefetched: true | undefined;
 	reason: string | undefined;
-	/** See `RenderJob.declaredCanonical`: present only on a non-indexable result whose canonical names another URL. */
+	/** See `RenderJob.declaredCanonical`: present only on a non-indexable result whose canonical names another URL, content or not. */
 	declaredCanonical: string | undefined;
 	error: { name: string; message: string; phase: string | undefined } | undefined;
 };
 
@@ -1143,8 +1143,9 @@ const renderer: Renderer = async (page, job) => {
 			job.isIndexable = verdict.isIndexable;
 			if (!verdict.isIndexable) {
 				job.reason = verdict.reason;
-				job.declaredCanonical = verdict.declaredCanonical;
 			}
+			// Assigned on every verdict, so an earlier attempt's never outlives a later one's.
+			job.declaredCanonical = verdict.declaredCanonical;
 
 			if (job.isIndexable || job.isFromSitemap) {
 				// Before postProcess: it may strip nodes, and this must describe the page as
@@ -1310,12 +1311,11 @@ export function indexVerdict(
 	const verdict = canonicalVerdict(signals.canonicalHref, pageUrl);
 	const disowned = verdict === 'elsewhere' || (verdict === 'variant' && strict);
 	if (!signals.noindex && !disowned) return { isIndexable: true };
-	const declaredCanonical = verdict === 'self' ? undefined : declaredCanonicalOf(signals.canonicalHref, pageUrl);
-	return {
-		isIndexable: false,
-		reason: signals.noindex ? 'noindex' : verdict === 'variant' ? 'canonical-variant' : 'canonical-mismatch',
-		...(declaredCanonical ? { declaredCanonical } : {}),
-	};
+	const reason = signals.noindex ? 'noindex' : verdict === 'variant' ? 'canonical-variant' : 'canonical-mismatch';
+	// Only a CANONICAL verdict reports where the page points: a noindex page's canonical is a statement made by
+	// a page that asked not to be indexed, and is not what the plugin adopts targets from.
+	const declaredCanonical = reason === 'noindex' ? undefined : declaredCanonicalOf(signals.canonicalHref, pageUrl);
+	return { isIndexable: false, reason, ...(declaredCanonical ? { declaredCanonical } : {}) };
 }
 
 /**
@@ -1329,12 +1329,17 @@ function declaredCanonicalOf(canonicalHref: string | null, pageUrl: string): str
 	try {
 		const url = new URL(canonicalHref, pageUrl);
 		url.hash = '';
-		return url.href;
+		// A web page's URL, of a length that could ever be a cache key; anything else is not worth posting.
+		if (url.protocol !== 'https:' && url.protocol !== 'http:') return undefined;
+		return url.href.length <= DECLARED_CANONICAL_MAX ? url.href : undefined;
 	} catch {
 		return undefined;
 	}
 }
 
+/** Longest declared canonical posted: past this no Harper primary key could hold it (the limit is ~1,978 bytes). */
+const DECLARED_CANONICAL_MAX = 2048;
+
 function extractIndexSignals(): { canonicalHref: string | null; noindex: boolean } {
 	let canonicalHref: string | null = null;
 	let noindex = false;
 
@@ -109,6 +109,14 @@ test('the post-settle verdict reports the declared canonical too, and an indexab
 	assert.equal(fine.declaredCanonical, undefined);
 });
 
+test('a SITEMAP target whose canonical names another URL is serialized, and still reports where it points', async () => {
+	const listed = await render('/canonical-elsewhere', {}, true);
+	await listed.close();
+	assert.equal(listed.isIndexable, false);
+	assert.match(listed.html ?? '', /<link rel="canonical"/, 'a listed URL is captured anyway');
+	assert.equal(listed.declaredCanonical, `${base}/other`);
+});
+
 // A 404's settle is skipped BY THE BAIL, not by the `status >= 400` abort: that abort only stops
 // subresource interception, so `goto` still resolves and the page would otherwise settle in full.
 // An earlier review argued the opposite (that `goto` rejects, making this arm dead code); this test
@@ -197,7 +205,6 @@ test('indexVerdict: the shared verdict both paths use', () => {
 	assert.deepEqual(indexVerdict({ canonicalHref: 'https://x.test/other', noindex: true }, page, false), {
 		isIndexable: false,
 		reason: 'noindex',
-		declaredCanonical: 'https://x.test/other',
 	});
 });
 
@@ -237,10 +244,20 @@ test('indexVerdict: a canonical naming another URL is reported, resolved against
 		indexVerdict({ canonicalHref: '/product/prd-1/new-slug.jsp#top', noindex: false }, page, false).declaredCanonical,
 		'https://x.test/product/prd-1/new-slug.jsp'
 	);
-	// A noindex page that also names another canonical still says where it points.
+	// Only a canonical verdict reports it: a noindex page's canonical is not something to adopt a target from.
+	assert.equal(
+		'declaredCanonical' in indexVerdict({ canonicalHref: 'https://x.test/other', noindex: true }, page, false),
+		false
+	);
+	// A web URL of a keyable length, or nothing.
+	assert.equal(
+		'declaredCanonical' in indexVerdict({ canonicalHref: 'ftp://x.test/other', noindex: false }, page, false),
+		false
+	);
 	assert.equal(
-		indexVerdict({ canonicalHref: 'https://x.test/other', noindex: true }, page, false).declaredCanonical,
-		'https://x.test/other'
+		'declaredCanonical' in
+			indexVerdict({ canonicalHref: `https://x.test/${'a'.repeat(3000)}`, noindex: false }, page, false),
+		false
 	);
 	// A strict variant names this document re-spelled: reported too, it is still the origin's spelling.
 	assert.equal(
 
@@ -111,7 +111,7 @@ test('a noindex page posts outcome=non-indexable with the reason', async () => {
 	assert.equal(meta.reason, 'noindex');
 });
 
-test('a canonical verdict posts the canonical the page declared; a render with content never does', async () => {
+test('a canonical verdict posts the canonical the page declared — with or without content; an indexable render never does', async () => {
 	const job = makeJob();
 	job.attemptStarted();
 	job.httpResponse = { statusCode: 200, headers: {} };
@@ -123,16 +123,24 @@ test('a canonical verdict posts the canonical the page declared; a render with c
 	assert.equal(meta.outcome, 'non-indexable');
 	assert.equal(meta.declaredCanonical, 'https://site.example.com/product/x-new-slug');
 
+	// A sitemap target is serialized even when non-indexable: its content and its declared canonical both post.
+	const listed = makeJob();
+	listed.attemptStarted();
+	listed.httpResponse = { statusCode: 200, headers: { 'content-type': 'text/html' } };
+	listed.isIndexable = false;
+	listed.declaredCanonical = 'https://site.example.com/product/x-new-slug';
+	listed.attemptEnded(undefined, '<html>listed</html>');
+	const stored = await send(listed);
+	assert.equal(stored.outcome, 'rendered');
+	assert.equal(stored.declaredCanonical, 'https://site.example.com/product/x-new-slug');
+
 	// Absent, not null, when there is nothing to say: an older plugin never sees the key.
 	const plain = makeJob();
 	plain.attemptStarted();
 	plain.httpResponse = { statusCode: 200, headers: { 'content-type': 'text/html' } };
 	plain.isIndexable = true;
-	plain.declaredCanonical = 'https://site.example.com/product/x-new-slug'; // left over from an earlier attempt
 	plain.attemptEnded(undefined, '<html>ok</html>');
-	const stored = await send(plain);
-	assert.equal(stored.outcome, 'rendered');
-	assert.equal('declaredCanonical' in stored, false);
+	assert.equal('declaredCanonical' in (await send(plain)), false);
 });
 
 test('a failed render posts outcome=error with the attempt error and derived reason', async () => {