@decocms/blocks 7.28.0-beta.5 → 7.28.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/blocks",
-  "version": "7.28.0-beta.5",
+  "version": "7.28.1",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/cms/applySectionConventions.ts

@@ -6,20 +6,23 @@
  * registerSectionsSync, setAsyncRenderingConfig, registerCacheableSections,
  * registerLayoutSections, registerSeoSections, and registerSection.
  */
-import { registerSection, registerSectionsSync } from "./registry";
+import {
+  registerSection,
+  registerSectionsSync,
+} from "./registry";
+import {
+  type CacheableSectionInput,
+  registerCacheableSections,
+  registerLayoutSections,
+} from "./sectionLoaders";
 import {
   type AsyncRenderingConfig,
-  getAsyncRenderingConfig,
   registerEagerSections,
   registerNeverDeferSections,
   registerSeoSections,
   setAsyncRenderingConfig,
+  getAsyncRenderingConfig,
 } from "./resolve";
-import {
-  type CacheableSectionInput,
-  registerCacheableSections,
-  registerLayoutSections,
-} from "./sectionLoaders";
 
 export interface SectionMetaEntry {
   eager?: boolean;
@@ -93,7 +96,8 @@ export function applySectionConventions(input: ApplySectionConventionsInput): vo
   // it, asyncConfig stays null, `useAsync` is false in resolveDecoPage, and
   // even editor-marked ⚡ sections render eagerly. (The default foldThreshold is
   // Infinity, so position-based deferral stays off unless a site opts in.)
-  const existing: Partial<AsyncRenderingConfig> = getAsyncRenderingConfig() ?? {};
+  const existing: Partial<AsyncRenderingConfig> =
+    getAsyncRenderingConfig() ?? {};
   setAsyncRenderingConfig({
     ...existing,
     alwaysEager: [...(existing.alwaysEager ?? []), ...eagerSections],

package/src/cms/blockSource.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, it } from "vitest";
-import { djb2Hex } from "../sdk/djb2";
 import {
   BundledBlockSource,
   computeRevision,
@@ -9,6 +8,7 @@ import {
   revisionKey,
   snapshotKey,
 } from "./blockSource";
+import { djb2Hex } from "../sdk/djb2";
 
 describe("computeRevision", () => {
   it("matches loader.ts computeRevision (djb2Hex of JSON.stringify)", () => {

package/src/cms/client.browserBundle.test.ts

@@ -1,7 +1,7 @@
+import { describe, expect, it } from "vitest";
 import { execFileSync } from "node:child_process";
-import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { describe, expect, it } from "vitest";
+import { dirname, join } from "node:path";
 
 const here = dirname(fileURLToPath(import.meta.url));
 // esbuild's JS API relies on `new TextEncoder().encode("") instanceof

package/src/cms/client.ts

@@ -49,6 +49,8 @@ export {
   registerSectionsSync,
   setResolvedComponent,
 } from "./registry";
+export type { SectionLoaderFn } from "./sectionLoaders";
+export { compose, withDevice, withMobile, withSearchParam, withSectionLoader } from "./sectionMixins";
 export type {
   ActionConfig,
   AppSchemas,
@@ -70,11 +72,3 @@ export {
   registerMatcherSchema,
   registerMatcherSchemas,
 } from "./schema";
-export type { SectionLoaderFn } from "./sectionLoaders";
-export {
-  compose,
-  withDevice,
-  withMobile,
-  withSearchParam,
-  withSectionLoader,
-} from "./sectionMixins";

package/src/cms/index.ts

@@ -12,19 +12,6 @@ export {
   revisionKey,
   snapshotKey,
 } from "./blockSource";
-export type { DraftPointer, ResolveDraftOptions } from "./draftSource";
-export {
-  clearDraftCache,
-  DEFAULT_PREVIEW_API_DOMAINS,
-  getRequestDraftOverride,
-  isDraftHostAllowed,
-  isDraftPreviewEnabled,
-  parseDraftPointer,
-  previewApiOriginForHost,
-  resolveDraftDecofile,
-  setDraftOverrideGetter,
-  setDraftPreviewHosts,
-} from "./draftSource";
 export type { DecoPage, Resolvable } from "./loader";
 export {
   findPageByPath,
@@ -73,6 +60,7 @@ export {
   getAsyncRenderingConfig,
   getDeferredRawProps,
   isBot,
+  isEagerRequest,
   isSeoSection,
   onBeforeResolve,
   reExtractRawProps,
@@ -95,6 +83,8 @@ export {
   unregisterCommerceLoader,
   WELL_KNOWN_TYPES,
 } from "./resolve";
+export type { SectionLoaderContext } from "./sectionLoaderContext";
+export { buildSectionLoaderContext } from "./sectionLoaderContext";
 export type {
   ActionConfig,
   AppSchemas,
@@ -116,8 +106,6 @@ export {
   registerMatcherSchema,
   registerMatcherSchemas,
 } from "./schema";
-export type { SectionLoaderContext } from "./sectionLoaderContext";
-export { buildSectionLoaderContext } from "./sectionLoaderContext";
 export type { SectionLoaderFn } from "./sectionLoaders";
 export {
   getDegradedSections,

package/src/cms/loader.test.ts

@@ -82,12 +82,12 @@ describe("matchPath", () => {
     });
 
     it("matches with an optional prefix before a literal segment", () => {
-      expect(matchPath("/{granado/}?campanhas/*", "/granado/campanhas/destaques-2023")).toEqual({
-        "0": "destaques-2023",
-      });
-      expect(matchPath("/{granado/}?campanhas/*", "/campanhas/destaques-2023")).toEqual({
-        "0": "destaques-2023",
-      });
+      expect(
+        matchPath("/{granado/}?campanhas/*", "/granado/campanhas/destaques-2023"),
+      ).toEqual({ "0": "destaques-2023" });
+      expect(
+        matchPath("/{granado/}?campanhas/*", "/campanhas/destaques-2023"),
+      ).toEqual({ "0": "destaques-2023" });
     });
 
     it("matches an optional suffix group present and absent", () => {
@@ -112,7 +112,9 @@ describe("matchPath", () => {
       // biome-ignore lint/performance/noDelete: restoring exact global state
       delete g.URLPattern;
       try {
-        expect(() => matchPath("/foo/:slug", "/foo/bar")).toThrow(/URLPattern.*Node\.js >= 24/s);
+        expect(() => matchPath("/foo/:slug", "/foo/bar")).toThrow(
+          /URLPattern.*Node\.js >= 24/s,
+        );
       } finally {
         if (saved !== undefined) g.URLPattern = saved;
       }

package/src/cms/loader.ts

@@ -1,6 +1,5 @@
 import * as asyncHooks from "node:async_hooks";
 import { djb2Hex } from "../sdk/djb2";
-import { getRequestDraftOverride } from "./draftSource";
 
 export type Resolvable = {
   __resolveType?: string;
@@ -87,8 +86,7 @@ export function setBlocks(blocks: Record<string, unknown>) {
 
 /**
  * Load the current blocks. If running inside a `withBlocksOverride` scope
- * (admin preview) or a request carrying a draft-preview override, that
- * override is merged on top of the base blocks.
+ * (admin preview), the override is merged on top of the base blocks.
  */
 export function loadBlocks(): Record<string, unknown> {
   // Re-sync from globalThis in case setBlocks was called in another module instance
@@ -97,10 +95,7 @@ export function loadBlocks(): Record<string, unknown> {
     revision = G.__deco.revision ?? null;
   }
 
-  // `withBlocksOverride` (an explicit admin render of a specific payload) wins
-  // over an ambient draft: the caller named the exact blocks to render, so a
-  // draft pointer on the same request must not silently replace them.
-  const override = blocksOverrideStorage.getStore() ?? getRequestDraftOverride();
+  const override = blocksOverrideStorage.getStore();
   if (override) {
     const merged = { ...blockData };
     for (const [key, value] of Object.entries(override)) {
@@ -208,14 +203,12 @@ export function getAllPages(): Array<{ key: string; page: DecoPage }> {
 // same regardless of whether @types/node has its own `URLPattern` global or
 // not — there's nothing for a local declaration to collide with.
 type MatchPatternResult = {
-  pathname: { groups: Record<string, string | undefined> };
+	pathname: { groups: Record<string, string | undefined> };
 };
 declare const URLPattern: {
-  new (init: {
-    pathname: string;
-  }): {
-    exec(input: { pathname: string }): MatchPatternResult | null;
-  };
+	new (init: { pathname: string }): {
+		exec(input: { pathname: string }): MatchPatternResult | null;
+	};
 };
 
 /**
@@ -238,7 +231,10 @@ declare const URLPattern: {
  * `URLPattern` is native in browsers, workerd, Deno, and Node >= 24 (this
  * package's `engines` floor). Node 22 and older lack it.
  */
-export function matchPath(pattern: string, urlPath: string): Record<string, string> | null {
+export function matchPath(
+  pattern: string,
+  urlPath: string,
+): Record<string, string> | null {
   if (typeof URLPattern === "undefined") {
     throw new Error(
       "@decocms/blocks: this runtime has no URLPattern Web API, so CMS page " +

package/src/cms/registry.test.ts

@@ -1,11 +1,11 @@
-import { beforeEach, describe, expect, it } from "vitest";
+import { describe, expect, it, beforeEach } from "vitest";
 import {
-  getResolvedComponent,
+  registerSection,
+  registerSectionsSync,
   getSection,
   getSectionOptions,
   getSyncComponent,
-  registerSection,
-  registerSectionsSync,
+  getResolvedComponent,
 } from "./registry";
 
 // Reset globalThis.__deco between tests to avoid cross-test pollution
@@ -34,36 +34,44 @@ describe("registerSection + getSection", () => {
 describe("registerSection with options", () => {
   it("stores loadingFallback in section options", () => {
     const fallback = () => null;
-    registerSection("site/sections/Shelf.tsx", async () => ({ default: () => null }), {
-      loadingFallback: fallback,
-    });
+    registerSection(
+      "site/sections/Shelf.tsx",
+      async () => ({ default: () => null }),
+      { loadingFallback: fallback },
+    );
 
     const opts = getSectionOptions("site/sections/Shelf.tsx");
     expect(opts?.loadingFallback).toBe(fallback);
   });
 
   it("stores clientOnly flag in section options", () => {
-    registerSection("site/sections/Analytics.tsx", async () => ({ default: () => null }), {
-      clientOnly: true,
-    });
+    registerSection(
+      "site/sections/Analytics.tsx",
+      async () => ({ default: () => null }),
+      { clientOnly: true },
+    );
 
     const opts = getSectionOptions("site/sections/Analytics.tsx");
     expect(opts?.clientOnly).toBe(true);
   });
 
   it("clientOnly defaults to undefined when not set", () => {
-    registerSection("site/sections/Normal.tsx", async () => ({ default: () => null }), {
-      loadingFallback: () => null,
-    });
+    registerSection(
+      "site/sections/Normal.tsx",
+      async () => ({ default: () => null }),
+      { loadingFallback: () => null },
+    );
 
     const opts = getSectionOptions("site/sections/Normal.tsx");
     expect(opts?.clientOnly).toBeUndefined();
   });
 
   it("clientOnly false is preserved", () => {
-    registerSection("site/sections/Explicit.tsx", async () => ({ default: () => null }), {
-      clientOnly: false,
-    });
+    registerSection(
+      "site/sections/Explicit.tsx",
+      async () => ({ default: () => null }),
+      { clientOnly: false },
+    );
 
     const opts = getSectionOptions("site/sections/Explicit.tsx");
     expect(opts?.clientOnly).toBe(false);

package/src/cms/registry.ts

@@ -1,6 +1,8 @@
 import type { ComponentType } from "react";
 
-export type OnBeforeResolveProps = (props: Record<string, unknown>) => Record<string, unknown>;
+export type OnBeforeResolveProps = (
+  props: Record<string, unknown>,
+) => Record<string, unknown>;
 
 export type SectionModule = {
   default: ComponentType<any>;
@@ -33,7 +35,8 @@ if (!G.__deco.sectionRegistry) G.__deco.sectionRegistry = {};
 if (!G.__deco.sectionOptions) G.__deco.sectionOptions = {};
 if (!G.__deco.resolvedComponents) G.__deco.resolvedComponents = {};
 if (!G.__deco.syncComponents) G.__deco.syncComponents = {};
-if (!G.__deco.onBeforeResolvePropsRegistry) G.__deco.onBeforeResolvePropsRegistry = {};
+if (!G.__deco.onBeforeResolvePropsRegistry)
+  G.__deco.onBeforeResolvePropsRegistry = {};
 
 const registry: Record<string, RegistryEntry> = G.__deco.sectionRegistry;
 const sectionOptions: Record<string, SectionOptions> = G.__deco.sectionOptions;
@@ -191,7 +194,9 @@ export function registerSectionsSync(sections: Record<string, SyncSectionEntry>)
     ];
     const component =
       typeof raw === "function" ||
-      (raw != null && typeof raw === "object" && REACT_WRAPPERS.includes((raw as any).$$typeof))
+      (raw != null &&
+        typeof raw === "object" &&
+        REACT_WRAPPERS.includes((raw as any).$$typeof))
         ? raw
         : undefined;
     if (!component) {
@@ -224,12 +229,17 @@ export function getSyncComponent(key: string): ComponentType<any> | undefined {
  * BEFORE the resolution engine resolves them. Use to extract metadata from
  * resolvable structures that would be lost after resolution.
  */
-export function registerOnBeforeResolveProps(sectionKey: string, fn: OnBeforeResolveProps): void {
+export function registerOnBeforeResolveProps(
+  sectionKey: string,
+  fn: OnBeforeResolveProps,
+): void {
   onBeforeResolvePropsRegistry[sectionKey] = fn;
 }
 
 /** Get the registered onBeforeResolveProps for a section, if any. */
-export function getOnBeforeResolveProps(sectionKey: string): OnBeforeResolveProps | undefined {
+export function getOnBeforeResolveProps(
+  sectionKey: string,
+): OnBeforeResolveProps | undefined {
   return onBeforeResolvePropsRegistry[sectionKey];
 }
 

package/src/cms/resolve.test.ts

@@ -20,10 +20,6 @@ vi.mock("./registry", () => ({
   getOnBeforeResolveProps: vi.fn(),
 }));
 
-import { normalizeUrlsInObject } from "../sdk/normalizeUrls";
-import { findPageByPath } from "./loader";
-import { getSection } from "./registry";
-import type { AsyncRenderingConfig, DeferredSection } from "./resolve";
 import {
   clearCommerceLoaders,
   DEFAULT_FOLD_THRESHOLD,
@@ -33,8 +29,8 @@ import {
   registerCommerceLoader,
   registerEagerSections,
   registerNeverDeferSections,
-  resolveDecoPage,
   resolveDeferredSectionFull,
+  resolveDecoPage,
   resolvePageSeoBlock,
   resolveSectionsList,
   resolveValue,
@@ -43,6 +39,10 @@ import {
   WELL_KNOWN_TYPES,
 } from "./resolve";
 import { runSingleSectionLoader } from "./sectionLoaders";
+import { normalizeUrlsInObject } from "../sdk/normalizeUrls";
+import { findPageByPath } from "./loader";
+import { getSection } from "./registry";
+import type { AsyncRenderingConfig, DeferredSection } from "./resolve";
 
 describe("resolveDeferredSectionFull", () => {
   it("resolves a deferred section and preserves index", async () => {
@@ -217,10 +217,14 @@ describe("commerce loader auto-injects URL search params as props", () => {
       return null;
     });
 
-    await resolveValue({ __resolveType: KEY, slug: "sabonete" }, undefined, {
-      url: "https://store.com/produto/sabonete/p?skuId=12345&size=M",
-      path: "/produto/sabonete/p",
-    });
+    await resolveValue(
+      { __resolveType: KEY, slug: "sabonete" },
+      undefined,
+      {
+        url: "https://store.com/produto/sabonete/p?skuId=12345&size=M",
+        path: "/produto/sabonete/p",
+      },
+    );
 
     expect(calls).toHaveLength(1);
     expect(calls[0]).toMatchObject({
@@ -239,10 +243,11 @@ describe("commerce loader auto-injects URL search params as props", () => {
       return null;
     });
 
-    await resolveValue({ __resolveType: KEY, skuId: "cms-locked-sku" }, undefined, {
-      url: "https://store.com/p?skuId=url-value",
-      path: "/p",
-    });
+    await resolveValue(
+      { __resolveType: KEY, skuId: "cms-locked-sku" },
+      undefined,
+      { url: "https://store.com/p?skuId=url-value", path: "/p" },
+    );
 
     expect(calls[0]?.skuId).toBe("cms-locked-sku");
   });
@@ -353,10 +358,7 @@ describe("commerce loader resolves legacy .ts-suffixed resolveType", () => {
     await resolveValue(
       { __resolveType: "shopify/loaders/ProductDetailsPage.ts", slug: "oversize-t-shirt-123" },
       undefined,
-      {
-        url: "https://store.com/products/oversize-t-shirt-123",
-        path: "/products/oversize-t-shirt-123",
-      },
+      { url: "https://store.com/products/oversize-t-shirt-123", path: "/products/oversize-t-shirt-123" },
     );
 
     expect(calls).toHaveLength(1);
@@ -507,9 +509,9 @@ describe("isEagerRequest — programmatic fetch detection", () => {
   });
 
   it("falls back to matcherCtx.headers when no Request is present", () => {
-    expect(isEagerRequest({ userAgent: HUMAN_UA, headers: { "sec-fetch-dest": "empty" } })).toBe(
-      true,
-    );
+    expect(
+      isEagerRequest({ userAgent: HUMAN_UA, headers: { "sec-fetch-dest": "empty" } }),
+    ).toBe(true);
   });
 
   it("a request with no Sec-Fetch headers stays deferred (no UA bot, no override)", () => {
@@ -621,6 +623,104 @@ describe("resolvePageSeoBlock — bot-aware commerce SEO", () => {
   });
 });
 
+describe("resolvePageSeoBlock — per-section ignoreStructuredData drives the fetch-skip", () => {
+  const KEY = "site/loaders/__test/plpSeoLoader";
+  const HUMAN_UA =
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120 Safari/537.36";
+  const BOT_UA = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+
+  // PLP toggle lives under `configJsonLD`; PDP toggle is top-level.
+  const plpBlock = {
+    __resolveType: "commerce/sections/Seo/SeoPLPV2.tsx",
+    title: "Escolar",
+    jsonLD: { __resolveType: KEY },
+    configJsonLD: { ignoreStructuredData: true },
+  };
+  const pdpBlock = {
+    __resolveType: "commerce/sections/Seo/SeoPDPV2.tsx",
+    title: "Produto",
+    jsonLD: { __resolveType: KEY },
+    ignoreStructuredData: true,
+  };
+
+  const rctx = (userAgent?: string) =>
+    ({
+      matcherCtx: { userAgent, url: "https://store.com/escolar", path: "/escolar" },
+      memo: new Map(),
+      depth: 0,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }) as any;
+
+  beforeEach(() => {
+    clearCommerceLoaders();
+    // The per-section toggle is the PRIMARY lever — it must work with the
+    // site-wide botAwareSeo shortcut OFF.
+    setAsyncRenderingConfig({ botAwareSeo: false });
+  });
+  afterEach(() => {
+    clearCommerceLoaders();
+    setAsyncRenderingConfig({ botAwareSeo: false });
+  });
+
+  it("humans: toggle skips the commerce loader (PLP configJsonLD)", async () => {
+    let calls = 0;
+    registerCommerceLoader(KEY, async () => {
+      calls++;
+      return { seo: { title: "Rich SEO title" }, products: [{ id: 1 }] };
+    });
+
+    const res = await resolvePageSeoBlock(plpBlock, rctx(HUMAN_UA));
+
+    expect(calls).toBe(0); // no product fetch for humans
+    expect(res?.props).toHaveProperty("title", "Escolar");
+    expect(res?.props).not.toHaveProperty("jsonLD");
+  });
+
+  it("bots: toggle still resolves the commerce loader (PLP configJsonLD)", async () => {
+    let calls = 0;
+    registerCommerceLoader(KEY, async () => {
+      calls++;
+      return { seo: { title: "Rich SEO title" }, products: [{ id: 1 }] };
+    });
+
+    const res = await resolvePageSeoBlock(plpBlock, rctx(BOT_UA));
+
+    expect(calls).toBe(1);
+    expect(res?.props?.jsonLD).toMatchObject({ seo: { title: "Rich SEO title" } });
+  });
+
+  it("humans: top-level toggle skips the commerce loader (PDP)", async () => {
+    let calls = 0;
+    registerCommerceLoader(KEY, async () => {
+      calls++;
+      return { seo: { title: "Rich SEO title" }, product: { id: 1 } };
+    });
+
+    const res = await resolvePageSeoBlock(pdpBlock, rctx(HUMAN_UA));
+
+    expect(calls).toBe(0);
+    expect(res?.props).not.toHaveProperty("jsonLD");
+  });
+
+  it("toggle OFF: humans keep the full SEO even with botAwareSeo off (no regression)", async () => {
+    let calls = 0;
+    registerCommerceLoader(KEY, async () => {
+      calls++;
+      return { seo: { title: "Rich SEO title" }, products: [{ id: 1 }] };
+    });
+
+    const noToggle = {
+      __resolveType: "commerce/sections/Seo/SeoPLPV2.tsx",
+      title: "Escolar",
+      jsonLD: { __resolveType: KEY },
+    };
+    const res = await resolvePageSeoBlock(noToggle, rctx(HUMAN_UA));
+
+    expect(calls).toBe(1); // no toggle + no global flag → resolve for everyone
+    expect(res?.props?.jsonLD).toMatchObject({ seo: { title: "Rich SEO title" } });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // resolveDecoPage — #277 client-side navigation disables deferral
 // ---------------------------------------------------------------------------
@@ -646,6 +746,20 @@ describe("extractSeoFromProps — commerce jsonLD structured data", () => {
     ...overrides,
   });
 
+  const pdp = (overrides: Record<string, unknown> = {}) => ({
+    "@type": "ProductDetailsPage",
+    breadcrumbList: {
+      "@type": "BreadcrumbList",
+      itemListElement: [
+        { "@type": "ListItem", position: 1, item: "https://x.com/a" },
+        { "@type": "ListItem", position: 2, item: "https://x.com/a/p" },
+      ],
+    },
+    product: { "@type": "Product", name: "P1", image: [{ url: "https://x.com/p.jpg" }] },
+    seo: { title: "PDP Title", description: "PDP Desc" },
+    ...overrides,
+  });
+
   it("derives title/description/canonical and emits the ItemList JSON-LD (PLP)", () => {
     // The casaevideo.com.br/eletroportateis regression: a page.seo pointing at
     // commerce/sections/Seo/SeoPLPV2.tsx resolved its jsonLD but emitted no
@@ -693,7 +807,7 @@ describe("extractSeoFromProps — commerce jsonLD structured data", () => {
     expect(seo.jsonLDs).toHaveLength(1);
   });
 
-  it("omits structured data when ignoreStructuredData is set", () => {
+  it("omits structured data for humans when ignoreStructuredData is set", () => {
     const seo = extractSeoFromProps({
       jsonLD: plp(),
       configJsonLD: { ignoreStructuredData: true },
@@ -703,6 +817,35 @@ describe("extractSeoFromProps — commerce jsonLD structured data", () => {
     expect(seo.title).toBe("PLP Title");
   });
 
+  it("keeps structured data for bots even when ignoreStructuredData is set", () => {
+    // Bot-aware: the toggle suppresses JSON-LD for humans only. Crawlers (and the
+    // `?__deco_ssr=1` audit override, both surfaced via isEager) still get it.
+    const seo = extractSeoFromProps(
+      { jsonLD: plp(), configJsonLD: { ignoreStructuredData: true } },
+      { isEager: true },
+    );
+    expect(seo.jsonLDs).toHaveLength(1);
+    expect(seo.title).toBe("PLP Title");
+  });
+
+  it("omits structured data for bots too when the listing is empty", () => {
+    // ignoreStructuredData is bot-aware, but an empty listing contributes no
+    // ItemList regardless of bot status.
+    const seo = extractSeoFromProps(
+      { jsonLD: plp({ products: [] }), configJsonLD: { ignoreStructuredData: true } },
+      { isEager: true },
+    );
+    expect(seo.jsonLDs).toBeUndefined();
+  });
+
+  it("keeps PDP structured data for bots with top-level ignoreStructuredData", () => {
+    const seo = extractSeoFromProps(
+      { jsonLD: pdp(), ignoreStructuredData: true },
+      { isEager: true },
+    );
+    expect(seo.jsonLDs).toHaveLength(1);
+  });
+
   it("marks an empty listing noIndexing and emits no ItemList", () => {
     const seo = extractSeoFromProps({ jsonLD: plp({ products: [] }) });
     expect(seo.noIndexing).toBe(true);