@decocms/blocks 7.27.0 → 7.28.0-beta.0

package/package.json

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

package/src/cms/draftSource.test.ts

@@ -0,0 +1,201 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import {
+  buildDraftOrigin,
+  clearDraftCache,
+  isDraftPreviewEnabled,
+  parseDraftPointer,
+  resolveDraftDecofile,
+} from "./draftSource";
+
+const ENV_ON = {
+  DECO_DRAFT_PREVIEW: "1",
+  DECO_SANDBOX_ORIGIN_SUFFIXES: ".preview-studio.decocms.com",
+};
+
+function jsonResponse(body: unknown, init?: ResponseInit): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+    ...init,
+  });
+}
+
+beforeEach(() => {
+  clearDraftCache();
+});
+
+describe("parseDraftPointer", () => {
+  it("parses handle@version", () => {
+    expect(parseDraftPointer("gimenes-abc123@ff00")).toEqual({
+      handle: "gimenes-abc123",
+      version: "ff00",
+    });
+  });
+
+  it("rejects more than one @", () => {
+    // A naive split("@") accepts this and silently uses the first two
+    // segments — the exact hole found while spiking the fetch path.
+    expect(parseDraftPointer("a@b@c")).toBeNull();
+  });
+
+  it("rejects a handle that could escape the authority", () => {
+    expect(parseDraftPointer("evil.com/x@v1")).toBeNull();
+    expect(parseDraftPointer("user:pw@v1")).toBeNull();
+    expect(parseDraftPointer("a/../b@v1")).toBeNull();
+    expect(parseDraftPointer(".leading-dot@v1")).toBeNull();
+  });
+
+  it("rejects empty halves and missing input", () => {
+    expect(parseDraftPointer("@v1")).toBeNull();
+    expect(parseDraftPointer("handle@")).toBeNull();
+    expect(parseDraftPointer("handle")).toBeNull();
+    expect(parseDraftPointer(null)).toBeNull();
+    expect(parseDraftPointer("")).toBeNull();
+  });
+});
+
+describe("buildDraftOrigin", () => {
+  it("builds https from the configured suffix", () => {
+    expect(buildDraftOrigin("abc", [".preview-studio.decocms.com"])).toBe(
+      "https://abc.preview-studio.decocms.com",
+    );
+  });
+
+  it("uses http for a localhost suffix (local e2e)", () => {
+    expect(buildDraftOrigin("abc", [".localhost:3200"])).toBe("http://abc.localhost:3200");
+  });
+
+  it("returns null with no configured suffix — never guesses an origin", () => {
+    expect(buildDraftOrigin("abc", [])).toBeNull();
+  });
+});
+
+describe("isDraftPreviewEnabled", () => {
+  it("needs both the flag and a suffix", () => {
+    expect(isDraftPreviewEnabled(ENV_ON)).toBe(true);
+    expect(isDraftPreviewEnabled({ DECO_DRAFT_PREVIEW: "1" })).toBe(false);
+    expect(
+      isDraftPreviewEnabled({
+        DECO_SANDBOX_ORIGIN_SUFFIXES: ".preview-studio.decocms.com",
+      }),
+    ).toBe(false);
+    expect(isDraftPreviewEnabled({})).toBe(false);
+  });
+});
+
+describe("resolveDraftDecofile", () => {
+  it("fetches the sandbox decofile and returns it", async () => {
+    const calls: string[] = [];
+    const blocks = await resolveDraftDecofile({
+      pointer: "abc@v1",
+      env: ENV_ON,
+      fetchImpl: (async (url: string) => {
+        calls.push(String(url));
+        return jsonResponse({ "pages-home": { title: "draft" } });
+      }) as unknown as typeof fetch,
+    });
+
+    expect(blocks).toEqual({ "pages-home": { title: "draft" } });
+    expect(calls).toEqual(["https://abc.preview-studio.decocms.com/_sandbox/decofile"]);
+  });
+
+  it("is inert unless explicitly enabled — no fetch at all", async () => {
+    let called = false;
+    const blocks = await resolveDraftDecofile({
+      pointer: "abc@v1",
+      env: { DECO_SANDBOX_ORIGIN_SUFFIXES: ".preview-studio.decocms.com" },
+      fetchImpl: (async () => {
+        called = true;
+        return jsonResponse({});
+      }) as unknown as typeof fetch,
+    });
+
+    expect(blocks).toBeNull();
+    expect(called).toBe(false);
+  });
+
+  it("caches by version — one fetch per version, not per request", async () => {
+    let fetches = 0;
+    const fetchImpl = (async () => {
+      fetches++;
+      return jsonResponse({ n: fetches });
+    }) as unknown as typeof fetch;
+
+    const a = await resolveDraftDecofile({ pointer: "abc@v1", env: ENV_ON, fetchImpl });
+    const b = await resolveDraftDecofile({ pointer: "abc@v1", env: ENV_ON, fetchImpl });
+    expect(fetches).toBe(1);
+    expect(b).toBe(a);
+
+    await resolveDraftDecofile({ pointer: "abc@v2", env: ENV_ON, fetchImpl });
+    expect(fetches).toBe(2);
+  });
+
+  it("bounds the cache so multi-MB decofiles can't accumulate", async () => {
+    let fetches = 0;
+    const fetchImpl = (async () => {
+      fetches++;
+      return jsonResponse({ n: fetches });
+    }) as unknown as typeof fetch;
+
+    for (const v of ["v1", "v2", "v3", "v4"]) {
+      await resolveDraftDecofile({ pointer: `abc@${v}`, env: ENV_ON, fetchImpl });
+    }
+    expect(fetches).toBe(4);
+
+    // v1 was evicted (cap is 3), so it must re-fetch rather than serve stale.
+    await resolveDraftDecofile({ pointer: "abc@v1", env: ENV_ON, fetchImpl });
+    expect(fetches).toBe(5);
+
+    // v4 is still resident.
+    await resolveDraftDecofile({ pointer: "abc@v4", env: ENV_ON, fetchImpl });
+    expect(fetches).toBe(5);
+  });
+
+  it("degrades to published on a malformed pointer, without fetching", async () => {
+    let called = false;
+    const blocks = await resolveDraftDecofile({
+      pointer: "a@b@c",
+      env: ENV_ON,
+      fetchImpl: (async () => {
+        called = true;
+        return jsonResponse({});
+      }) as unknown as typeof fetch,
+    });
+    expect(blocks).toBeNull();
+    expect(called).toBe(false);
+  });
+
+  it("degrades to published on a non-2xx sandbox", async () => {
+    const blocks = await resolveDraftDecofile({
+      pointer: "abc@v1",
+      env: ENV_ON,
+      fetchImpl: (async () => new Response("nope", { status: 404 })) as unknown as typeof fetch,
+    });
+    expect(blocks).toBeNull();
+  });
+
+  it("degrades to published when the sandbox is unreachable", async () => {
+    const blocks = await resolveDraftDecofile({
+      pointer: "abc@v1",
+      env: ENV_ON,
+      fetchImpl: (async () => {
+        throw new Error("ECONNREFUSED");
+      }) as unknown as typeof fetch,
+    });
+    expect(blocks).toBeNull();
+  });
+
+  it("degrades to published on an unparseable body", async () => {
+    const blocks = await resolveDraftDecofile({
+      pointer: "abc@v1",
+      env: ENV_ON,
+      fetchImpl: (async () =>
+        new Response("<html>not json</html>", {
+          status: 200,
+          headers: { "content-type": "text/html" },
+        })) as unknown as typeof fetch,
+    });
+    expect(blocks).toBeNull();
+  });
+});

package/src/cms/draftSource.ts

@@ -0,0 +1,197 @@
+/**
+ * Draft preview — pull-based decofile override.
+ *
+ * A Studio sandbox serves the working-tree draft at
+ * `GET <origin>/_sandbox/decofile`; a production site pulls it and renders its
+ * own real pages against it. This replaces pushing the decofile into a POST
+ * body, which only deco's own runtime honours — Next.js and most frameworks
+ * render on GET only.
+ *
+ * This module is the framework-agnostic half: pointer parsing, origin
+ * construction, fetching, and version caching. Binding a resolved draft to a
+ * request is framework-specific (see `@decocms/nextjs`'s draft wiring) and
+ * reaches this module through {@link setDraftOverrideGetter} — the same
+ * dependency-injection shape as `setFastDeployKVGetter`, so `blocks` keeps its
+ * zero-dependency direction.
+ *
+ * Inert unless BOTH `DECO_DRAFT_PREVIEW=1` and `DECO_SANDBOX_ORIGIN_SUFFIXES`
+ * are set, mirroring Fast Deploy's opt-in: upgrading the package must never be
+ * enough to start fetching from the network and rendering unpublished content.
+ */
+
+/** A parsed `<handle>@<version>` draft pointer. */
+export interface DraftPointer {
+  /** Sandbox handle — the subdomain under a configured origin suffix. */
+  handle: string;
+  /** Content version (the daemon's ETag). Immutable, so safe to cache on. */
+  version: string;
+}
+
+/**
+ * Sandbox handles are `[a-z0-9-]`, always leading with an alphanumeric.
+ *
+ * Validated BEFORE the handle is interpolated into an authority, so it cannot
+ * smuggle `/`, `@`, `:` or userinfo into the URL and redirect the fetch at some
+ * other host.
+ */
+const HANDLE_RE = /^[a-zA-Z0-9][a-zA-Z0-9-]*$/;
+
+/**
+ * Parse `<handle>@<version>`.
+ *
+ * Requires EXACTLY one `@`: a naive `split("@")` accepts `a@b@c` and silently
+ * uses the first two segments, which is how a malformed pointer sneaks past
+ * validation. Returns null on anything unexpected — callers fall back to
+ * published content.
+ */
+export function parseDraftPointer(raw: string | null | undefined): DraftPointer | null {
+  if (!raw) return null;
+  const parts = raw.split("@");
+  if (parts.length !== 2) return null;
+  const [handle, version] = parts;
+  if (!handle || !version) return null;
+  if (!HANDLE_RE.test(handle)) return null;
+  return { handle, version };
+}
+
+/** Configured suffixes, e.g. `.preview-studio.decocms.com,.localhost:3200`. */
+function readSuffixes(env: Record<string, string | undefined>): string[] {
+  return (env.DECO_SANDBOX_ORIGIN_SUFFIXES ?? "")
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Build the sandbox origin for a handle.
+ *
+ * The origin comes from CONFIGURED suffixes, never from caller input, so there
+ * is no SSRF surface to defend and no allowlist to keep correct. A `localhost`
+ * suffix (local e2e) speaks http; everything else is https.
+ */
+export function buildDraftOrigin(handle: string, suffixes: string[]): string | null {
+  const suffix = suffixes[0];
+  if (!suffix) return null;
+  if (!HANDLE_RE.test(handle)) return null;
+  const scheme = suffix.includes("localhost") ? "http" : "https";
+  return `${scheme}://${handle}${suffix}`;
+}
+
+/**
+ * Version cache.
+ *
+ * Bounded on purpose: a decofile is routinely multi-megabyte, so an unbounded
+ * map keyed by version would grow with every save until the process died.
+ * Keyed by version (content-addressed), so a hit is always correct.
+ */
+const MAX_CACHED_VERSIONS = 3;
+const byVersion = new Map<string, Record<string, unknown>>();
+
+function cacheDraft(version: string, blocks: Record<string, unknown>): void {
+  // Re-insert to make this the most recently used key.
+  byVersion.delete(version);
+  byVersion.set(version, blocks);
+  while (byVersion.size > MAX_CACHED_VERSIONS) {
+    const oldest = byVersion.keys().next().value;
+    if (oldest === undefined) break;
+    byVersion.delete(oldest);
+  }
+}
+
+/** Test seam — drops every cached version. */
+export function clearDraftCache(): void {
+  byVersion.clear();
+}
+
+export interface ResolveDraftOptions {
+  /** Raw `<handle>@<version>` pointer from the request. */
+  pointer: string | null | undefined;
+  /** Defaults to `process.env`. */
+  env?: Record<string, string | undefined>;
+  /** Defaults to global `fetch`. Injected in tests. */
+  fetchImpl?: typeof fetch;
+}
+
+/**
+ * Resolve a draft pointer to a decofile, or null to render published content.
+ *
+ * Null on every failure path — disabled, malformed pointer, unreachable
+ * sandbox, non-2xx — because a draft that cannot be resolved must degrade to
+ * published rather than break the page. Callers that need to *tell the user*
+ * the draft failed should check {@link isDraftPreviewEnabled} and surface it
+ * themselves; silently showing published content while the user believes they
+ * are looking at a draft is the failure mode worth avoiding.
+ */
+export async function resolveDraftDecofile(
+  options: ResolveDraftOptions,
+): Promise<Record<string, unknown> | null> {
+  const env =
+    options.env ??
+    (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env ??
+    {};
+  if (env.DECO_DRAFT_PREVIEW !== "1") return null;
+
+  const parsed = parseDraftPointer(options.pointer);
+  if (!parsed) return null;
+
+  const cached = byVersion.get(parsed.version);
+  if (cached) return cached;
+
+  const origin = buildDraftOrigin(parsed.handle, readSuffixes(env));
+  if (!origin) return null;
+
+  const doFetch = options.fetchImpl ?? fetch;
+  let res: Response;
+  try {
+    res = await doFetch(`${origin}/_sandbox/decofile`, { cache: "no-store" });
+  } catch {
+    return null;
+  }
+  if (!res.ok) return null;
+
+  let blocks: Record<string, unknown>;
+  try {
+    blocks = (await res.json()) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+
+  cacheDraft(parsed.version, blocks);
+  return blocks;
+}
+
+/** True when the feature is switched on and configured. Inert otherwise. */
+export function isDraftPreviewEnabled(env?: Record<string, string | undefined>): boolean {
+  const e =
+    env ??
+    (globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env ??
+    {};
+  return e.DECO_DRAFT_PREVIEW === "1" && readSuffixes(e).length > 0;
+}
+
+// ---------------------------------------------------------------------------
+// Request binding (dependency-injected by the framework binding)
+// ---------------------------------------------------------------------------
+
+type DraftOverrideGetter = () => Record<string, unknown> | null | undefined;
+
+let getDraftOverride: DraftOverrideGetter = () => undefined;
+
+/**
+ * Inject the request-scoped draft getter.
+ *
+ * Binding a value to "the current request" is framework-specific and `blocks`
+ * must not know about any framework: `@decocms/nextjs` backs this with React
+ * `cache()` (App Router has no AsyncLocalStorage request scope of its own —
+ * `RequestContext.run` is never entered there). Bindings that do have an ALS
+ * request scope can back it with that instead. Never called → returns
+ * undefined → `loadBlocks()` behaves exactly as before.
+ */
+export function setDraftOverrideGetter(getter: DraftOverrideGetter): void {
+  getDraftOverride = getter;
+}
+
+/** The current request's draft blocks, if a binding registered one. */
+export function getRequestDraftOverride(): Record<string, unknown> | null | undefined {
+  return getDraftOverride();
+}

package/src/cms/index.ts

@@ -12,6 +12,16 @@ export {
   revisionKey,
   snapshotKey,
 } from "./blockSource";
+export type { DraftPointer, ResolveDraftOptions } from "./draftSource";
+export {
+  buildDraftOrigin,
+  clearDraftCache,
+  getRequestDraftOverride,
+  isDraftPreviewEnabled,
+  parseDraftPointer,
+  resolveDraftDecofile,
+  setDraftOverrideGetter,
+} from "./draftSource";
 export type { DecoPage, Resolvable } from "./loader";
 export {
   findPageByPath,
@@ -82,8 +92,6 @@ export {
   unregisterCommerceLoader,
   WELL_KNOWN_TYPES,
 } from "./resolve";
-export type { SectionLoaderContext } from "./sectionLoaderContext";
-export { buildSectionLoaderContext } from "./sectionLoaderContext";
 export type {
   ActionConfig,
   AppSchemas,
@@ -105,6 +113,8 @@ 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.ts

@@ -1,5 +1,6 @@
 import * as asyncHooks from "node:async_hooks";
 import { djb2Hex } from "../sdk/djb2";
+import { getRequestDraftOverride } from "./draftSource";
 
 export type Resolvable = {
   __resolveType?: string;
@@ -86,7 +87,8 @@ export function setBlocks(blocks: Record<string, unknown>) {
 
 /**
  * Load the current blocks. If running inside a `withBlocksOverride` scope
- * (admin preview), the override is merged on top of the base blocks.
+ * (admin preview) or a request carrying a draft-preview override, that
+ * 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
@@ -95,7 +97,10 @@ export function loadBlocks(): Record<string, unknown> {
     revision = G.__deco.revision ?? null;
   }
 
-  const override = blocksOverrideStorage.getStore();
+  // `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();
   if (override) {
     const merged = { ...blockData };
     for (const [key, value] of Object.entries(override)) {
@@ -203,12 +208,14 @@ 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;
+  };
 };
 
 /**
@@ -231,10 +238,7 @@ 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/schema.test.ts

@@ -253,10 +253,9 @@ describe("commerce SEO section schemas", () => {
     // PLP-specific structured-data config (see seo-form-mode.ts PLP_SEO_FIELD_KEYS).
     expect(props.configJsonLD.properties).toHaveProperty("removeVideos");
     expect(props.configJsonLD.properties).toHaveProperty("ignoreStructuredData");
-    // The data source is a loader picker (anyOf over the loader union), not
-    // hidden — the user picks the PLP loader that feeds the structured data.
-    expect(Array.isArray(props.jsonLD.anyOf)).toBe(true);
-    expect(props.jsonLD.title).toBe("Data Source");
+    // The data source is set once at creation and stays hidden in the SEO panel;
+    // it round-trips via the form rather than being re-picked here.
+    expect(props.jsonLD.hide).toBe(true);
   });
 
   it("emits editable props for the product-details SEO section (pdp mode)", () => {
@@ -269,8 +268,7 @@ describe("commerce SEO section schemas", () => {
     // PDP-specific fields (see seo-form-mode.ts PDP_SEO_FIELD_KEYS).
     expect(props).toHaveProperty("omitVariants");
     expect(props).toHaveProperty("ignoreStructuredData");
-    expect(Array.isArray(props.jsonLD.anyOf)).toBe(true);
-    expect(props.jsonLD.title).toBe("Data Source");
+    expect(props.jsonLD.hide).toBe(true);
   });
 
   it("registers the defs + manifest blocks and offers them as page.seo options", () => {
@@ -287,51 +285,6 @@ describe("commerce SEO section schemas", () => {
       expect(meta.schema.root.sections.anyOf).toContainEqual(b64Ref(key));
     }
   });
-
-  // Mirrors a generated site meta: a loader carries a real def AND is listed in
-  // the site's loader union. `@ignore`d loaders are the exception — they get a
-  // def but are withheld from the union.
-  function siteMetaWithLoader(key: string, opts: { inUnion: boolean }) {
-    const site = emptySiteMeta();
-    site.schema.definitions[b64(key)] = {
-      title: key,
-      type: "object",
-      properties: { __resolveType: { type: "string", enum: [key] } },
-    };
-    site.manifest.blocks.loaders = {
-      [key]: { $ref: `#/definitions/${b64(key)}`, namespace: "site" },
-    };
-    site.schema.root = { loaders: { anyOf: opts.inUnion ? [b64Ref(key)] : [] } };
-    return site;
-  }
-
-  it("feeds the site's own loaders into the jsonLD data-source picker", () => {
-    // The runtime loader registry is empty at generation time, so the union must
-    // be seeded from the site's own loader union — else the picker has no
-    // options and the user can't wire the data source.
-    const loaderKey = "site/loaders/product/productDetailsPage.ts";
-    const meta = composeMeta(siteMetaWithLoader(loaderKey, { inUnion: true }));
-
-    // The picker option is real, not a dangling $ref: its def survives.
-    expect(meta.schema.definitions).toHaveProperty(b64(loaderKey));
-    // …offered in both the root union and the commerce SEO jsonLD picker.
-    expect(meta.schema.root.loaders.anyOf).toContainEqual(b64Ref(loaderKey));
-    const seoDef =
-      meta.schema.definitions[b64("commerce/sections/Seo/SeoPDPV2.tsx")];
-    expect(seoDef.properties.jsonLD.anyOf).toContainEqual(b64Ref(loaderKey));
-  });
-
-  it("keeps @ignore'd loaders (in the manifest, not the union) out of the picker", () => {
-    // Seeding from `manifest.blocks.loaders` would resurrect hidden loaders;
-    // seeding from the union keeps them out.
-    const hiddenKey = "site/loaders/internal/hidden.ts";
-    const meta = composeMeta(siteMetaWithLoader(hiddenKey, { inUnion: false }));
-
-    expect(meta.schema.root.loaders.anyOf).not.toContainEqual(b64Ref(hiddenKey));
-    const seoDef =
-      meta.schema.definitions[b64("commerce/sections/Seo/SeoPDPV2.tsx")];
-    expect(seoDef.properties.jsonLD.anyOf).not.toContainEqual(b64Ref(hiddenKey));
-  });
 });
 
 describe("composeMeta idempotency", () => {

package/src/cms/schema.ts

@@ -731,7 +731,7 @@ function buildPageSchema(sectionAnyOf: any[]) {
 // Framework sections
 // ---------------------------------------------------------------------------
 
-function buildFrameworkSections(sectionAnyOf: any[], loaderUnion: any[]) {
+function buildFrameworkSections(sectionAnyOf: any[]) {
   const definitions: Record<string, any> = {};
   const manifestBlocks: Record<string, any> = {};
   const extraAnyOf: any[] = [];
@@ -839,12 +839,8 @@ function buildFrameworkSections(sectionAnyOf: any[], loaderUnion: any[]) {
   // there is no manifest to emit these props from. The Studio's SEO editor
   // already knows this type as its "plp" mode (see seo-form-mode.ts); it just
   // needs the props schema to render the override fields. `jsonLD` is the
-  // data-source loader picker (mirrors deco-cx's `@title Data Source`) — an
-  // inline anyOf over the loader union so the editor lets you pick the PLP/PDP
-  // loader that feeds the structured data. Inlined (a fresh copy) rather than a
-  // `$ref: "#/root/loaders"` because the Studio drops the prop-level title when
-  // resolving a `$ref` union, which would lose the "Data Source" label; the
-  // copy also avoids sharing one array instance across the two defs + root.
+  // data-source block-ref set once when the page is created; it round-trips via
+  // the form (kept `hide`) rather than being re-picked in the SEO panel.
   //
   // Added to `extraAnyOf` (offered as a selectable page.seo type) unconditionally,
   // like the website Seo sections above. Gating this on "is a commerce site" via
@@ -865,7 +861,12 @@ function buildFrameworkSections(sectionAnyOf: any[], loaderUnion: any[]) {
         enum: [SEO_PLP_V2_TYPE],
         default: SEO_PLP_V2_TYPE,
       },
-      jsonLD: { title: "Data Source", anyOf: [...loaderUnion] },
+      jsonLD: {
+        type: "object",
+        title: "Data Source",
+        additionalProperties: true,
+        hide: true,
+      },
       title: { type: "string", title: "Title Override" },
       description: { type: "string", title: "Description Override" },
       noIndexing: { type: "boolean", title: "Disable indexing" },
@@ -899,7 +900,12 @@ function buildFrameworkSections(sectionAnyOf: any[], loaderUnion: any[]) {
         enum: [SEO_PDP_V2_TYPE],
         default: SEO_PDP_V2_TYPE,
       },
-      jsonLD: { title: "Data Source", anyOf: [...loaderUnion] },
+      jsonLD: {
+        type: "object",
+        title: "Data Source",
+        additionalProperties: true,
+        hide: true,
+      },
       omitVariants: { type: "boolean", title: "Omit variants" },
       title: { type: "string", title: "Title Override" },
       description: { type: "string", title: "Description Override" },
@@ -1103,36 +1109,11 @@ export function composeMeta(
 
   const siteAnyOf = siteMeta.schema?.root?.sections?.anyOf || [];
 
-  // Build all framework components. Loaders first: the commerce SEO sections'
-  // `jsonLD` data-source picker references the loader union, and that union must
-  // include the site's OWN loaders. The runtime registry (loaderRegistry) is
-  // empty at generation time, so `buildLoaderDefinitions` alone yields just
-  // `Resolvable` — merge in the site's own loaders so loader-backed pickers have
-  // real options in the baked meta, not only at runtime.
-  //
-  // Seed from the site's loader UNION (`schema.root.loaders.anyOf`), NOT
-  // `manifest.blocks.loaders`: the generator keeps `@ignore`d loaders in the
-  // manifest (they still need a def) while withholding them from the union so
-  // they can't be picked — reading the manifest would resurrect them. This
-  // source is also already `{ $ref }`-shaped and only points at defs that exist
-  // (no dangling refs).
-  //
-  // TODO: `root.matchers`/`root.actions` have the same empty-union-at-gen-time
-  // gap; only loaders are merged here (commerce SEO scope). Generalize if a
-  // matcher/action picker ever needs baked options.
-  const loaders = buildLoaderDefinitions();
-  const siteLoaderRefs = (siteMeta.schema?.root?.loaders?.anyOf ?? []).filter(
-    (ref: any): ref is { $ref: string } => Boolean(ref) && typeof ref.$ref === "string",
-  );
-  const seenLoaderRefs = new Set<string>(loaders.loaderAnyOf.map((r: any) => r.$ref));
-  const loaderUnion = [
-    ...loaders.loaderAnyOf,
-    ...siteLoaderRefs.filter((r) => !seenLoaderRefs.has(r.$ref)),
-  ];
-
-  const fwSections = buildFrameworkSections(siteAnyOf, loaderUnion);
+  // Build all framework components
+  const fwSections = buildFrameworkSections(siteAnyOf);
   const fullSectionAnyOf = [...siteAnyOf, ...fwSections.extraAnyOf];
   const page = buildPageSchema(fullSectionAnyOf);
+  const loaders = buildLoaderDefinitions();
   const actions = buildActionDefinitions();
   const matchers = buildMatcherDefinitions();
 
@@ -1193,7 +1174,7 @@ export function composeMeta(
         ...(siteMeta.schema?.root || {}),
         sections: { anyOf: fullSectionAnyOf },
         pages: { anyOf: page.rootAnyOf },
-        loaders: { anyOf: loaderUnion },
+        loaders: { anyOf: loaders.loaderAnyOf },
         matchers: { anyOf: matchers.matcherAnyOf },
       },
     },