From 06f75b2fdbc94062cac940a02f1ca9bd93aaa0d5 Mon Sep 17 00:00:00 2001
From: Joe <joseph@harperdb.io>
Date: Thu, 24 Sep 2026 19:07:23 -0400
Subject: [PATCH] =?UTF-8?q?perf(browser):=20one=20in-page=20evaluate=20for?=
 =?UTF-8?q?=20structuredOffers=20and=20pageFacts=20=E2=80=94=20one=20CDP?=
 =?UTF-8?q?=20round=20trip=20and=20one=20JSON-LD=20parse=20per=20render,?=
 =?UTF-8?q?=20outputs=20unchanged;=20v1.38.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The renderer read the page's two claims with two separate page.evaluate calls, each
querying and JSON-parsing every JSON-LD block itself. extractPageClaims reads both in
one evaluate: the blocks are queried once and each parsed at most once, on the first
reader's demand and never past the furthest block either reader needs.

The two readers' bodies are the 1.37.0 extractors verbatim apart from the block loop,
so every output is unchanged, including structuredOffers' 64-char field slicing (the
plugin's change probe stores those values). Each reader runs in its own in-page
try/catch, so a throw in one still nulls only that claim; a failure of the evaluate
itself posts null for both, never a failed render and never an absent field.

test/pageClaimsParity.test.ts keeps both 1.37.0 extractors verbatim and holds the
merged one to deep-equal and byte-identical output over every fixture of both suites,
edge cases where the two walks diverge, hostile pages that break one reader, and a
400-document seeded fuzz corpus. Three deliberate mutations of the merged extractor
each fail it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
---
 package-lock.json                             |    2 +-
 packages/browser/README.md                    |    4 +-
 packages/browser/package.json                 |    2 +-
 packages/browser/src/pageFacts.ts             |  523 ++++---
 packages/browser/src/renderer.ts              |  105 +-
 .../browser/test/pageClaimsParity.test.ts     | 1245 +++++++++++++++++
 packages/browser/test/pageFacts.test.ts       |   44 +-
 7 files changed, 1629 insertions(+), 296 deletions(-)
 create mode 100644 packages/browser/test/pageClaimsParity.test.ts

diff --git a/package-lock.json b/package-lock.json
index 7bb0c89d..07759f98 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8516,7 +8516,7 @@
 		},
 		"packages/browser": {
 			"name": "@harperfast/prerender-browser",
-			"version": "1.37.0",
+			"version": "1.38.0",
 			"license": "Apache-2.0",
 			"dependencies": {
 				"mqtt": "^5.10.4",
diff --git a/packages/browser/README.md b/packages/browser/README.md
index 35d4d0f0..5cce888e 100644
--- a/packages/browser/README.md
+++ b/packages/browser/README.md
@@ -142,7 +142,9 @@ carries facts the renderer read off the settled DOM (before `postProcess`), so t
 the cached page's own claims against its sources of truth without parsing HTML on its write path. Both
 fields share one wire contract: **absent** means the renderer predates the field (a consumer may alarm on
 it); **`null`** means the extraction ran and found nothing to claim or failed benignly — it is posted as
-`null`, never omitted, and an extraction failure never fails the render. The extraction runs only on
+`null`, never omitted, and an extraction failure never fails the render. Both are read in one in-page
+pass (one `page.evaluate`, each JSON-LD block parsed once): a failure in one reader costs only that
+field, and a failure of the pass itself posts `null` for both. The extraction runs only on
 the path that produces content, so a variant without content (a redirect, a verdict, an error) may carry
 neither — absence is meaningful only on a variant that carries content.
 
diff --git a/packages/browser/package.json b/packages/browser/package.json
index 0e169d35..116d24e8 100644
--- a/packages/browser/package.json
+++ b/packages/browser/package.json
@@ -1,6 +1,6 @@
 {
 	"name": "@harperfast/prerender-browser",
-	"version": "1.37.0",
+	"version": "1.38.0",
 	"type": "module",
 	"description": "Headless-browser render library for Harper Prerender: claims render jobs from the @harperfast/prerender queue, renders pages in headless Chrome (Puppeteer), and posts the HTML back. Embedded by a render service and configured entirely via startWorker() options.",
 	"keywords": [
diff --git a/packages/browser/src/pageFacts.ts b/packages/browser/src/pageFacts.ts
index 6ad358cb..95b8bea9 100644
--- a/packages/browser/src/pageFacts.ts
+++ b/packages/browser/src/pageFacts.ts
@@ -1,6 +1,7 @@
 /**
- * What the rendered page itself CLAIMS — its canonical, title, meta description, first heading,
- * product JSON-LD and breadcrumb trail — read off the settled DOM and posted with each variant.
+ * What the rendered page itself CLAIMS — its schema.org offers (`structuredOffers`) and its SEO facts
+ * (canonical, title, meta description, first heading, product JSON-LD and breadcrumb trail) — read off
+ * the settled DOM and posted with each variant.
  *
  * WHY THE RENDERER. The consumer compares these against its own sources of truth to decide whether a
  * cached page is wrong (and only then re-render it). It deliberately never parses HTML on its hot
@@ -10,7 +11,9 @@
  * BOUNDS ARE REFUSALS, NEVER TRUNCATIONS. A truncated value would disagree with the consumer's source
  * of truth on every comparison, and a systematic disagreement means the consumer expires and
  * re-renders that page forever. So a value past its bound is reported as no claim at all (`null`),
- * which degrades to exactly what "the page does not say" does: nothing to compare.
+ * which degrades to exactly what "the page does not say" does: nothing to compare. (`structuredOffers`
+ * predates this rule for its fields: it refuses past its offer cap but slices an over-long field to 64
+ * characters. Changing that would change every value the consumer already stores, so it stays.)
  *
  * Standard HTML and schema.org only — nothing here may know about a particular site.
  */
@@ -79,219 +82,349 @@ export const PAGE_FACT_BOUNDS: PageFactBounds = {
 	maxOfferField: 64,
 };
 
+// Refusal threshold, not a sample size: a variant-heavy PDP legitimately carries dozens of offer
+// triples, but past this the page posts NO claim rather than a truncated one (see
+// `extractPageClaims` — a deterministic sample can systematically disagree with the consumer's
+// endpoint).
+export const STRUCTURED_OFFER_CAP = 200;
+
 /**
- * Read the page's facts off the live DOM. Runs IN THE PAGE (passed to `page.evaluate`), so it is fully
- * self-contained: no imports, no closure over module scope, every helper declared inside.
+ * Both claims, as one in-page extraction returns them. Each is `null` when its reader found nothing to
+ * claim or threw — independently: a throw in one reader never costs the other its value.
+ */
+export type PageClaims = {
+	/** See `RenderJob.structuredOffers`: sorted `[price, currency, availability]` triples, flattened. */
+	structuredOffers: Array<string | null> | null;
+	pageFacts: PageFacts | null;
+};
+
+/**
+ * Read both of the page's claims off the live DOM in ONE `page.evaluate`. Runs IN THE PAGE, so it is
+ * fully self-contained: no imports, no closure over module scope, every helper declared inside.
+ *
+ * ONE ROUND TRIP, ONE PARSE. The two readers search the same `<script type="application/ld+json">`
+ * blocks, in document order, reading a top-level array or an `@graph` as a list of nodes. Each block is
+ * queried once and parsed at most once — on the first reader's demand, never past the furthest block
+ * either reader needs — and a block that does not parse is skipped without costing the others. The
+ * parsed values are shared, which is invisible to both: neither reader writes to a parsed node, and each
+ * builds its output from fresh arrays and primitives.
+ *
+ * INDEPENDENT. Each reader runs in its own try/catch, so a throw in one reports THAT claim as null and
+ * costs the other nothing — what two separate evaluates gave. A failure of the evaluate itself (a
+ * destroyed context, an unserializable result) is past any in-page catch; the caller posts null for
+ * both, never a failed render.
  *
- * JSON-LD is searched the way `extractStructuredOffers` searches it — each
- * `<script type="application/ld+json">` in document order, reading a top-level array or an `@graph`
- * as a list of nodes — and a block that does not parse is skipped without costing the others. When no
- * top-level node matches, one level under a page node (WebPage or a subtype) is searched too: its
- * `mainEntity` / `mainEntityOfPage` for the product, its `breadcrumb` for the trail.
+ * `structuredOffers`: every schema.org Product's offers, flattened to [price, currency, availability]
+ * triples and sorted so the sequence is stable across renders of unchanged content. null when the page
+ * declares no Product offers, so "no structured data" stays distinguishable from "no offers". A page
+ * carrying MORE offers than `offerCap` is null too — no claim, never a truncated one. A deterministic
+ * sample that happens to omit the offer the consumer's endpoint reports would disagree with it on every
+ * comparison, and a systematic disagreement means the consumer expires and re-renders that page
+ * forever. "Too many offers to read confidently" degrades to exactly what "no offers" does: nothing.
+ *
+ * `pageFacts`: see {@link PageFacts}. When no top-level node matches, one level under a page node
+ * (WebPage or a subtype) is searched too: its `mainEntity` / `mainEntityOfPage` for the product, its
+ * `breadcrumb` for the trail.
  */
-export function extractPageFacts(bounds: PageFactBounds): PageFacts {
-	type Json = Record<string, unknown>;
-	const isObject = (value: unknown): value is Json => !!value && typeof value === 'object' && !Array.isArray(value);
-	const boundTo =
-		(max: number) =>
-		(value: unknown): string | null =>
-			typeof value !== 'string' || value === '' || value.length > max ? null : value;
-	const str = boundTo(bounds.maxString);
-	const offerField = boundTo(bounds.maxOfferField);
-	const hasType = (node: Json, wanted: string[]) => {
-		const type = node['@type'];
-		return Array.isArray(type) ? type.some((t) => wanted.includes(t as string)) : wanted.includes(type as string);
+export function extractPageClaims(offerCap: number, bounds: PageFactBounds): PageClaims {
+	// The page's JSON-LD blocks, queried on first use and each parsed at most once. Both readers walk
+	// them in order from the first, so the cache only ever grows at its end.
+	const MALFORMED = {};
+	let scripts: NodeListOf<Element> | null = null;
+	const parsed: unknown[] = [];
+	const blockCount = (): number => {
+		if (!scripts) scripts = document.querySelectorAll('script[type="application/ld+json"]');
+		return scripts.length;
+	};
+	/** Block `i`'s JSON, or MALFORMED. Only called below `blockCount()`. */
+	const block = (i: number): unknown => {
+		while (parsed.length <= i) {
+			let data: unknown;
+			try {
+				data = JSON.parse((scripts as NodeListOf<Element>)[parsed.length].textContent || '');
+			} catch {
+				data = MALFORMED; // one malformed block must not cost the page its other blocks
+			}
+			parsed.push(data);
+		}
+		return parsed[i];
 	};
-	// A schema.org number may be written as a JSON number or a numeric string ("4.5"). Anything else —
-	// including null, which Number() would silently read as 0 — is no claim.
-	const num = (value: unknown): number | null => {
-		if (typeof value === 'number') return Number.isFinite(value) ? value : null;
-		if (typeof value !== 'string') return null;
-		const trimmed = value.trim();
-		if (!trimmed || trimmed.length > bounds.maxOfferField) return null;
-		const n = Number(trimmed);
-		return Number.isFinite(n) ? n : null;
+
+	const readStructuredOffers = (cap: number): Array<string | null> | null => {
+		const triples: Array<Array<string | null>> = [];
+		let overflowed = false;
+		// Field-level byte bound: the cap bounds triple COUNT, so without this a single pathological
+		// field (a megabyte "price" string) would still inflate every posted result for the page. No
+		// legitimate price, currency code, or availability token approaches 64 characters.
+		const bound = (value: string): string | null => (value === '' ? null : value.slice(0, 64));
+		const collect = (node: unknown) => {
+			if (overflowed || !node || typeof node !== 'object') return;
+			const record = node as Record<string, unknown>;
+			const type = record['@type'];
+			const isProduct = type === 'Product' || (Array.isArray(type) && type.includes('Product'));
+			if (!isProduct) return;
+			const raw = record.offers;
+			const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+			for (const entry of list) {
+				if (!entry || typeof entry !== 'object') continue;
+				if (triples.length >= cap) {
+					overflowed = true;
+					return;
+				}
+				const offer = entry as Record<string, unknown>;
+				// filter(Boolean) before pop: a trailing slash (https://schema.org/InStock/) would
+				// otherwise pop the empty segment and read as no availability at all.
+				const availability =
+					typeof offer.availability === 'string'
+						? bound(offer.availability.split('/').filter(Boolean).pop() ?? '')
+						: null;
+				const price = offer.price === undefined || offer.price === null ? null : bound(String(offer.price));
+				const currency = typeof offer.priceCurrency === 'string' ? bound(offer.priceCurrency) : null;
+				triples.push([price, currency, availability]);
+			}
+		};
+		for (let i = 0; i < blockCount() && !overflowed; i++) {
+			const data = block(i);
+			if (data === MALFORMED) continue;
+			const graph = (data as Record<string, unknown>)?.['@graph'];
+			const nodes = Array.isArray(data) ? data : Array.isArray(graph) ? graph : [data];
+			for (const node of nodes) {
+				if (overflowed) break;
+				collect(node);
+			}
+		}
+		if (overflowed || !triples.length) return null;
+		// Field-wise, not JSON.stringify per comparison: sorting is O(n log n) COMPARISONS, so
+		// stringifying inside the comparator serialises every triple many times over. Code-unit
+		// comparison, not localeCompare: the whole point of the sort is a sequence that is identical
+		// across renders, and collation varies with the browser's locale/ICU.
+		triples.sort((a, b) => {
+			for (let i = 0; i < 3; i++) {
+				const x = a[i];
+				const y = b[i];
+				if (x === y) continue;
+				if (x === null) return -1;
+				if (y === null) return 1;
+				return x < y ? -1 : 1;
+			}
+			return 0;
+		});
+		return triples.flat();
 	};
-	const listOf = (value: unknown): unknown[] => (Array.isArray(value) ? value : value ? [value] : []);
 
-	const canonicalEl = document.querySelector('link[rel="canonical"]') as HTMLLinkElement | null;
-	const descriptionEl = document.querySelector('meta[name="description" i]');
-	const h1El = document.querySelector('h1');
+	const readPageFacts = (): PageFacts => {
+		type Json = Record<string, unknown>;
+		const isObject = (value: unknown): value is Json => !!value && typeof value === 'object' && !Array.isArray(value);
+		const boundTo =
+			(max: number) =>
+			(value: unknown): string | null =>
+				typeof value !== 'string' || value === '' || value.length > max ? null : value;
+		const str = boundTo(bounds.maxString);
+		const offerField = boundTo(bounds.maxOfferField);
+		const hasType = (node: Json, wanted: string[]) => {
+			const type = node['@type'];
+			return Array.isArray(type) ? type.some((t) => wanted.includes(t as string)) : wanted.includes(type as string);
+		};
+		// A schema.org number may be written as a JSON number or a numeric string ("4.5"). Anything else —
+		// including null, which Number() would silently read as 0 — is no claim.
+		const num = (value: unknown): number | null => {
+			if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+			if (typeof value !== 'string') return null;
+			const trimmed = value.trim();
+			if (!trimmed || trimmed.length > bounds.maxOfferField) return null;
+			const n = Number(trimmed);
+			return Number.isFinite(n) ? n : null;
+		};
+		const listOf = (value: unknown): unknown[] => (Array.isArray(value) ? value : value ? [value] : []);
 
-	// schema.org WebPage and its subtypes: the nodes whose `mainEntity` / `breadcrumb` are searched.
-	const PAGE_TYPES = [
-		'WebPage',
-		'ItemPage',
-		'CollectionPage',
-		'SearchResultsPage',
-		'ProfilePage',
-		'AboutPage',
-		'ContactPage',
-		'FAQPage',
-		'QAPage',
-		'CheckoutPage',
-		'MedicalWebPage',
-		'RealEstateListing',
-		'MediaGallery',
-		'ImageGallery',
-		'VideoGallery',
-	];
-	const PRODUCT_TYPES = ['Product', 'ProductGroup'];
+		const canonicalEl = document.querySelector('link[rel="canonical"]') as HTMLLinkElement | null;
+		const descriptionEl = document.querySelector('meta[name="description" i]');
+		const h1El = document.querySelector('h1');
 
-	// A node at the top of a block (or of its @graph) always wins; one found a single level down — a
-	// page node's `mainEntity` / `mainEntityOfPage` / `breadcrumb` — is used only when no top-level node
-	// matched. One level only: this reads what a page states about itself, it does not crawl a graph.
-	let productNode: Json | null = null;
-	let breadcrumbNode: Json | null = null;
-	let nestedProduct: Json | null = null;
-	let nestedBreadcrumb: Json | null = null;
-	const blocks = document.querySelectorAll('script[type="application/ld+json"]');
-	for (let i = 0; i < blocks.length && !(productNode && breadcrumbNode); i++) {
-		let data: unknown;
-		try {
-			data = JSON.parse(blocks[i].textContent || '');
-		} catch {
-			continue; // one malformed block must not cost the page its other blocks
-		}
-		const graph = isObject(data) ? data['@graph'] : undefined;
-		const nodes = Array.isArray(data) ? data : Array.isArray(graph) ? graph : [data];
-		for (const node of nodes) {
-			if (!isObject(node)) continue;
-			if (!productNode && hasType(node, PRODUCT_TYPES)) productNode = node;
-			if (!breadcrumbNode && hasType(node, ['BreadcrumbList'])) breadcrumbNode = node;
-			if (!hasType(node, PAGE_TYPES)) continue;
-			if (!nestedProduct) {
-				for (const entity of listOf(node.mainEntity)) {
-					if (isObject(entity) && hasType(entity, PRODUCT_TYPES)) {
-						nestedProduct = entity;
-						break;
+		// schema.org WebPage and its subtypes: the nodes whose `mainEntity` / `breadcrumb` are searched.
+		const PAGE_TYPES = [
+			'WebPage',
+			'ItemPage',
+			'CollectionPage',
+			'SearchResultsPage',
+			'ProfilePage',
+			'AboutPage',
+			'ContactPage',
+			'FAQPage',
+			'QAPage',
+			'CheckoutPage',
+			'MedicalWebPage',
+			'RealEstateListing',
+			'MediaGallery',
+			'ImageGallery',
+			'VideoGallery',
+		];
+		const PRODUCT_TYPES = ['Product', 'ProductGroup'];
+
+		// A node at the top of a block (or of its @graph) always wins; one found a single level down — a
+		// page node's `mainEntity` / `mainEntityOfPage` / `breadcrumb` — is used only when no top-level node
+		// matched. One level only: this reads what a page states about itself, it does not crawl a graph.
+		let productNode: Json | null = null;
+		let breadcrumbNode: Json | null = null;
+		let nestedProduct: Json | null = null;
+		let nestedBreadcrumb: Json | null = null;
+		for (let i = 0; i < blockCount() && !(productNode && breadcrumbNode); i++) {
+			const data = block(i);
+			if (data === MALFORMED) continue;
+			const graph = isObject(data) ? data['@graph'] : undefined;
+			const nodes = Array.isArray(data) ? data : Array.isArray(graph) ? graph : [data];
+			for (const node of nodes) {
+				if (!isObject(node)) continue;
+				if (!productNode && hasType(node, PRODUCT_TYPES)) productNode = node;
+				if (!breadcrumbNode && hasType(node, ['BreadcrumbList'])) breadcrumbNode = node;
+				if (!hasType(node, PAGE_TYPES)) continue;
+				if (!nestedProduct) {
+					for (const entity of listOf(node.mainEntity)) {
+						if (isObject(entity) && hasType(entity, PRODUCT_TYPES)) {
+							nestedProduct = entity;
+							break;
+						}
 					}
 				}
+				const ofPage = node.mainEntityOfPage;
+				if (!nestedProduct && isObject(ofPage) && hasType(ofPage, PRODUCT_TYPES)) nestedProduct = ofPage;
+				const crumb = node.breadcrumb;
+				if (!nestedBreadcrumb && isObject(crumb) && hasType(crumb, ['BreadcrumbList'])) nestedBreadcrumb = crumb;
 			}
-			const ofPage = node.mainEntityOfPage;
-			if (!nestedProduct && isObject(ofPage) && hasType(ofPage, PRODUCT_TYPES)) nestedProduct = ofPage;
-			const crumb = node.breadcrumb;
-			if (!nestedBreadcrumb && isObject(crumb) && hasType(crumb, ['BreadcrumbList'])) nestedBreadcrumb = crumb;
 		}
-	}
-	productNode = productNode ?? nestedProduct;
-	breadcrumbNode = breadcrumbNode ?? nestedBreadcrumb;
+		productNode = productNode ?? nestedProduct;
+		breadcrumbNode = breadcrumbNode ?? nestedBreadcrumb;
 
-	// A JSON number is stated as its string form ("35.99", "12345"), as structuredOffers states a price.
-	const asString = (value: unknown) => (typeof value === 'number' && Number.isFinite(value) ? String(value) : value);
-	const absent = (value: unknown) => value === undefined || value === null || value === '';
-	const nonEmpty = (value: unknown) => (typeof value === 'string' && value !== '' ? value : undefined);
+		// A JSON number is stated as its string form ("35.99", "12345"), as structuredOffers states a price.
+		const asString = (value: unknown) => (typeof value === 'number' && Number.isFinite(value) ? String(value) : value);
+		const absent = (value: unknown) => value === undefined || value === null || value === '';
+		const nonEmpty = (value: unknown) => (typeof value === 'string' && value !== '' ? value : undefined);
 
-	// The offer objects a node states, in document order — an AggregateOffer summarises
-	// (lowPrice/highPrice), so only the offers it lists are offers. null when past the bound.
-	const offersOf = (raw: unknown): Json[] | null => {
-		const found: Json[] = [];
-		for (const entry of listOf(raw)) {
-			const list = isObject(entry) && hasType(entry, ['AggregateOffer']) ? listOf(entry.offers) : [entry];
-			for (const offer of list) {
-				if (!isObject(offer)) continue;
-				if (found.length >= bounds.maxOffers) return null;
-				found.push(offer);
+		// The offer objects a node states, in document order — an AggregateOffer summarises
+		// (lowPrice/highPrice), so only the offers it lists are offers. null when past the bound.
+		const offersOf = (raw: unknown): Json[] | null => {
+			const found: Json[] = [];
+			for (const entry of listOf(raw)) {
+				const list = isObject(entry) && hasType(entry, ['AggregateOffer']) ? listOf(entry.offers) : [entry];
+				for (const offer of list) {
+					if (!isObject(offer)) continue;
+					if (found.length >= bounds.maxOffers) return null;
+					found.push(offer);
+				}
 			}
-		}
-		return found;
-	};
-	const tuple = (offer: Json, sku: unknown): PageFactOffer => {
-		// Reduced exactly as extractStructuredOffers reduces it: the last non-empty path segment, so a
-		// trailing slash (https://schema.org/InStock/) still yields the verdict.
-		const availability =
-			typeof offer.availability === 'string' ? (offer.availability.split('/').filter(Boolean).pop() ?? '') : null;
-		return [
-			offerField(asString(sku)),
-			offerField(asString(offer.price)),
-			offerField(offer.priceCurrency),
-			offerField(availability),
-		];
-	};
+			return found;
+		};
+		const tuple = (offer: Json, sku: unknown): PageFactOffer => {
+			// Reduced exactly as readStructuredOffers reduces it: the last non-empty path segment, so a
+			// trailing slash (https://schema.org/InStock/) still yields the verdict.
+			const availability =
+				typeof offer.availability === 'string' ? (offer.availability.split('/').filter(Boolean).pop() ?? '') : null;
+			return [
+				offerField(asString(sku)),
+				offerField(asString(offer.price)),
+				offerField(offer.priceCurrency),
+				offerField(availability),
+			];
+		};
 
-	const readOffers = (node: Json, variants: Json[]): PageFactOffer[] | null => {
-		const own = offersOf(node.offers);
-		if (own === null) return null; // refused — never fall through to the variants
-		if (own.length) {
-			// A product selling ONE offer often names the SKU on itself rather than on the offer. Only
-			// then: with several offers, the product's SKU names none of them.
-			const inherit = own.length === 1 && absent(own[0].sku);
-			return own.map((offer) => tuple(offer, inherit ? node.sku : offer.sku));
-		}
-		// A ProductGroup usually sells through its variants (`hasVariant`, each a Product with its own
-		// offers and SKU) — read those when the group itself states no offers.
-		const out: PageFactOffer[] = [];
-		for (const variant of variants) {
-			const offers = offersOf(variant.offers);
-			if (offers === null) return null;
-			for (const offer of offers) {
-				if (out.length >= bounds.maxOffers) return null;
-				out.push(tuple(offer, absent(offer.sku) ? variant.sku : offer.sku));
+		const readOffers = (node: Json, variants: Json[]): PageFactOffer[] | null => {
+			const own = offersOf(node.offers);
+			if (own === null) return null; // refused — never fall through to the variants
+			if (own.length) {
+				// A product selling ONE offer often names the SKU on itself rather than on the offer. Only
+				// then: with several offers, the product's SKU names none of them.
+				const inherit = own.length === 1 && absent(own[0].sku);
+				return own.map((offer) => tuple(offer, inherit ? node.sku : offer.sku));
 			}
-		}
-		return out.length ? out : null;
-	};
+			// A ProductGroup usually sells through its variants (`hasVariant`, each a Product with its own
+			// offers and SKU) — read those when the group itself states no offers.
+			const out: PageFactOffer[] = [];
+			for (const variant of variants) {
+				const offers = offersOf(variant.offers);
+				if (offers === null) return null;
+				for (const offer of offers) {
+					if (out.length >= bounds.maxOffers) return null;
+					out.push(tuple(offer, absent(offer.sku) ? variant.sku : offer.sku));
+				}
+			}
+			return out.length ? out : null;
+		};
 
-	// Each field is PICKED raw — from the node, else (for a ProductGroup) its first variant — and only
-	// then bounded, so a value the group states too long is refused rather than swapped for a variant's.
-	const pickBrand = (n: Json) => nonEmpty(isObject(n.brand) ? n.brand.name : n.brand);
-	const pickImage = (n: Json) => {
-		const image = Array.isArray(n.image) ? n.image[0] : n.image;
-		return nonEmpty(isObject(image) ? image.url : image);
-	};
-	const pickRating = (n: Json): [number | null, number | null] | undefined => {
-		const r = n.aggregateRating;
-		if (!isObject(r)) return undefined;
-		const pair: [number | null, number | null] = [num(r.ratingValue), num(r.ratingCount ?? r.reviewCount)];
-		return pair[0] !== null || pair[1] !== null ? pair : undefined;
-	};
+		// Each field is PICKED raw — from the node, else (for a ProductGroup) its first variant — and only
+		// then bounded, so a value the group states too long is refused rather than swapped for a variant's.
+		const pickBrand = (n: Json) => nonEmpty(isObject(n.brand) ? n.brand.name : n.brand);
+		const pickImage = (n: Json) => {
+			const image = Array.isArray(n.image) ? n.image[0] : n.image;
+			return nonEmpty(isObject(image) ? image.url : image);
+		};
+		const pickRating = (n: Json): [number | null, number | null] | undefined => {
+			const r = n.aggregateRating;
+			if (!isObject(r)) return undefined;
+			const pair: [number | null, number | null] = [num(r.ratingValue), num(r.ratingCount ?? r.reviewCount)];
+			return pair[0] !== null || pair[1] !== null ? pair : undefined;
+		};
 
-	const readProduct = (node: Json): PageFactsProduct => {
-		const variants = hasType(node, ['ProductGroup']) ? listOf(node.hasVariant).filter(isObject) : [];
-		const pick = <T>(from: (n: Json) => T | undefined): T | undefined =>
-			from(node) ?? (variants.length ? from(variants[0]) : undefined);
-		return {
-			name: str(pick((n) => nonEmpty(n.name))),
-			brand: str(pick(pickBrand)),
-			image: str(pick(pickImage)),
-			rating: pick(pickRating) ?? null,
-			offers: readOffers(node, variants),
+		const readProduct = (node: Json): PageFactsProduct => {
+			const variants = hasType(node, ['ProductGroup']) ? listOf(node.hasVariant).filter(isObject) : [];
+			const pick = <T>(from: (n: Json) => T | undefined): T | undefined =>
+				from(node) ?? (variants.length ? from(variants[0]) : undefined);
+			return {
+				name: str(pick((n) => nonEmpty(n.name))),
+				brand: str(pick(pickBrand)),
+				image: str(pick(pickImage)),
+				rating: pick(pickRating) ?? null,
+				offers: readOffers(node, variants),
+			};
 		};
-	};
 
-	const readBreadcrumbs = (node: Json): string[] | null => {
-		const crumbs: Array<{ name: string; position: number | null; order: number }> = [];
-		const elements = listOf(node.itemListElement);
-		for (let order = 0; order < elements.length; order++) {
-			const el = elements[order];
-			if (!isObject(el)) continue;
-			const itemName = isObject(el.item) ? el.item.name : undefined;
-			const raw = typeof itemName === 'string' && itemName !== '' ? itemName : el.name;
-			if (typeof raw !== 'string' || raw === '') continue; // an unnamed crumb claims nothing
-			// A name past the bound refuses the whole trail: a trail with a hole in it would disagree.
-			if (raw.length > bounds.maxString) return null;
-			if (crumbs.length >= bounds.maxBreadcrumbs) return null;
-			crumbs.push({ name: raw, position: num(el.position), order });
-		}
-		// Ordered by position; a crumb without one keeps its document order after the positioned ones.
-		crumbs.sort((a, b) =>
-			a.position === b.position
-				? a.order - b.order
-				: a.position === null
-					? 1
-					: b.position === null
-						? -1
-						: a.position - b.position
-		);
-		return crumbs.length ? crumbs.map((c) => c.name) : null;
-	};
+		const readBreadcrumbs = (node: Json): string[] | null => {
+			const crumbs: Array<{ name: string; position: number | null; order: number }> = [];
+			const elements = listOf(node.itemListElement);
+			for (let order = 0; order < elements.length; order++) {
+				const el = elements[order];
+				if (!isObject(el)) continue;
+				const itemName = isObject(el.item) ? el.item.name : undefined;
+				const raw = typeof itemName === 'string' && itemName !== '' ? itemName : el.name;
+				if (typeof raw !== 'string' || raw === '') continue; // an unnamed crumb claims nothing
+				// A name past the bound refuses the whole trail: a trail with a hole in it would disagree.
+				if (raw.length > bounds.maxString) return null;
+				if (crumbs.length >= bounds.maxBreadcrumbs) return null;
+				crumbs.push({ name: raw, position: num(el.position), order });
+			}
+			// Ordered by position; a crumb without one keeps its document order after the positioned ones.
+			crumbs.sort((a, b) =>
+				a.position === b.position
+					? a.order - b.order
+					: a.position === null
+						? 1
+						: b.position === null
+							? -1
+							: a.position - b.position
+			);
+			return crumbs.length ? crumbs.map((c) => c.name) : null;
+		};
 
-	return {
-		canonical: canonicalEl ? str(canonicalEl.href) : null,
-		title: str((document.title || '').trim()),
-		metaDescription: descriptionEl ? str(descriptionEl.getAttribute('content')) : null,
-		h1: h1El ? str((h1El.textContent || '').replace(/\s+/g, ' ').trim()) : null,
-		product: productNode ? readProduct(productNode) : null,
-		breadcrumbs: breadcrumbNode ? readBreadcrumbs(breadcrumbNode) : null,
+		return {
+			canonical: canonicalEl ? str(canonicalEl.href) : null,
+			title: str((document.title || '').trim()),
+			metaDescription: descriptionEl ? str(descriptionEl.getAttribute('content')) : null,
+			h1: h1El ? str((h1El.textContent || '').replace(/\s+/g, ' ').trim()) : null,
+			product: productNode ? readProduct(productNode) : null,
+			breadcrumbs: breadcrumbNode ? readBreadcrumbs(breadcrumbNode) : null,
+		};
 	};
+
+	let structuredOffers: Array<string | null> | null = null;
+	try {
+		structuredOffers = readStructuredOffers(offerCap);
+	} catch {
+		// This reader alone reports no claim; the other still runs.
+	}
+	let pageFacts: PageFacts | null = null;
+	try {
+		pageFacts = readPageFacts();
+	} catch {
+		// Likewise.
+	}
+	return { structuredOffers, pageFacts };
 }
diff --git a/packages/browser/src/renderer.ts b/packages/browser/src/renderer.ts
index 1b4fabd5..80011248 100644
--- a/packages/browser/src/renderer.ts
+++ b/packages/browser/src/renderer.ts
@@ -18,7 +18,7 @@ import {
 	type ReadinessResult,
 } from './readiness.js';
 import { responseLogSource } from './responseLog.js';
-import { extractPageFacts, PAGE_FACT_BOUNDS } from './pageFacts.js';
+import { extractPageClaims, PAGE_FACT_BOUNDS, STRUCTURED_OFFER_CAP } from './pageFacts.js';
 import {
 	DOCUMENT_REUSE_HEADER,
 	cookieHeaderOf,
@@ -1150,11 +1150,14 @@ const renderer: Renderer = async (page, job) => {
 				// offers (or it failed benignly)" while an ABSENT field means "renderer predates
 				// this feature" — the consumer alarms on the latter, so collapsing null into
 				// undefined would make every offerless page impersonate an outdated renderer.
-				job.structuredOffers = await page.evaluate(extractStructuredOffers, STRUCTURED_OFFER_CAP).catch(() => null);
-				// The page's own SEO facts, with exactly the same absent-vs-null contract and the same
-				// never-fail-the-render handling. A separate evaluate on purpose: a throw in one must not
-				// cost the consumer the other.
-				job.pageFacts = await page.evaluate(extractPageFacts, PAGE_FACT_BOUNDS).catch(() => null);
+				//
+				// The page's own SEO facts ride the same evaluate, under exactly the same contract: one CDP
+				// round trip and one JSON-LD parse for both. Each reader is caught inside the page, so a
+				// throw in one still costs the consumer only that claim; a failure of the evaluate itself
+				// posts null for both. `?? null` keeps a missing key from ever reading as absent.
+				const claims = await page.evaluate(extractPageClaims, STRUCTURED_OFFER_CAP, PAGE_FACT_BOUNDS).catch(() => null);
+				job.structuredOffers = claims?.structuredOffers ?? null;
+				job.pageFacts = claims?.pageFacts ?? null;
 				const ppStart = Date.now();
 				const content = await page.evaluate(postProcess, config.postProcess, config.block.urlPatterns);
 				timings.postProcess = Date.now() - ppStart;
@@ -1301,96 +1304,6 @@ export function indexVerdict(
 	};
 }
 
-// Refusal threshold, not a sample size: a variant-heavy PDP legitimately carries dozens of offer
-// triples, but past this the page posts NO claim rather than a truncated one (see
-// extractStructuredOffers — a deterministic sample can systematically disagree with the
-// consumer's endpoint).
-const STRUCTURED_OFFER_CAP = 200;
-
-/**
- * The page's schema.org Product offers, flattened to [price, currency, availability] triples and
- * sorted so the sequence is stable across renders of unchanged content.
- *
- * Runs IN THE PAGE against the settled DOM, which is the whole point: the consumer would otherwise
- * have to regex-scan and JSON-parse the serialized document (~1MB on a commerce PDP) on its hottest
- * write path to recover values this process can read directly. Returns null when the page declares
- * no Product offers, so "no structured data" stays distinguishable from "no offers".
- *
- * A page carrying MORE offers than the cap also returns null — no claim, never a truncated one. A
- * deterministic sample that happens to omit the offer the consumer's endpoint reports would
- * disagree with it on every comparison, and a systematic disagreement means the consumer expires
- * and re-renders that page forever. "Too many offers to read confidently" degrades to exactly
- * what "no offers" does: nothing.
- *
- * Self-contained (passed to page.evaluate) — no imports, no closure over module scope.
- */
-function extractStructuredOffers(cap: number): Array<string | null> | null {
-	const triples: Array<Array<string | null>> = [];
-	let overflowed = false;
-	// Field-level byte bound: the cap bounds triple COUNT, so without this a single pathological
-	// field (a megabyte "price" string) would still inflate every posted result for the page. No
-	// legitimate price, currency code, or availability token approaches 64 characters.
-	const bound = (value: string): string | null => (value === '' ? null : value.slice(0, 64));
-	const collect = (node: unknown) => {
-		if (overflowed || !node || typeof node !== 'object') return;
-		const record = node as Record<string, unknown>;
-		const type = record['@type'];
-		const isProduct = type === 'Product' || (Array.isArray(type) && type.includes('Product'));
-		if (!isProduct) return;
-		const raw = record.offers;
-		const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
-		for (const entry of list) {
-			if (!entry || typeof entry !== 'object') continue;
-			if (triples.length >= cap) {
-				overflowed = true;
-				return;
-			}
-			const offer = entry as Record<string, unknown>;
-			// filter(Boolean) before pop: a trailing slash (https://schema.org/InStock/) would
-			// otherwise pop the empty segment and read as no availability at all.
-			const availability =
-				typeof offer.availability === 'string'
-					? bound(offer.availability.split('/').filter(Boolean).pop() ?? '')
-					: null;
-			const price = offer.price === undefined || offer.price === null ? null : bound(String(offer.price));
-			const currency = typeof offer.priceCurrency === 'string' ? bound(offer.priceCurrency) : null;
-			triples.push([price, currency, availability]);
-		}
-	};
-	document.querySelectorAll('script[type="application/ld+json"]').forEach((el) => {
-		if (overflowed) return;
-		let data: unknown;
-		try {
-			data = JSON.parse(el.textContent || '');
-		} catch {
-			return; // one malformed block must not cost the page its other blocks
-		}
-		const graph = (data as Record<string, unknown>)?.['@graph'];
-		const nodes = Array.isArray(data) ? data : Array.isArray(graph) ? graph : [data];
-		for (const node of nodes) {
-			if (overflowed) break;
-			collect(node);
-		}
-	});
-	if (overflowed || !triples.length) return null;
-	// Field-wise, not JSON.stringify per comparison: sorting is O(n log n) COMPARISONS, so
-	// stringifying inside the comparator serialises every triple many times over. Code-unit
-	// comparison, not localeCompare: the whole point of the sort is a sequence that is identical
-	// across renders, and collation varies with the browser's locale/ICU.
-	triples.sort((a, b) => {
-		for (let i = 0; i < 3; i++) {
-			const x = a[i];
-			const y = b[i];
-			if (x === y) continue;
-			if (x === null) return -1;
-			if (y === null) return 1;
-			return x < y ? -1 : 1;
-		}
-		return 0;
-	});
-	return triples.flat();
-}
-
 function extractIndexSignals(): { canonicalHref: string | null; noindex: boolean } {
 	let canonicalHref: string | null = null;
 	let noindex = false;
diff --git a/packages/browser/test/pageClaimsParity.test.ts b/packages/browser/test/pageClaimsParity.test.ts
new file mode 100644
index 00000000..6070b9cf
--- /dev/null
+++ b/packages/browser/test/pageClaimsParity.test.ts
@@ -0,0 +1,1245 @@
+import { test, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import type { AddressInfo } from 'node:net';
+import puppeteer, { type Browser, type Page } from 'puppeteer';
+import { extractPageClaims, PAGE_FACT_BOUNDS, STRUCTURED_OFFER_CAP } from '../dist/pageFacts.js';
+import type { PageFactBounds, PageFactOffer, PageFacts, PageFactsProduct } from '../dist/pageFacts.js';
+
+/**
+ * PARITY GATE for the single in-page extraction (browser 1.38.0).
+ *
+ * Up to 1.37.0 the renderer read `structuredOffers` and `pageFacts` with two separate `page.evaluate`
+ * calls, each querying and JSON-parsing every JSON-LD block itself. 1.38.0 reads both in ONE evaluate
+ * (`extractPageClaims`) that parses each block once. The outputs must not move by a byte: the plugin's
+ * change probe stores `structuredOffers` as the claim it compares against, so any drift would expire and
+ * re-render pages whose content never changed.
+ *
+ * So this file keeps the two 1.37.0 extractors VERBATIM (bottom of the file — only renamed) and asserts,
+ * for every fixture the two extractors' own suites use, a set of new edge cases, and a seeded fuzz
+ * corpus, that the merged extractor returns deep-equal AND byte-identical (JSON) output to the old pair —
+ * each side mapped exactly as its renderer maps it (`.catch(() => null)` per evaluate before; one
+ * evaluate, `?? null` per field, after).
+ *
+ * If the extraction's semantics are ever changed ON PURPOSE, this gate has done its job: delete the file.
+ */
+
+type Claims = { structuredOffers: Array<string | null> | null; pageFacts: PageFacts | null };
+
+let server: http.Server;
+let base = '';
+const pages = new Map<string, string>();
+let browser: Browser;
+
+before(async () => {
+	server = http.createServer((req, res) => {
+		const body = pages.get(req.url ?? '');
+		res.writeHead(body === undefined ? 404 : 200, { 'content-type': 'text/html; charset=utf-8' });
+		res.end(body ?? 'not found');
+	});
+	await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+	base = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+	browser = await puppeteer.launch({ headless: true });
+});
+
+after(async () => {
+	await browser?.close();
+	server?.close();
+});
+
+/** The 1.37.0 renderer: two evaluates, each failure its own null. */
+const before137 = async (page: Page): Promise<Claims> => ({
+	structuredOffers: await page.evaluate(legacyStructuredOffers, STRUCTURED_OFFER_CAP).catch(() => null),
+	pageFacts: await page.evaluate(legacyPageFacts, PAGE_FACT_BOUNDS).catch(() => null),
+});
+
+/** The 1.38.0 renderer: one evaluate. */
+const after138 = async (page: Page): Promise<Claims> => {
+	const claims = await page.evaluate(extractPageClaims, STRUCTURED_OFFER_CAP, PAGE_FACT_BOUNDS).catch(() => null);
+	return { structuredOffers: claims?.structuredOffers ?? null, pageFacts: claims?.pageFacts ?? null };
+};
+
+const assertParity = (old: Claims, merged: Claims, label: string) => {
+	assert.deepEqual(merged, old, `${label}: merged output differs from the 1.37.0 pair`);
+	assert.equal(JSON.stringify(merged), JSON.stringify(old), `${label}: wire bytes differ`);
+};
+
+let seq = 0;
+/** Serve `html`, load it (its own scripts run), and compare both extractions against that one DOM. */
+const compare = async (label: string, html: string): Promise<Claims> => {
+	const path = `/parity-${++seq}`;
+	pages.set(path, html);
+	const page = await browser.newPage();
+	try {
+		await page.goto(`${base}${path}`, { waitUntil: 'load' });
+		const old = await before137(page);
+		const merged = await after138(page);
+		assertParity(old, merged, label);
+		return merged;
+	} finally {
+		await page.close();
+	}
+};
+
+// JSON inside <script> — escape `<` so no fixture string can close the element early.
+const ld = (value: unknown) =>
+	`<script type="application/ld+json">${JSON.stringify(value).replace(/</g, '\\u003c')}</script>`;
+const rawLd = (text: string) => `<script type="application/ld+json">${text}</script>`;
+const doc = (head: string, body = '') => `<!doctype html><html><head>${head}</head><body>${body}</body></html>`;
+/** The structuredOffers suite's page shell. */
+const soPage = (head: string) =>
+	`<!doctype html><html><head><title>p</title>
+<link rel="canonical" href="https://www.example.com/p">
+${head}</head><body><h1>product</h1></body></html>`;
+
+const soffer = (i: number) => ({ price: `${i}.99`, priceCurrency: 'USD', availability: 'https://schema.org/InStock' });
+const foffer = (i: number) => ({ sku: `S${i}`, price: i, priceCurrency: 'USD', availability: 'InStock' });
+const variant = (sku: string, offers: unknown, extra: Record<string, unknown> = {}) => ({
+	'@type': 'Product',
+	sku,
+	offers,
+	...extra,
+});
+const crumbs = (length: number) =>
+	ld({
+		'@type': 'BreadcrumbList',
+		'itemListElement': Array.from({ length }, (_, i) => ({ position: i + 1, name: `C${i + 1}` })),
+	});
+
+// ── the structuredOffers suite's fixtures ──────────────────────────────────────────────────────
+
+const STRUCTURED_OFFERS_FIXTURES: Array<[string, string]> = [
+	[
+		'offers: two offers, number and string price',
+		soPage(
+			ld({
+				'@type': 'Product',
+				'name': 'Thing',
+				'offers': [
+					{ price: 35.99, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+					{ price: '29.99', priceCurrency: 'USD', availability: 'OutOfStock' },
+				],
+			})
+		),
+	],
+	[
+		'offers: @graph with a single offer',
+		soPage(
+			ld({
+				'@graph': [
+					{ '@type': 'BreadcrumbList' },
+					{
+						'@type': ['Product'],
+						'offers': { price: 10, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+					},
+				],
+			})
+		),
+	],
+	[
+		'offers: malformed block then a valid one',
+		soPage(
+			`${rawLd('{ this is not json ')}\n${ld({ '@type': 'Product', 'offers': { price: 5, availability: 'InStock' } })}`
+		),
+	],
+	[
+		'offers: trailing slash on availability',
+		soPage(
+			ld({
+				'@type': 'Product',
+				'offers': { price: 7.5, priceCurrency: 'USD', availability: 'https://schema.org/InStock/' },
+			})
+		),
+	],
+	['offers: none (WebPage only)', soPage(ld({ '@type': 'WebPage' }))],
+	[
+		'offers: 250 products in one @graph (over the cap)',
+		soPage(ld({ '@graph': Array.from({ length: 250 }, (_, i) => ({ '@type': 'Product', 'offers': soffer(i) })) })),
+	],
+	[
+		'offers: a 100k-character price is sliced',
+		soPage(
+			ld({ '@type': 'Product', 'offers': { price: 'x'.repeat(100000), priceCurrency: 'USD', availability: 'InStock' } })
+		),
+	],
+];
+
+// ── the pageFacts suite's fixtures ─────────────────────────────────────────────────────────────
+
+const over = (n: number, c = 'x') => c.repeat(n + 1);
+const PAGE_FACTS_FIXTURES: Array<[string, string]> = [
+	[
+		'facts: head facts',
+		doc(
+			`<title>
+				Blue Widget | Example Store   </title>
+			<link rel="canonical" href="/p/blue-widget?color=blue">
+			<link rel="canonical" href="https://www.example.com/second-canonical-is-ignored">
+			<meta name="Description" content="  A widget, in blue.  ">
+			<meta name="description" content="the first description wins">`,
+			`<h1>
+				Blue
+				<span>Widget</span>&nbsp;<em>\t2000</em>
+			</h1><h1>second h1 is ignored</h1>`
+		),
+	],
+	['facts: empty document', doc('')],
+	[
+		'facts: empty values',
+		doc('<title>   </title><meta name="description" content=""><link rel="canonical">', '<h1>  \n </h1>'),
+	],
+	[
+		'facts: Product with brand object, image array, rating, per-SKU offers',
+		doc(
+			ld({
+				'@context': 'https://schema.org',
+				'@type': 'Product',
+				'name': 'Blue Widget',
+				'brand': { '@type': 'Brand', 'name': 'Example Brand' },
+				'image': ['https://www.example.com/img/1.jpg', 'https://www.example.com/img/2.jpg'],
+				'aggregateRating': { '@type': 'AggregateRating', 'ratingValue': 4.6, 'ratingCount': 212, 'reviewCount': 90 },
+				'offers': [
+					{ sku: 'SKU-B', price: 35.99, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+					{ sku: 1234567, price: '29.99', priceCurrency: 'USD', availability: 'http://schema.org/OutOfStock/' },
+					{ sku: 'SKU-A', price: 0, priceCurrency: 'USD', availability: 'PreOrder' },
+				],
+			})
+		),
+	],
+	[
+		'facts: ProductGroup inside @graph with an AggregateOffer',
+		doc(
+			ld({
+				'@context': 'https://schema.org',
+				'@graph': [
+					{ '@type': 'WebPage', 'name': 'not the product' },
+					{
+						'@type': 'ProductGroup',
+						'name': 'Widget Family',
+						'brand': 'Example Brand',
+						'image': { '@type': 'ImageObject', 'url': 'https://www.example.com/img/family.jpg' },
+						'aggregateRating': { ratingValue: '4.2', reviewCount: '37' },
+						'offers': {
+							'@type': 'AggregateOffer',
+							'lowPrice': 10,
+							'highPrice': 20,
+							'offers': [
+								{ sku: 'S', price: 10, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+								{ sku: 'L', price: 20, priceCurrency: 'USD', availability: 'https://schema.org/LimitedAvailability' },
+							],
+						},
+					},
+				],
+			})
+		),
+	],
+	[
+		'facts: top-level array, @type array, first product wins',
+		doc(
+			ld([
+				{ '@type': 'WebSite', 'name': 'Example Store' },
+				{ '@type': ['Product', 'Thing'], 'name': 'First', 'image': 'https://www.example.com/first.jpg' },
+			]) + ld({ '@type': 'Product', 'name': 'Second' })
+		),
+	],
+	[
+		'facts: malformed, null and string blocks beside valid ones',
+		doc(
+			rawLd('{ "@type": "Product", "name": broken ') +
+				ld({ '@type': 'Product', 'name': 'Survivor', 'offers': { sku: 'X', price: 5, availability: 'InStock' } }) +
+				rawLd('null') +
+				rawLd('"just a string"') +
+				ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Home' }] })
+		),
+	],
+	[
+		'facts: a Product that states nothing else',
+		doc(
+			ld({
+				'@type': 'Product',
+				'brand': { '@type': 'Brand' },
+				'image': [],
+				'aggregateRating': { ratingValue: 'n/a', ratingCount: null },
+				'offers': { '@type': 'AggregateOffer', 'lowPrice': 1, 'highPrice': 9 },
+			})
+		),
+	],
+	['facts: rating value only', doc(ld({ '@type': 'Product', 'aggregateRating': { ratingValue: 5 } }))],
+	[
+		'facts: rating null count falls back to reviewCount',
+		doc(ld({ '@type': 'Product', 'aggregateRating': { ratingValue: '3.5', ratingCount: null, reviewCount: 8 } })),
+	],
+	['facts: rating zero', doc(ld({ '@type': 'Product', 'aggregateRating': { ratingValue: 0, ratingCount: 0 } }))],
+	[
+		'facts: odd offer field types',
+		doc(
+			ld({
+				'@type': 'Product',
+				'offers': [
+					{ price: 12 },
+					{ sku: { nested: true }, price: true, priceCurrency: 840, availability: 42 },
+					'not an offer',
+					null,
+				],
+			})
+		),
+	],
+	[
+		'facts: breadcrumb ordering',
+		doc(
+			ld({
+				'@type': 'BreadcrumbList',
+				'itemListElement': [
+					{ '@type': 'ListItem', 'position': 3, 'item': { '@id': 'https://www.example.com/c/w', 'name': 'Widgets' } },
+					{ '@type': 'ListItem', 'position': '1', 'name': 'Home', 'item': 'https://www.example.com/' },
+					{ '@type': 'ListItem', 'name': 'Unpositioned' },
+					{ '@type': 'ListItem', 'position': 2, 'name': 'Shop', 'item': { name: '' } },
+					{ '@type': 'ListItem', 'position': 4 },
+					{ '@type': 'ListItem', 'position': 5, 'name': 'Element name', 'item': { name: 'Item name' } },
+				],
+			}) + ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'second list is ignored' }] })
+		),
+	],
+	[
+		'facts: breadcrumbs with no named crumbs',
+		doc(ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1 }] })),
+	],
+	[
+		'facts: strings past and at maxString',
+		doc(
+			`<title>${over(PAGE_FACT_BOUNDS.maxString, 'b')}</title><meta name="description" content="${over(PAGE_FACT_BOUNDS.maxString, 'b')}">
+			<link rel="canonical" href="https://www.example.com/${over(PAGE_FACT_BOUNDS.maxString, 'b')}">` +
+				ld({
+					'@type': 'Product',
+					'name': over(PAGE_FACT_BOUNDS.maxString, 'b'),
+					'brand': 'a'.repeat(PAGE_FACT_BOUNDS.maxString),
+					'image': over(PAGE_FACT_BOUNDS.maxString, 'b'),
+				}),
+			`<h1>${over(PAGE_FACT_BOUNDS.maxString, 'b')}</h1>`
+		),
+	],
+	[
+		'facts: exactly maxOffers offers',
+		doc(ld({ '@type': 'Product', 'offers': Array.from({ length: PAGE_FACT_BOUNDS.maxOffers }, (_, i) => foffer(i)) })),
+	],
+	[
+		'facts: maxOffers + 1 across an AggregateOffer',
+		doc(
+			ld({
+				'@type': 'Product',
+				'name': 'Kept',
+				'offers': [
+					foffer(-1),
+					{
+						'@type': 'AggregateOffer',
+						'offers': Array.from({ length: PAGE_FACT_BOUNDS.maxOffers }, (_, i) => foffer(i)),
+					},
+				],
+			})
+		),
+	],
+	['facts: exactly maxBreadcrumbs', doc(crumbs(PAGE_FACT_BOUNDS.maxBreadcrumbs))],
+	['facts: maxBreadcrumbs + 1', doc(crumbs(PAGE_FACT_BOUNDS.maxBreadcrumbs + 1))],
+	[
+		'facts: one overlong breadcrumb name',
+		doc(
+			ld({
+				'@type': 'BreadcrumbList',
+				'itemListElement': [
+					{ position: 1, name: 'Home' },
+					{ position: 2, name: over(PAGE_FACT_BOUNDS.maxString) },
+				],
+			})
+		),
+	],
+	[
+		'facts: offer fields past and at maxOfferField',
+		doc(
+			ld({
+				'@type': 'Product',
+				'offers': [
+					{
+						sku: over(PAGE_FACT_BOUNDS.maxOfferField),
+						price: over(PAGE_FACT_BOUNDS.maxOfferField),
+						priceCurrency: over(PAGE_FACT_BOUNDS.maxOfferField),
+						availability: `https://schema.org/${over(PAGE_FACT_BOUNDS.maxOfferField)}`,
+					},
+					{
+						sku: 'k'.repeat(PAGE_FACT_BOUNDS.maxOfferField),
+						price: '1.00',
+						priceCurrency: 'USD',
+						availability: 'https://schema.org/InStock',
+					},
+				],
+			})
+		),
+	],
+	[
+		'facts: one sku-less offer takes the product sku',
+		doc(
+			ld({
+				'@type': 'Product',
+				'sku': 9001,
+				'offers': { price: 5, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+			})
+		),
+	],
+	[
+		'facts: one aggregated offer with an empty sku',
+		doc(
+			ld({
+				'@type': 'Product',
+				'sku': 'P-1',
+				'offers': { '@type': 'AggregateOffer', 'offers': [{ price: 5, priceCurrency: 'USD', sku: '' }] },
+			})
+		),
+	],
+	['facts: the offer sku wins', doc(ld({ '@type': 'Product', 'sku': 'P-1', 'offers': { sku: 'O-1', price: 5 } }))],
+	[
+		'facts: several offers never take the product sku',
+		doc(ld({ '@type': 'Product', 'sku': 'P-1', 'offers': [{ price: 5 }, { sku: 'O-2', price: 6 }] })),
+	],
+	[
+		'facts: a refused offer sku is not replaced',
+		doc(ld({ '@type': 'Product', 'sku': 'P-1', 'offers': { sku: over(PAGE_FACT_BOUNDS.maxOfferField), price: 5 } })),
+	],
+	[
+		'facts: an overlong inherited sku',
+		doc(ld({ '@type': 'Product', 'sku': over(PAGE_FACT_BOUNDS.maxOfferField, 'y'), 'offers': { price: 5 } })),
+	],
+	[
+		'facts: ProductGroup reads its hasVariant offers',
+		doc(
+			ld({
+				'@type': 'ProductGroup',
+				'name': 'Widget Family',
+				'productGroupID': 'FAM-1',
+				'hasVariant': [
+					variant(
+						'V-S',
+						{ price: 10, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+						{
+							name: 'Widget, small',
+							brand: { '@type': 'Brand', 'name': 'Variant Brand' },
+							image: 'https://www.example.com/img/small.jpg',
+							aggregateRating: { ratingValue: 4, ratingCount: 3 },
+						}
+					),
+					variant('V-L', [
+						{ price: 20, priceCurrency: 'USD', availability: 'https://schema.org/OutOfStock' },
+						{ sku: 'V-L-REFURB', price: 15, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+					]),
+					'not a variant',
+				],
+			})
+		),
+	],
+	[
+		"facts: a ProductGroup's own offers and fields win",
+		doc(
+			ld({
+				'@type': 'ProductGroup',
+				'name': 'Group name',
+				'brand': 'Group Brand',
+				'image': 'https://www.example.com/img/group.jpg',
+				'aggregateRating': { ratingValue: 5, reviewCount: 1 },
+				'offers': { '@type': 'AggregateOffer', 'offers': [{ sku: 'G-1', price: 1 }] },
+				'hasVariant': [variant('V-1', { price: 2 }, { name: 'Variant name', brand: 'Variant Brand' })],
+			})
+		),
+	],
+	[
+		'facts: a ProductGroup value past its bound',
+		doc(
+			ld({
+				'@type': 'ProductGroup',
+				'name': over(PAGE_FACT_BOUNDS.maxString, 'n'),
+				'hasVariant': [variant('V-1', { price: 2 }, { name: 'Variant name' })],
+			})
+		),
+	],
+	[
+		'facts: variant offers over the cap together',
+		doc(
+			ld({
+				'@type': 'ProductGroup',
+				'hasVariant': [
+					variant(
+						'A',
+						Array.from({ length: PAGE_FACT_BOUNDS.maxOffers }, (_, i) => ({ price: i }))
+					),
+					variant('B', [{ price: 0 }]),
+				],
+			})
+		),
+	],
+	[
+		'facts: a refused group never falls through',
+		doc(
+			ld({
+				'@type': 'ProductGroup',
+				'offers': Array.from({ length: PAGE_FACT_BOUNDS.maxOffers + 1 }, (_, i) => ({ price: i })),
+				'hasVariant': [variant('A', { price: 1 })],
+			})
+		),
+	],
+	[
+		'facts: mainEntity object',
+		doc(
+			ld({
+				'@type': 'WebPage',
+				'mainEntity': { '@type': 'Product', 'name': 'Nested', 'offers': { sku: 'N-1', price: 3 } },
+			})
+		),
+	],
+	[
+		'facts: mainEntity array inside @graph',
+		doc(
+			ld({
+				'@context': 'https://schema.org',
+				'@graph': [
+					{
+						'@type': 'ItemPage',
+						'mainEntity': [
+							{ '@type': 'Organization', 'name': 'not it' },
+							{ '@type': 'ProductGroup', 'name': 'Nested group' },
+						],
+					},
+				],
+			})
+		),
+	],
+	[
+		'facts: mainEntityOfPage',
+		doc(ld({ '@type': 'WebPage', 'mainEntityOfPage': { '@type': 'Product', 'name': 'Of page' } })),
+	],
+	[
+		'facts: nested breadcrumb',
+		doc(
+			ld({
+				'@type': 'CollectionPage',
+				'breadcrumb': {
+					'@type': 'BreadcrumbList',
+					'itemListElement': [
+						{ position: 2, name: 'Widgets' },
+						{ position: 1, name: 'Home' },
+					],
+				},
+			})
+		),
+	],
+	[
+		'facts: top-level beats nested',
+		doc(
+			ld({
+				'@type': 'WebPage',
+				'mainEntity': { '@type': 'Product', 'name': 'Nested' },
+				'breadcrumb': { '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Nested crumb' }] },
+			}) +
+				ld({ '@type': 'Product', 'name': 'Top level' }) +
+				ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Top crumb' }] })
+		),
+	],
+	[
+		'facts: one level deep, only under page nodes',
+		doc(
+			ld({
+				'@graph': [
+					{
+						'@type': 'WebPage',
+						'mainEntity': { '@type': 'WebPage', 'mainEntity': { '@type': 'Product', 'name': 'Deep' } },
+					},
+					{
+						'@type': 'Organization',
+						'mainEntity': { '@type': 'Product', 'name': 'Under an organization' },
+						'breadcrumb': { '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'no' }] },
+					},
+					{
+						'@type': 'WebPage',
+						'mainEntityOfPage': 'https://www.example.com/p',
+						'breadcrumb': { itemListElement: [{ position: 1, name: 'untyped' }] },
+					},
+				],
+			})
+		),
+	],
+];
+
+// ── new edge cases: where the two readers' walks DIVERGE, so the shared parse must serve both ──
+
+const EDGE_FIXTURES: Array<[string, string]> = [
+	[
+		// pageFacts stops after block 0 (product + breadcrumbs found); structuredOffers must still read the
+		// later blocks — parsed only for it.
+		'edge: facts stop early, offers read on',
+		doc(
+			ld({
+				'@graph': [
+					{ '@type': 'Product', 'name': 'First', 'offers': { sku: 'A', price: 1, priceCurrency: 'USD' } },
+					{ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Home' }] },
+				],
+			}) +
+				rawLd('{ broken') +
+				ld({ '@type': 'Product', 'name': 'Second', 'offers': [{ price: 2 }, { price: 3, availability: 'InStock' }] }) +
+				ld([{ '@type': 'Product', 'offers': { price: '0.50', priceCurrency: 'EUR' } }])
+		),
+	],
+	[
+		// structuredOffers overflows in block 1; pageFacts still needs block 3 for its breadcrumbs.
+		'edge: offers overflow early, facts read on',
+		doc(
+			ld({ '@type': 'Organization', 'name': 'Example' }) +
+				ld({
+					'@graph': Array.from({ length: STRUCTURED_OFFER_CAP + 1 }, (_, i) => ({
+						'@type': 'Product',
+						'offers': soffer(i),
+					})),
+				}) +
+				ld({ '@type': 'WebSite' }) +
+				ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Late crumb' }] })
+		),
+	],
+	[
+		'edge: exactly the offer cap across two products',
+		doc(
+			ld({
+				'@graph': [
+					{ '@type': 'Product', 'offers': Array.from({ length: 150 }, (_, i) => soffer(i)) },
+					{
+						'@type': 'Product',
+						'offers': Array.from({ length: STRUCTURED_OFFER_CAP - 150 }, (_, i) => soffer(i + 150)),
+					},
+				],
+			})
+		),
+	],
+	[
+		'edge: one offer past the cap across two blocks',
+		doc(
+			ld({ '@type': 'Product', 'offers': Array.from({ length: STRUCTURED_OFFER_CAP }, (_, i) => soffer(i)) }) +
+				ld({ '@type': 'Product', 'offers': soffer(999) })
+		),
+	],
+	[
+		// A ProductGroup is not a `Product` to structuredOffers (null), while pageFacts reads its variants.
+		'edge: ProductGroup — offers see nothing, facts see the variants',
+		doc(
+			ld({
+				'@type': 'ProductGroup',
+				'name': 'Family',
+				'hasVariant': [variant('V1', { price: 4, priceCurrency: 'USD', availability: 'https://schema.org/InStock' })],
+			})
+		),
+	],
+	[
+		'edge: JSON primitives, empty and whitespace blocks',
+		doc(
+			rawLd('') +
+				rawLd('   \n ') +
+				rawLd('42') +
+				rawLd('true') +
+				rawLd('[]') +
+				rawLd('[null, 1, "x", []]') +
+				rawLd('{"@graph": {"@type": "Product", "offers": {"price": 1}}}') +
+				ld({ '@type': 'Product', 'name': 'After the junk', 'offers': { price: 8 } })
+		),
+	],
+	[
+		'edge: over-long strings everywhere',
+		doc(
+			`<title>${'t'.repeat(5000)}</title>` +
+				ld({
+					'@type': 'Product',
+					'name': 'n'.repeat(3000),
+					'sku': 's'.repeat(65),
+					'offers': [
+						{
+							price: 'p'.repeat(100000),
+							priceCurrency: 'c'.repeat(70),
+							availability: `https://schema.org/${'a'.repeat(80)}`,
+						},
+						{ price: 1, priceCurrency: 'USD', availability: 'https://schema.org/InStock' },
+					],
+				}),
+			`<h1>${'h '.repeat(1500)}</h1>`
+		),
+	],
+	[
+		'edge: sort order with nulls, duplicates and non-ASCII',
+		doc(
+			ld({
+				'@type': 'Product',
+				'offers': [
+					{ price: 'Ü', priceCurrency: 'USD' },
+					{ price: 'Z' },
+					{ availability: 'InStock' },
+					{ price: 'Z' },
+					{ price: '10', priceCurrency: 'USD', availability: 'https://schema.org/OutOfStock' },
+					{ price: '9', priceCurrency: 'usd', availability: '/' },
+					{ price: 1e21, priceCurrency: '€', availability: 'https://schema.org/' },
+					{ price: -0, priceCurrency: 'USD', availability: '' },
+				],
+				'aggregateRating': { ratingValue: -0, ratingCount: '  12  ' },
+			})
+		),
+	],
+	[
+		'edge: many small blocks',
+		doc(
+			Array.from({ length: 60 }, (_, i) =>
+				i % 7 === 3
+					? rawLd('{ nope')
+					: ld({ '@type': i % 5 ? 'Thing' : 'Product', 'name': `N${i}`, 'offers': { price: i } })
+			).join('') + ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Last' }] })
+		),
+	],
+];
+
+// ── pages that break one reader: each side must null exactly what it nulled before ─────────────
+
+const hostile = (script: string) =>
+	doc(
+		`<title>Hostile</title><link rel="canonical" href="https://www.example.com/h">` +
+			ld({ '@type': 'Product', 'name': 'H', 'offers': { sku: 'H1', price: 2, priceCurrency: 'USD' } }) +
+			ld({ '@type': 'BreadcrumbList', 'itemListElement': [{ position: 1, name: 'Home' }] }),
+		`<h1>Hostile</h1><script>${script}</script>`
+	);
+const HOSTILE_FIXTURES: Array<[string, string, (c: Claims) => void]> = [
+	[
+		'hostile: document.title throws — facts null, offers kept',
+		hostile(`Object.defineProperty(document, 'title', { get() { throw new Error('hostile'); } });`),
+		(c) => {
+			assert.equal(c.pageFacts, null);
+			assert.deepEqual(c.structuredOffers, ['2', 'USD', null]);
+		},
+	],
+	[
+		'hostile: document.querySelector throws — facts null, offers kept',
+		hostile(`document.querySelector = () => { throw new Error('hostile'); };`),
+		(c) => {
+			assert.equal(c.pageFacts, null);
+			assert.deepEqual(c.structuredOffers, ['2', 'USD', null]);
+		},
+	],
+	[
+		'hostile: Array.prototype.flat throws — offers null, facts kept',
+		hostile(`Array.prototype.flat = function () { throw new Error('hostile'); };`),
+		(c) => {
+			assert.equal(c.structuredOffers, null);
+			assert.equal(c.pageFacts?.product?.name, 'H');
+			assert.deepEqual(c.pageFacts?.breadcrumbs, ['Home']);
+		},
+	],
+	[
+		'hostile: document.querySelectorAll throws — both null',
+		hostile(`document.querySelectorAll = () => { throw new Error('hostile'); };`),
+		(c) => assert.deepEqual(c, { structuredOffers: null, pageFacts: null }),
+	],
+	[
+		'hostile: one block’s textContent throws — that block is skipped by both',
+		hostile(
+			`Object.defineProperty(document.querySelector('script[type="application/ld+json"]'), 'textContent', { get() { throw new Error('hostile'); } });`
+		),
+		(c) => {
+			assert.equal(c.structuredOffers, null, 'the only Product block was unreadable');
+			assert.equal(c.pageFacts?.product, null);
+			assert.deepEqual(c.pageFacts?.breadcrumbs, ['Home']);
+		},
+	],
+];
+
+test('every structuredOffers-suite fixture: merged output is identical to the 1.37.0 pair', async () => {
+	for (const [label, html] of STRUCTURED_OFFERS_FIXTURES) await compare(label, html);
+});
+
+test('every pageFacts-suite fixture: merged output is identical to the 1.37.0 pair', async () => {
+	for (const [label, html] of PAGE_FACTS_FIXTURES) await compare(label, html);
+});
+
+test('edge cases where the two walks diverge: merged output is identical to the 1.37.0 pair', async () => {
+	const results = new Map<string, Claims>();
+	for (const [label, html] of EDGE_FIXTURES) results.set(label, await compare(label, html));
+	// Not vacuous: the divergent walks really did produce both claims.
+	const early = results.get('edge: facts stop early, offers read on')!;
+	assert.equal(early.structuredOffers?.length, 4 * 3, 'offers from blocks past the one facts stopped at');
+	assert.deepEqual(early.pageFacts?.breadcrumbs, ['Home']);
+	const late = results.get('edge: offers overflow early, facts read on')!;
+	assert.equal(late.structuredOffers, null);
+	assert.deepEqual(late.pageFacts?.breadcrumbs, ['Late crumb']);
+});
+
+test('a page that breaks one reader: each claim is null exactly where the 1.37.0 pair made it null', async () => {
+	for (const [label, html, check] of HOSTILE_FIXTURES) check(await compare(label, html));
+});
+
+// ── seeded fuzz ────────────────────────────────────────────────────────────────────────────────
+
+/** mulberry32 — a fixed seed, so a failure reproduces. */
+const prng = (seed: number) => () => {
+	seed = (seed + 0x6d2b79f5) | 0;
+	let t = Math.imul(seed ^ (seed >>> 15), 1 | seed);
+	t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+	return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+};
+
+const fuzzDocuments = (count: number, seed: number): string[] => {
+	const rand = prng(seed);
+	const pick = <T>(xs: readonly T[]): T => xs[Math.floor(rand() * xs.length)];
+	const maybe = (p: number) => rand() < p;
+	const STRINGS = [
+		'Widget',
+		'',
+		'  padded  ',
+		'Ünïcødé ✓',
+		'x'.repeat(64),
+		'x'.repeat(65),
+		'y'.repeat(PAGE_FACT_BOUNDS.maxString),
+		'z'.repeat(PAGE_FACT_BOUNDS.maxString + 1),
+		'a/b/',
+		'35.99',
+		' 4.5 ',
+		'n/a',
+	];
+	const SCALARS = [0, -0, 12.5, 1e21, -3, 1234567, true, false, null, {}, [], { name: 'obj' }];
+	const TYPES = [
+		'Product',
+		'Product',
+		'ProductGroup',
+		'BreadcrumbList',
+		'WebPage',
+		'ItemPage',
+		'CollectionPage',
+		'Organization',
+		'Offer',
+		'AggregateOffer',
+		'Thing',
+		['Product', 'Thing'],
+		['ProductGroup'],
+		['WebPage', 'ItemPage'],
+		undefined,
+		42,
+	];
+	const AVAILABILITY = [
+		'https://schema.org/InStock',
+		'http://schema.org/OutOfStock/',
+		'InStock',
+		'PreOrder',
+		'',
+		'/',
+		'https://schema.org/',
+		42,
+		null,
+		'x'.repeat(70),
+		`https://schema.org/${'x'.repeat(70)}`,
+	];
+	const value = () => (maybe(0.6) ? pick(STRINGS) : pick(SCALARS));
+	const offer = (nested = false): unknown => {
+		if (maybe(0.05)) return pick(['not an offer', null, 7]);
+		const o: Record<string, unknown> = {};
+		if (maybe(0.3)) o['@type'] = pick(['Offer', 'AggregateOffer']);
+		if (maybe(0.85)) o.price = maybe(0.6) ? pick([9.99, 0, -0, '35.99', 1e21, 100, '1,299.00']) : value();
+		if (maybe(0.7)) o.priceCurrency = maybe(0.8) ? pick(['USD', 'EUR', 'usd', '€']) : value();
+		if (maybe(0.7)) o.availability = pick(AVAILABILITY);
+		if (maybe(0.5)) o.sku = maybe(0.7) ? `SKU-${Math.floor(rand() * 50)}` : value();
+		if (!nested && o['@type'] === 'AggregateOffer' && maybe(0.7)) o.offers = offers(true);
+		return o;
+	};
+	const offerCount = () => pick([0, 1, 1, 1, 2, 2, 3, 5, 8, 199, 200, 201]);
+	const offers = (nested = false): unknown => {
+		const list = Array.from({ length: offerCount() }, () => offer(nested));
+		switch (pick(['array', 'array', 'single', 'aggregate', 'mixed', 'absent'])) {
+			case 'single':
+				return list[0] ?? offer(nested);
+			case 'aggregate':
+				return { '@type': 'AggregateOffer', 'lowPrice': 1, 'highPrice': 9, 'offers': maybe(0.8) ? list : undefined };
+			case 'mixed':
+				return [offer(nested), { '@type': 'AggregateOffer', 'offers': list }, ...list.slice(0, 2)];
+			case 'absent':
+				return pick([undefined, null, '', 'string offers']);
+			default:
+				return list;
+		}
+	};
+	const crumbList = (): unknown => {
+		const n = pick([0, 1, 2, 3, 5, 30, 31]);
+		return {
+			'@type': maybe(0.9) ? 'BreadcrumbList' : undefined,
+			'itemListElement': Array.from({ length: n }, (_, i) =>
+				maybe(0.05)
+					? 'junk'
+					: {
+							'@type': 'ListItem',
+							'position': maybe(0.8) ? pick([i + 1, String(i + 1), n - i, 1, null, 'x']) : undefined,
+							'name': maybe(0.8) ? pick([`C${i}`, '', 'Home', 'z'.repeat(PAGE_FACT_BOUNDS.maxString + 1)]) : undefined,
+							'item': maybe(0.4) ? pick([{ name: `Item ${i}` }, { name: '' }, 'https://www.example.com/']) : undefined,
+						}
+			),
+		};
+	};
+	const node = (depth: number): unknown => {
+		if (maybe(0.04)) return pick([null, 'text', 3, []]);
+		const type = pick(TYPES);
+		const n: Record<string, unknown> = { '@type': type };
+		if (maybe(0.7)) n.name = value();
+		if (maybe(0.4)) n.brand = maybe(0.5) ? { '@type': 'Brand', 'name': value() } : value();
+		if (maybe(0.4))
+			n.image = pick([
+				value(),
+				[value(), 'second'],
+				{ '@type': 'ImageObject', 'url': value() },
+				[],
+				[{ url: 'https://www.example.com/i.jpg' }],
+			]);
+		if (maybe(0.4))
+			n.aggregateRating = { ratingValue: value(), ratingCount: maybe(0.5) ? value() : undefined, reviewCount: value() };
+		if (maybe(0.5)) n.sku = maybe(0.6) ? `P-${Math.floor(rand() * 20)}` : value();
+		if (maybe(0.7)) n.offers = offers();
+		if (maybe(0.2) || type === 'ProductGroup')
+			n.hasVariant = Array.from({ length: pick([0, 1, 2, 3]) }, () => node(depth + 1));
+		if (type === 'BreadcrumbList' || maybe(0.1))
+			n.itemListElement = (crumbList() as Record<string, unknown>).itemListElement;
+		if (depth < 2 && maybe(0.25)) n.mainEntity = maybe(0.5) ? node(depth + 1) : [node(depth + 1), node(depth + 1)];
+		if (depth < 2 && maybe(0.15)) n.mainEntityOfPage = maybe(0.6) ? node(depth + 1) : 'https://www.example.com/p';
+		if (depth < 2 && maybe(0.2)) n.breadcrumb = crumbList();
+		return n;
+	};
+	const block = (): string => {
+		switch (pick(['node', 'node', 'node', 'array', 'graph', 'graph', 'malformed', 'primitive', 'graph-object'])) {
+			case 'array':
+				return ld(Array.from({ length: pick([0, 1, 2, 4]) }, () => node(0)));
+			case 'graph':
+				return ld({
+					'@context': 'https://schema.org',
+					'@graph': Array.from({ length: pick([1, 2, 3, 6]) }, () => node(0)),
+				});
+			case 'graph-object':
+				return ld({ '@graph': node(0) });
+			case 'malformed':
+				return rawLd(pick(['{ "@type": "Product", ', '', '   ', '{nope}', '[1,']));
+			case 'primitive':
+				return rawLd(pick(['null', '"str"', '42', 'true', '[]']));
+			default:
+				return ld(node(0));
+		}
+	};
+	const text = () =>
+		pick(['Blue Widget', '', '  spaced   out  ', 'w'.repeat(PAGE_FACT_BOUNDS.maxString + 1), 'Ünïcødé']);
+	return Array.from({ length: count }, () => {
+		const head = [
+			maybe(0.8) ? `<title>${text()}</title>` : '',
+			maybe(0.6) ? `<meta name="${pick(['description', 'Description', 'DESCRIPTION'])}" content="${text()}">` : '',
+			maybe(0.6)
+				? `<link rel="canonical"${maybe(0.9) ? ` href="${pick(['/p/1', 'https://www.example.com/p?a=1', '', '?q=1'])}"` : ''}>`
+				: '',
+			...Array.from({ length: pick([0, 1, 1, 2, 3, 5]) }, block),
+		].join('');
+		const body = maybe(0.7) ? `<h1>${text()} <span>${text()}</span></h1>` : '';
+		return `<head>${head}</head><body>${body}</body>`;
+	});
+};
+
+test('seeded fuzz: 400 generated documents, merged output identical to the 1.37.0 pair on every one', async () => {
+	const documents = fuzzDocuments(400, 0x5eed138);
+	const page = await browser.newPage();
+	const seen = { offers: 0, offersNull: 0, product: 0, productOffers: 0, breadcrumbs: 0, capRefusal: 0 };
+	try {
+		pages.set('/fuzz', doc(''));
+		await page.goto(`${base}/fuzz`, { waitUntil: 'load' });
+		for (let i = 0; i < documents.length; i++) {
+			await page.evaluate((html) => {
+				document.documentElement.innerHTML = html;
+			}, documents[i]);
+			const old = await before137(page);
+			const merged = await after138(page);
+			assertParity(old, merged, `fuzz #${i}`);
+			if (merged.structuredOffers) seen.offers++;
+			else seen.offersNull++;
+			if (merged.pageFacts?.product) seen.product++;
+			if (merged.pageFacts?.product?.offers) seen.productOffers++;
+			if (merged.pageFacts?.breadcrumbs) seen.breadcrumbs++;
+			if (documents[i].split('"price"').length > STRUCTURED_OFFER_CAP && !merged.structuredOffers) seen.capRefusal++;
+		}
+	} finally {
+		await page.close();
+	}
+	// The corpus must actually exercise both readers, not compare a wall of nulls.
+	for (const [what, n] of Object.entries(seen)) assert.ok(n >= 20, `fuzz coverage: only ${n} documents with ${what}`);
+});
+
+// ── the 1.37.0 extractors, VERBATIM (renamed only) ─────────────────────────────────────────────
+// `extractStructuredOffers` from src/renderer.ts and `extractPageFacts` from src/pageFacts.ts at
+// browser 1.37.0. Do not edit: they are the reference the merged extractor is held to.
+
+function legacyStructuredOffers(cap: number): Array<string | null> | null {
+	const triples: Array<Array<string | null>> = [];
+	let overflowed = false;
+	// Field-level byte bound: the cap bounds triple COUNT, so without this a single pathological
+	// field (a megabyte "price" string) would still inflate every posted result for the page. No
+	// legitimate price, currency code, or availability token approaches 64 characters.
+	const bound = (value: string): string | null => (value === '' ? null : value.slice(0, 64));
+	const collect = (node: unknown) => {
+		if (overflowed || !node || typeof node !== 'object') return;
+		const record = node as Record<string, unknown>;
+		const type = record['@type'];
+		const isProduct = type === 'Product' || (Array.isArray(type) && type.includes('Product'));
+		if (!isProduct) return;
+		const raw = record.offers;
+		const list = Array.isArray(raw) ? raw : raw ? [raw] : [];
+		for (const entry of list) {
+			if (!entry || typeof entry !== 'object') continue;
+			if (triples.length >= cap) {
+				overflowed = true;
+				return;
+			}
+			const offer = entry as Record<string, unknown>;
+			// filter(Boolean) before pop: a trailing slash (https://schema.org/InStock/) would
+			// otherwise pop the empty segment and read as no availability at all.
+			const availability =
+				typeof offer.availability === 'string'
+					? bound(offer.availability.split('/').filter(Boolean).pop() ?? '')
+					: null;
+			const price = offer.price === undefined || offer.price === null ? null : bound(String(offer.price));
+			const currency = typeof offer.priceCurrency === 'string' ? bound(offer.priceCurrency) : null;
+			triples.push([price, currency, availability]);
+		}
+	};
+	document.querySelectorAll('script[type="application/ld+json"]').forEach((el) => {
+		if (overflowed) return;
+		let data: unknown;
+		try {
+			data = JSON.parse(el.textContent || '');
+		} catch {
+			return; // one malformed block must not cost the page its other blocks
+		}
+		const graph = (data as Record<string, unknown>)?.['@graph'];
+		const nodes = Array.isArray(data) ? data : Array.isArray(graph) ? graph : [data];
+		for (const node of nodes) {
+			if (overflowed) break;
+			collect(node);
+		}
+	});
+	if (overflowed || !triples.length) return null;
+	// Field-wise, not JSON.stringify per comparison: sorting is O(n log n) COMPARISONS, so
+	// stringifying inside the comparator serialises every triple many times over. Code-unit
+	// comparison, not localeCompare: the whole point of the sort is a sequence that is identical
+	// across renders, and collation varies with the browser's locale/ICU.
+	triples.sort((a, b) => {
+		for (let i = 0; i < 3; i++) {
+			const x = a[i];
+			const y = b[i];
+			if (x === y) continue;
+			if (x === null) return -1;
+			if (y === null) return 1;
+			return x < y ? -1 : 1;
+		}
+		return 0;
+	});
+	return triples.flat();
+}
+
+function legacyPageFacts(bounds: PageFactBounds): PageFacts {
+	type Json = Record<string, unknown>;
+	const isObject = (value: unknown): value is Json => !!value && typeof value === 'object' && !Array.isArray(value);
+	const boundTo =
+		(max: number) =>
+		(value: unknown): string | null =>
+			typeof value !== 'string' || value === '' || value.length > max ? null : value;
+	const str = boundTo(bounds.maxString);
+	const offerField = boundTo(bounds.maxOfferField);
+	const hasType = (node: Json, wanted: string[]) => {
+		const type = node['@type'];
+		return Array.isArray(type) ? type.some((t) => wanted.includes(t as string)) : wanted.includes(type as string);
+	};
+	// A schema.org number may be written as a JSON number or a numeric string ("4.5"). Anything else —
+	// including null, which Number() would silently read as 0 — is no claim.
+	const num = (value: unknown): number | null => {
+		if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+		if (typeof value !== 'string') return null;
+		const trimmed = value.trim();
+		if (!trimmed || trimmed.length > bounds.maxOfferField) return null;
+		const n = Number(trimmed);
+		return Number.isFinite(n) ? n : null;
+	};
+	const listOf = (value: unknown): unknown[] => (Array.isArray(value) ? value : value ? [value] : []);
+
+	const canonicalEl = document.querySelector('link[rel="canonical"]') as HTMLLinkElement | null;
+	const descriptionEl = document.querySelector('meta[name="description" i]');
+	const h1El = document.querySelector('h1');
+
+	// schema.org WebPage and its subtypes: the nodes whose `mainEntity` / `breadcrumb` are searched.
+	const PAGE_TYPES = [
+		'WebPage',
+		'ItemPage',
+		'CollectionPage',
+		'SearchResultsPage',
+		'ProfilePage',
+		'AboutPage',
+		'ContactPage',
+		'FAQPage',
+		'QAPage',
+		'CheckoutPage',
+		'MedicalWebPage',
+		'RealEstateListing',
+		'MediaGallery',
+		'ImageGallery',
+		'VideoGallery',
+	];
+	const PRODUCT_TYPES = ['Product', 'ProductGroup'];
+
+	// A node at the top of a block (or of its @graph) always wins; one found a single level down — a
+	// page node's `mainEntity` / `mainEntityOfPage` / `breadcrumb` — is used only when no top-level node
+	// matched. One level only: this reads what a page states about itself, it does not crawl a graph.
+	let productNode: Json | null = null;
+	let breadcrumbNode: Json | null = null;
+	let nestedProduct: Json | null = null;
+	let nestedBreadcrumb: Json | null = null;
+	const blocks = document.querySelectorAll('script[type="application/ld+json"]');
+	for (let i = 0; i < blocks.length && !(productNode && breadcrumbNode); i++) {
+		let data: unknown;
+		try {
+			data = JSON.parse(blocks[i].textContent || '');
+		} catch {
+			continue; // one malformed block must not cost the page its other blocks
+		}
+		const graph = isObject(data) ? data['@graph'] : undefined;
+		const nodes = Array.isArray(data) ? data : Array.isArray(graph) ? graph : [data];
+		for (const node of nodes) {
+			if (!isObject(node)) continue;
+			if (!productNode && hasType(node, PRODUCT_TYPES)) productNode = node;
+			if (!breadcrumbNode && hasType(node, ['BreadcrumbList'])) breadcrumbNode = node;
+			if (!hasType(node, PAGE_TYPES)) continue;
+			if (!nestedProduct) {
+				for (const entity of listOf(node.mainEntity)) {
+					if (isObject(entity) && hasType(entity, PRODUCT_TYPES)) {
+						nestedProduct = entity;
+						break;
+					}
+				}
+			}
+			const ofPage = node.mainEntityOfPage;
+			if (!nestedProduct && isObject(ofPage) && hasType(ofPage, PRODUCT_TYPES)) nestedProduct = ofPage;
+			const crumb = node.breadcrumb;
+			if (!nestedBreadcrumb && isObject(crumb) && hasType(crumb, ['BreadcrumbList'])) nestedBreadcrumb = crumb;
+		}
+	}
+	productNode = productNode ?? nestedProduct;
+	breadcrumbNode = breadcrumbNode ?? nestedBreadcrumb;
+
+	// A JSON number is stated as its string form ("35.99", "12345"), as structuredOffers states a price.
+	const asString = (value: unknown) => (typeof value === 'number' && Number.isFinite(value) ? String(value) : value);
+	const absent = (value: unknown) => value === undefined || value === null || value === '';
+	const nonEmpty = (value: unknown) => (typeof value === 'string' && value !== '' ? value : undefined);
+
+	// The offer objects a node states, in document order — an AggregateOffer summarises
+	// (lowPrice/highPrice), so only the offers it lists are offers. null when past the bound.
+	const offersOf = (raw: unknown): Json[] | null => {
+		const found: Json[] = [];
+		for (const entry of listOf(raw)) {
+			const list = isObject(entry) && hasType(entry, ['AggregateOffer']) ? listOf(entry.offers) : [entry];
+			for (const offer of list) {
+				if (!isObject(offer)) continue;
+				if (found.length >= bounds.maxOffers) return null;
+				found.push(offer);
+			}
+		}
+		return found;
+	};
+	const tuple = (offer: Json, sku: unknown): PageFactOffer => {
+		// Reduced exactly as extractStructuredOffers reduces it: the last non-empty path segment, so a
+		// trailing slash (https://schema.org/InStock/) still yields the verdict.
+		const availability =
+			typeof offer.availability === 'string' ? (offer.availability.split('/').filter(Boolean).pop() ?? '') : null;
+		return [
+			offerField(asString(sku)),
+			offerField(asString(offer.price)),
+			offerField(offer.priceCurrency),
+			offerField(availability),
+		];
+	};
+
+	const readOffers = (node: Json, variants: Json[]): PageFactOffer[] | null => {
+		const own = offersOf(node.offers);
+		if (own === null) return null; // refused — never fall through to the variants
+		if (own.length) {
+			// A product selling ONE offer often names the SKU on itself rather than on the offer. Only
+			// then: with several offers, the product's SKU names none of them.
+			const inherit = own.length === 1 && absent(own[0].sku);
+			return own.map((offer) => tuple(offer, inherit ? node.sku : offer.sku));
+		}
+		// A ProductGroup usually sells through its variants (`hasVariant`, each a Product with its own
+		// offers and SKU) — read those when the group itself states no offers.
+		const out: PageFactOffer[] = [];
+		for (const variant of variants) {
+			const offers = offersOf(variant.offers);
+			if (offers === null) return null;
+			for (const offer of offers) {
+				if (out.length >= bounds.maxOffers) return null;
+				out.push(tuple(offer, absent(offer.sku) ? variant.sku : offer.sku));
+			}
+		}
+		return out.length ? out : null;
+	};
+
+	// Each field is PICKED raw — from the node, else (for a ProductGroup) its first variant — and only
+	// then bounded, so a value the group states too long is refused rather than swapped for a variant's.
+	const pickBrand = (n: Json) => nonEmpty(isObject(n.brand) ? n.brand.name : n.brand);
+	const pickImage = (n: Json) => {
+		const image = Array.isArray(n.image) ? n.image[0] : n.image;
+		return nonEmpty(isObject(image) ? image.url : image);
+	};
+	const pickRating = (n: Json): [number | null, number | null] | undefined => {
+		const r = n.aggregateRating;
+		if (!isObject(r)) return undefined;
+		const pair: [number | null, number | null] = [num(r.ratingValue), num(r.ratingCount ?? r.reviewCount)];
+		return pair[0] !== null || pair[1] !== null ? pair : undefined;
+	};
+
+	const readProduct = (node: Json): PageFactsProduct => {
+		const variants = hasType(node, ['ProductGroup']) ? listOf(node.hasVariant).filter(isObject) : [];
+		const pick = <T>(from: (n: Json) => T | undefined): T | undefined =>
+			from(node) ?? (variants.length ? from(variants[0]) : undefined);
+		return {
+			name: str(pick((n) => nonEmpty(n.name))),
+			brand: str(pick(pickBrand)),
+			image: str(pick(pickImage)),
+			rating: pick(pickRating) ?? null,
+			offers: readOffers(node, variants),
+		};
+	};
+
+	const readBreadcrumbs = (node: Json): string[] | null => {
+		const crumbs: Array<{ name: string; position: number | null; order: number }> = [];
+		const elements = listOf(node.itemListElement);
+		for (let order = 0; order < elements.length; order++) {
+			const el = elements[order];
+			if (!isObject(el)) continue;
+			const itemName = isObject(el.item) ? el.item.name : undefined;
+			const raw = typeof itemName === 'string' && itemName !== '' ? itemName : el.name;
+			if (typeof raw !== 'string' || raw === '') continue; // an unnamed crumb claims nothing
+			// A name past the bound refuses the whole trail: a trail with a hole in it would disagree.
+			if (raw.length > bounds.maxString) return null;
+			if (crumbs.length >= bounds.maxBreadcrumbs) return null;
+			crumbs.push({ name: raw, position: num(el.position), order });
+		}
+		// Ordered by position; a crumb without one keeps its document order after the positioned ones.
+		crumbs.sort((a, b) =>
+			a.position === b.position
+				? a.order - b.order
+				: a.position === null
+					? 1
+					: b.position === null
+						? -1
+						: a.position - b.position
+		);
+		return crumbs.length ? crumbs.map((c) => c.name) : null;
+	};
+
+	return {
+		canonical: canonicalEl ? str(canonicalEl.href) : null,
+		title: str((document.title || '').trim()),
+		metaDescription: descriptionEl ? str(descriptionEl.getAttribute('content')) : null,
+		h1: h1El ? str((h1El.textContent || '').replace(/\s+/g, ' ').trim()) : null,
+		product: productNode ? readProduct(productNode) : null,
+		breadcrumbs: breadcrumbNode ? readBreadcrumbs(breadcrumbNode) : null,
+	};
+}
diff --git a/packages/browser/test/pageFacts.test.ts b/packages/browser/test/pageFacts.test.ts
index df48eced..9b67a99b 100644
--- a/packages/browser/test/pageFacts.test.ts
+++ b/packages/browser/test/pageFacts.test.ts
@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import http from 'node:http';
 import type { AddressInfo } from 'node:net';
 import puppeteer, { type Browser } from 'puppeteer';
-import { extractPageFacts, PAGE_FACT_BOUNDS } from '../dist/pageFacts.js';
+import { extractPageClaims, PAGE_FACT_BOUNDS, STRUCTURED_OFFER_CAP } from '../dist/pageFacts.js';
 import { renderOnce } from '../dist/renderOnce.js';
 
 /**
@@ -50,7 +50,7 @@ const factsOf = async (html: string) => {
 	const page = await browser.newPage();
 	try {
 		await page.goto(`${base}${path}`, { waitUntil: 'load' });
-		return await page.evaluate(extractPageFacts, PAGE_FACT_BOUNDS);
+		return (await page.evaluate(extractPageClaims, STRUCTURED_OFFER_CAP, PAGE_FACT_BOUNDS)).pageFacts;
 	} finally {
 		await page.close();
 	}
@@ -655,3 +655,43 @@ test('an extraction that throws posts pageFacts: null — present, never a faile
 	assert.notEqual(result.job.pageFacts, undefined);
 	assert.deepEqual(result.job.structuredOffers, ['9.5', 'USD', 'InStock']);
 });
+
+test('an offers reader that throws posts structuredOffers: null — pageFacts still read, never a failed render', async () => {
+	// Both claims come from ONE evaluate now; each reader is caught inside the page, so a throw in the
+	// offers reader (here: the page breaks Array.prototype.flat, which only that reader calls) must cost
+	// the consumer the offers and nothing else — what two separate evaluates gave.
+	pages.set(
+		'/hostile-offers',
+		RENDERED(`${base}/hostile-offers`).replace(
+			'</body>',
+			`<script>Array.prototype.flat = function () { throw new Error('hostile page'); };</script></body>`
+		)
+	);
+	const result = await renderOnce({ url: `${base}/hostile-offers`, config: NO_SCROLL });
+	assert.equal(result.outcome, 'ok');
+	assert.ok(result.html && result.html.length > 0);
+	assert.equal(result.job.structuredOffers, null);
+	assert.notEqual(result.job.structuredOffers, undefined);
+	assert.equal(result.job.pageFacts?.product?.name, 'Blue Widget');
+	assert.deepEqual(result.job.pageFacts?.product?.offers, [['W1', '9.5', 'USD', 'InStock']]);
+});
+
+test('a failure of the extraction evaluate itself posts null for BOTH claims — present, never a failed render', async () => {
+	// No in-page catch can see a result that cannot be returned: the page makes the offers reader's
+	// output cyclic, so the evaluate itself rejects. Both claims are then null (ran, failed benignly),
+	// never absent ("renderer predates it"), and the render still succeeds.
+	pages.set(
+		'/unreturnable',
+		RENDERED(`${base}/unreturnable`).replace(
+			'</body>',
+			`<script>Array.prototype.flat = function () { const a = []; a.push(a); return a; };</script></body>`
+		)
+	);
+	const result = await renderOnce({ url: `${base}/unreturnable`, config: NO_SCROLL });
+	assert.equal(result.outcome, 'ok');
+	assert.ok(result.html && result.html.length > 0);
+	assert.equal(result.job.structuredOffers, null);
+	assert.notEqual(result.job.structuredOffers, undefined);
+	assert.equal(result.job.pageFacts, null);
+	assert.notEqual(result.job.pageFacts, undefined);
+});