@@ -219,6 +219,14 @@ export default class RenderJob {
 	 * redirect/error fallbacks so callers only set the values they alone can know.
 	 */
 	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.
+	 */
+	declaredCanonical: string | undefined;
 
 	_httpResponse: OriginHttpResponse | null = null;
 
@@ -366,6 +374,8 @@ 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,
 			// 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
@@ -425,6 +435,7 @@ export default class RenderJob {
 			documentReused: this.documentReused || undefined,
 			documentPrefetched: this.documentPrefetched || undefined,
 			reason: 'result-build-failed',
+			declaredCanonical: undefined,
 			error: {
 				name: (error as Error)?.name ?? 'Error',
 				message: (error as Error)?.message ?? String(error),
@@ -534,6 +545,8 @@ 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. */
+	declaredCanonical: string | undefined;
 	error: { name: string; message: string; phase: string | undefined } | undefined;
 };
 
 
@@ -97,6 +97,8 @@ export interface RenderResult {
 	isIndexable: boolean | undefined;
 	/** Why no cacheable content: 'noindex' | 'canonical-mismatch' | 'canonical-variant' | 'http-error' | 'redirect-loop' | 'redirect' | 'error'. */
 	reason: string | undefined;
+	/** The URL a non-indexable page's canonical names, when it names another URL (job.declaredCanonical). */
+	declaredCanonical: string | undefined;
 	/** Normalized redirect target (job.redirectedTo), if the final URL canonically differs. */
 	redirectedTo: string | undefined;
 	/** Raw page.url() at snapshot time (complements the normalized redirectedTo). */
@@ -290,6 +292,7 @@ export async function renderOnce(options: RenderOnceOptions): Promise<RenderResu
 			statusCode: job.httpResponse?.statusCode,
 			isIndexable: job.isIndexable,
 			reason: job.reason ?? (error ? 'error' : !html && job.redirectedTo ? 'redirect' : undefined),
+			declaredCanonical: job.declaredCanonical,
 			redirectedTo: job.redirectedTo,
 			finalUrl,
 			responseHeaders: job.httpResponse?.headers,
 
@@ -546,6 +546,7 @@ const renderer: Renderer = async (page, job) => {
 			job.httpResponse = { statusCode, headers: finalRes.headers() };
 			job.isIndexable = false;
 			job.reason = verdict.reason;
+			job.declaredCanonical = 'declaredCanonical' in verdict ? verdict.declaredCanonical : undefined;
 			return;
 		}
 	}
@@ -1142,6 +1143,7 @@ const renderer: Renderer = async (page, job) => {
 			job.isIndexable = verdict.isIndexable;
 			if (!verdict.isIndexable) {
 				job.reason = verdict.reason;
+				job.declaredCanonical = verdict.declaredCanonical;
 			}
 
 			if (job.isIndexable || job.isFromSitemap) {
@@ -1300,16 +1302,39 @@ export function indexVerdict(
 	signals: { canonicalHref: string | null; noindex: boolean },
 	pageUrl: string,
 	strict: boolean
-): { isIndexable: boolean; reason?: 'noindex' | 'canonical-variant' | 'canonical-mismatch' } {
+): {
+	isIndexable: boolean;
+	reason?: 'noindex' | 'canonical-variant' | 'canonical-mismatch';
+	declaredCanonical?: string;
+} {
 	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 } : {}),
 	};
 }
 
+/**
+ * The URL a page's canonical link names, resolved exactly as {@link canonicalVerdict} resolved it to reach
+ * its verdict (against the rendered URL), without its fragment. Posted with a non-indexable result whose
+ * canonical names another URL: on a site where every spelling of a product is one document, the page that
+ * disowned this spelling has just said where the product lives now, and the plugin records it.
+ */
+function declaredCanonicalOf(canonicalHref: string | null, pageUrl: string): string | undefined {
+	if (!canonicalHref) return undefined;
+	try {
+		const url = new URL(canonicalHref, pageUrl);
+		url.hash = '';
+		return url.href;
+	} catch {
+		return undefined;
+	}
+}
+
 function extractIndexSignals(): { canonicalHref: string | null; noindex: boolean } {
 	let canonicalHref: string | null = null;
 	let noindex = false;
 
@@ -94,6 +94,19 @@ test('a canonical naming another document skips the settle phase', async () => {
 	assert.equal(result.isIndexable, false);
 	assert.equal(result.reason, 'canonical-mismatch');
 	assert.equal(result.timings.settle, undefined);
+	assert.equal(result.declaredCanonical, `${base}/other`, 'the bail still says where the page points');
+});
+
+test('the post-settle verdict reports the declared canonical too, and an indexable page reports none', async () => {
+	const settled = await render('/canonical-elsewhere', { navigation: { skipSettleWhenNonIndexable: false } });
+	await settled.close();
+	assert.notEqual(settled.timings.settle, undefined, 'this one reached its verdict after the settle');
+	assert.equal(settled.reason, 'canonical-mismatch');
+	assert.equal(settled.declaredCanonical, `${base}/other`);
+
+	const fine = await render('/fine');
+	await fine.close();
+	assert.equal(fine.declaredCanonical, undefined);
 });
 
 // A 404's settle is skipped BY THE BAIL, not by the `status >= 400` abort: that abort only stops
@@ -178,11 +191,13 @@ test('indexVerdict: the shared verdict both paths use', () => {
 	assert.deepEqual(indexVerdict({ canonicalHref: 'https://x.test/other', noindex: false }, page, false), {
 		isIndexable: false,
 		reason: 'canonical-mismatch',
+		declaredCanonical: 'https://x.test/other',
 	});
 	// noindex outranks a canonical verdict when both fire, so the reason stays the stronger signal.
 	assert.deepEqual(indexVerdict({ canonicalHref: 'https://x.test/other', noindex: true }, page, false), {
 		isIndexable: false,
 		reason: 'noindex',
+		declaredCanonical: 'https://x.test/other',
 	});
 });
 
@@ -209,3 +224,32 @@ test('with the flag on, a client-side redirect to an INDEXABLE page still render
 	assert.equal(new URL(result.redirectedTo!).pathname, '/fine');
 	assert.notEqual(result.timings.settle, undefined, 'and it must still settle');
 });
+
+test('indexVerdict: a canonical naming another URL is reported, resolved against the page and without its fragment', () => {
+	const page = 'https://x.test/product/prd-1/old-slug.jsp?color=red';
+	assert.equal(
+		indexVerdict({ canonicalHref: 'https://x.test/product/prd-1/new-slug.jsp', noindex: false }, page, false)
+			.declaredCanonical,
+		'https://x.test/product/prd-1/new-slug.jsp'
+	);
+	// Resolved exactly as the verdict resolved it, so a path-absolute href names the page's own origin.
+	assert.equal(
+		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.
+	assert.equal(
+		indexVerdict({ canonicalHref: 'https://x.test/other', noindex: true }, page, false).declaredCanonical,
+		'https://x.test/other'
+	);
+	// A strict variant names this document re-spelled: reported too, it is still the origin's spelling.
+	assert.equal(
+		indexVerdict({ canonicalHref: 'https://x.test/p%20q', noindex: false }, 'https://x.test/p+q', true)
+			.declaredCanonical,
+		'https://x.test/p%20q'
+	);
+	// Nothing to report: indexable, no canonical, or a noindex page whose canonical is itself.
+	assert.equal('declaredCanonical' in indexVerdict({ canonicalHref: page, noindex: false }, page, false), false);
+	assert.equal('declaredCanonical' in indexVerdict({ canonicalHref: null, noindex: true }, page, false), false);
+	assert.equal('declaredCanonical' in indexVerdict({ canonicalHref: page, noindex: true }, page, false), false);
+});
@@ -111,6 +111,30 @@ 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 () => {
+	const job = makeJob();
+	job.attemptStarted();
+	job.httpResponse = { statusCode: 200, headers: {} };
+	job.isIndexable = false;
+	job.reason = 'canonical-mismatch';
+	job.declaredCanonical = 'https://site.example.com/product/x-new-slug';
+	job.attemptEnded(undefined, undefined);
+	const meta = await send(job);
+	assert.equal(meta.outcome, 'non-indexable');
+	assert.equal(meta.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);
+});
+
 test('a failed render posts outcome=error with the attempt error and derived reason', async () => {
 	const job = makeJob();
 	job.attemptStarted();