From 7b358e442230215911b35755009409e2825d9396 Mon Sep 17 00:00:00 2001
From: Maksim Hodasevich <maksim.hodasevich@gmail.com>
Date: Tue, 27 Oct 2026 13:30:45 +0100
Subject: [PATCH 1/5] fix(cms): keep pages in sync with the global blocks they
 embed

- GlobalBlock: add an afterChange hook that revalidates the cache of every
  published page that embeds the block, in every locale (locale fallback can
  render the block on pages of other locales), and re-indexes their search
  embeddings for the edited locale.
- GlobalBlock: the delete guard now checks every locale and the latest page
  drafts, so a reference that exists only in `es` or only in a draft blocks
  the delete.
- Page search: resolve published global blocks before text extraction, and
  extract the text of `globalSectionSlot` blocks.
---
 .../cms/src/collections/GlobalBlock/config.ts |  2 +
 .../GlobalBlock/findPagesUsingGlobalBlock.ts  | 45 ++++++++++++++++
 .../hooks/preventDeleteIfReferenced.ts        | 22 +++-----
 .../hooks/revalidatePagesUsingGlobalBlock.ts  | 52 +++++++++++++++++++
 .../src/collections/Page/extractPageText.ts   |  4 ++
 .../collections/Page/hooks/indexEmbedding.ts  | 37 ++++++++-----
 .../collections/Page/resolveGlobalBlocks.ts   | 46 ++++++++++++++++
 7 files changed, 180 insertions(+), 28 deletions(-)
 create mode 100644 apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts
 create mode 100644 apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
 create mode 100644 apps/cms/src/collections/Page/resolveGlobalBlocks.ts

diff --git a/apps/cms/src/collections/GlobalBlock/config.ts b/apps/cms/src/collections/GlobalBlock/config.ts
index 1e2e2ad18..f5ca9d6fb 100644
--- a/apps/cms/src/collections/GlobalBlock/config.ts
+++ b/apps/cms/src/collections/GlobalBlock/config.ts
@@ -5,6 +5,7 @@ import { anyone, author, or, superAdmin, user } from "@/lib/access";
 import { createLocalizedDefault } from "@/lib/utils/createLocalizedDefault";
 
 import { preventDeleteIfReferenced } from "./hooks/preventDeleteIfReferenced";
+import { revalidatePagesUsingGlobalBlock } from "./hooks/revalidatePagesUsingGlobalBlock";
 
 export const GlobalBlock: CollectionConfig<"globalBlock"> = {
   access: {
@@ -54,6 +55,7 @@ export const GlobalBlock: CollectionConfig<"globalBlock"> = {
     },
   ],
   hooks: {
+    afterChange: [revalidatePagesUsingGlobalBlock],
     beforeDelete: [preventDeleteIfReferenced],
   },
   labels: {
diff --git a/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts b/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts
new file mode 100644
index 000000000..272cb6963
--- /dev/null
+++ b/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts
@@ -0,0 +1,45 @@
+import type { PayloadRequest } from "payload";
+
+import { I18N_CONFIG } from "@/lib/config/i18n";
+
+export interface PageUsingGlobalBlock {
+  id: number;
+  title: string;
+}
+
+// `blocks` is localized and drafts live in the versions table, so each locale and the latest draft must be checked.
+export async function findPagesUsingGlobalBlock({
+  id,
+  includeDrafts = false,
+  req,
+}: {
+  id: number | string;
+  includeDrafts?: boolean;
+  req: PayloadRequest;
+}): Promise<PageUsingGlobalBlock[]> {
+  const pages = new Map<number, PageUsingGlobalBlock>();
+
+  for (const { code: locale } of I18N_CONFIG.locales) {
+    for (const draft of includeDrafts ? [false, true] : [false]) {
+      const { docs } = await req.payload.find({
+        collection: "page",
+        depth: 0,
+        draft,
+        locale,
+        overrideAccess: true,
+        pagination: false,
+        req,
+        select: { title: true },
+        where: { "blocks.reference": { equals: id } },
+      });
+
+      for (const doc of docs) {
+        if (!pages.has(doc.id)) {
+          pages.set(doc.id, { id: doc.id, title: doc.title });
+        }
+      }
+    }
+  }
+
+  return [...pages.values()];
+}
diff --git a/apps/cms/src/collections/GlobalBlock/hooks/preventDeleteIfReferenced.ts b/apps/cms/src/collections/GlobalBlock/hooks/preventDeleteIfReferenced.ts
index a3ba5dfc4..c60181117 100644
--- a/apps/cms/src/collections/GlobalBlock/hooks/preventDeleteIfReferenced.ts
+++ b/apps/cms/src/collections/GlobalBlock/hooks/preventDeleteIfReferenced.ts
@@ -1,26 +1,16 @@
 import { APIError } from "payload";
 import type { CollectionBeforeDeleteHook } from "payload";
 
+import { findPagesUsingGlobalBlock } from "../findPagesUsingGlobalBlock";
+
 export const preventDeleteIfReferenced: CollectionBeforeDeleteHook = async ({ id, req }) => {
-  const pages = await req.payload.find({
-    collection: "page",
-    depth: 0,
-    limit: 100,
-    overrideAccess: true,
-    pagination: false,
-    req,
-    where: {
-      "blocks.reference": { equals: id },
-    },
-  });
+  const pages = await findPagesUsingGlobalBlock({ id, includeDrafts: true, req });
 
-  if (pages.totalDocs > 0) {
-    const titles = pages.docs
-      .map((p) => (typeof p.title === "string" ? p.title : `#${p.id}`))
-      .join(", ");
+  if (pages.length > 0) {
+    const titles = pages.map((p) => p.title || `#${p.id}`).join(", ");
 
     throw new APIError(
-      `Cannot delete this global block: it is still used by ${pages.totalDocs} page(s): ${titles}. Remove those references first.`,
+      `Cannot delete this global block: it is still used by ${pages.length} page(s): ${titles}. Remove those references first.`,
       400,
       undefined,
       true
diff --git a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
new file mode 100644
index 000000000..d0e668394
--- /dev/null
+++ b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
@@ -0,0 +1,52 @@
+import type { CollectionAfterChangeHook } from "payload";
+
+import { upsertPageEmbedding } from "@/collections/Page/hooks/indexEmbedding";
+import { I18N_CONFIG } from "@/lib/config/i18n";
+import { getLocaleFromRequest } from "@/lib/utils/getLocaleFromRequest";
+import { revalidatePageCache } from "@/lib/utils/revalidatePageCache";
+import type { GlobalBlock } from "@/payload-types";
+
+import { findPagesUsingGlobalBlock } from "../findPagesUsingGlobalBlock";
+
+export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBlock> = async ({
+  doc,
+  previousDoc,
+  req,
+}) => {
+  const { context, payload } = req;
+  const affectsPublished = doc._status === "published" || previousDoc?._status === "published";
+
+  if (context.disableRevalidate || !affectsPublished) {
+    return doc;
+  }
+
+  const pageIds = (await findPagesUsingGlobalBlock({ id: doc.id, req })).map((p) => p.id);
+  if (pageIds.length === 0) {
+    return doc;
+  }
+
+  const editedLocale = getLocaleFromRequest(req);
+
+  // Every locale is revalidated because locale fallback can render this block on pages of other locales.
+  for (const { code: locale } of I18N_CONFIG.locales) {
+    const { docs: pages } = await payload.find({
+      collection: "page",
+      depth: 0,
+      locale,
+      overrideAccess: true,
+      pagination: false,
+      req,
+      where: { _status: { equals: "published" }, id: { in: pageIds } },
+    });
+
+    for (const page of pages) {
+      revalidatePageCache({ doc: page, locale, payload });
+
+      if (locale === editedLocale && !context.skipEmbedding) {
+        await upsertPageEmbedding({ locale, page, req });
+      }
+    }
+  }
+
+  return doc;
+};
diff --git a/apps/cms/src/collections/Page/extractPageText.ts b/apps/cms/src/collections/Page/extractPageText.ts
index 37448ee25..9940d60fb 100644
--- a/apps/cms/src/collections/Page/extractPageText.ts
+++ b/apps/cms/src/collections/Page/extractPageText.ts
@@ -51,6 +51,10 @@ export function extractPageBlockText(block: Page["blocks"][number]): string {
     case "stats": {
       return extractStatsText(block);
     }
+    case "globalSectionSlot": {
+      const inner = typeof block.reference === "object" ? block.reference.block?.[0] : undefined;
+      return inner ? extractPageBlockText(inner) : "";
+    }
     default: {
       return "";
     }
diff --git a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
index 3e6830724..1f12d1116 100644
--- a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
+++ b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
@@ -1,29 +1,31 @@
-import type { CollectionAfterChangeHook, CollectionAfterDeleteHook } from "payload";
+import type { CollectionAfterChangeHook, CollectionAfterDeleteHook, PayloadRequest } from "payload";
 import type { Pool } from "pg";
 
 import { extractPageText } from "@/collections/Page/extractPageText";
+import { resolveGlobalBlocks } from "@/collections/Page/resolveGlobalBlocks";
 import { getLocaleFromRequest } from "@/lib/utils/getLocaleFromRequest";
+import type { Locale } from "@/lib/types";
 import type { Page } from "@/payload-types";
 import { upsertEmbedding, deleteEmbedding } from "@/lib/search/dbOperations";
 import { generateEmbedding } from "@/lib/search/generateEmbedding";
 
-export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc, req }) => {
-  if (doc._status !== "published") {
-    return doc;
-  }
-  if (req.context?.skipEmbedding) {
-    return doc;
-  }
-
+export async function upsertPageEmbedding({
+  locale,
+  page,
+  req,
+}: {
+  locale: Locale;
+  page: Page;
+  req: PayloadRequest;
+}): Promise<void> {
   try {
-    const locale = getLocaleFromRequest(req);
-    const text = extractPageText(doc);
+    const text = extractPageText(await resolveGlobalBlocks({ locale, page, req }));
     const embedding = await generateEmbedding(text);
     const { pool } = req.payload.db as unknown as { pool: Pool };
 
     await upsertEmbedding({
       collection: "page",
-      documentId: String(doc.id),
+      documentId: String(page.id),
       embedding,
       locale,
       pool,
@@ -31,6 +33,17 @@ export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc,
   } catch (error) {
     req.payload.logger.error({ error }, "Failed to index page embedding");
   }
+}
+
+export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc, req }) => {
+  if (doc._status !== "published") {
+    return doc;
+  }
+  if (req.context?.skipEmbedding) {
+    return doc;
+  }
+
+  await upsertPageEmbedding({ locale: getLocaleFromRequest(req), page: doc, req });
 
   return doc;
 };
diff --git a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
new file mode 100644
index 000000000..5cbccc5b1
--- /dev/null
+++ b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
@@ -0,0 +1,46 @@
+import type { PayloadRequest } from "payload";
+
+import type { Locale } from "@/lib/types";
+import type { Page } from "@/payload-types";
+
+type Slot = Extract<Page["blocks"][number], { blockType: "globalSectionSlot" }>;
+
+const slotId = (slot: Slot) =>
+  typeof slot.reference === "object" ? slot.reference.id : slot.reference;
+
+export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
+  locale,
+  page,
+  req,
+}: {
+  locale: Locale;
+  page: T;
+  req: PayloadRequest;
+}): Promise<T> {
+  const blocks = page.blocks ?? [];
+  const ids = blocks.flatMap((b) => (b.blockType === "globalSectionSlot" ? [slotId(b)] : []));
+
+  if (ids.length === 0) {
+    return page;
+  }
+
+  const { docs } = await req.payload.find({
+    collection: "globalBlock",
+    depth: 0,
+    locale,
+    overrideAccess: true,
+    pagination: false,
+    req,
+    where: { _status: { equals: "published" }, id: { in: ids } },
+  });
+  const published = new Map(docs.map((d) => [d.id, d]));
+
+  return {
+    ...page,
+    blocks: blocks.map((b) =>
+      b.blockType === "globalSectionSlot"
+        ? { ...b, reference: published.get(slotId(b)) ?? slotId(b) }
+        : b
+    ),
+  };
+}

From b33f5dbc168a239c2cfd7288872305214ddab22f Mon Sep 17 00:00:00 2001
From: Maksim Hodasevich <maksim.hodasevich@gmail.com>
Date: Tue, 27 Oct 2026 13:52:09 +0100
Subject: [PATCH 2/5] fix(cms): share one global block visibility rule and skip
 draft-only saves

- GlobalBlock: the revalidation hook now skips a draft save over a published
  block (published content is unchanged) but still runs on publish and
  unpublish, and re-indexes page embeddings in every locale, because locale
  fallback changes the text of other locales too.
- GlobalBlock: new `slots` module with `collectGlobalBlockIds` and
  `isPublishedGlobalBlock`, used by the slot renderer, page search and the
  SEO extractor, so all three agree on which global block content is live.
- Page search: a slot with a null reference no longer throws.
- SEO extractor: unpublished global blocks no longer leak into SEO content.
- Remove comments from the new global block code.
---
 .../blocks/GlobalSectionSlot/Component.tsx    |  3 +-
 .../GlobalBlock/findPagesUsingGlobalBlock.ts  |  1 -
 .../hooks/revalidatePagesUsingGlobalBlock.ts  | 40 ++++++++++++++-----
 apps/cms/src/collections/GlobalBlock/slots.ts | 21 ++++++++++
 .../collections/Page/extractPageContent.ts    | 28 ++++---------
 .../src/collections/Page/extractPageText.ts   |  4 +-
 .../collections/Page/resolveGlobalBlocks.ts   | 28 +++++++------
 7 files changed, 78 insertions(+), 47 deletions(-)
 create mode 100644 apps/cms/src/collections/GlobalBlock/slots.ts

diff --git a/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx b/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx
index 265e1b869..ad0a7a370 100644
--- a/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx
+++ b/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx
@@ -1,6 +1,7 @@
 import { draftMode } from "next/headers";
 
 import { renderContentBlock } from "@/blocks/contentBlockComponents";
+import { isPublishedGlobalBlock } from "@/collections/GlobalBlock/slots";
 import { filterHiddenBlocks } from "@/lib/fields/section/filterHiddenBlocks";
 import type { GlobalSectionSlotBlock } from "@/payload-types";
 
@@ -8,7 +9,7 @@ export const GlobalSectionSlotBlockComponent = async ({ reference }: GlobalSecti
   if (!reference || typeof reference === "number") return null;
 
   const { isEnabled: draft } = await draftMode();
-  if (!draft && reference._status !== "published") return null;
+  if (!draft && !isPublishedGlobalBlock(reference)) return null;
 
   const [inner] = filterHiddenBlocks(reference.block);
   if (!inner) return null;
diff --git a/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts b/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts
index 272cb6963..bbc084481 100644
--- a/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts
+++ b/apps/cms/src/collections/GlobalBlock/findPagesUsingGlobalBlock.ts
@@ -7,7 +7,6 @@ export interface PageUsingGlobalBlock {
   title: string;
 }
 
-// `blocks` is localized and drafts live in the versions table, so each locale and the latest draft must be checked.
 export async function findPagesUsingGlobalBlock({
   id,
   includeDrafts = false,
diff --git a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
index d0e668394..14eb4f1ca 100644
--- a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
+++ b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
@@ -1,12 +1,36 @@
-import type { CollectionAfterChangeHook } from "payload";
+import type { CollectionAfterChangeHook, PayloadRequest } from "payload";
 
 import { upsertPageEmbedding } from "@/collections/Page/hooks/indexEmbedding";
 import { I18N_CONFIG } from "@/lib/config/i18n";
-import { getLocaleFromRequest } from "@/lib/utils/getLocaleFromRequest";
 import { revalidatePageCache } from "@/lib/utils/revalidatePageCache";
 import type { GlobalBlock } from "@/payload-types";
 
 import { findPagesUsingGlobalBlock } from "../findPagesUsingGlobalBlock";
+import { isPublishedGlobalBlock } from "../slots";
+
+async function changesPublishedContent({
+  doc,
+  previousDoc,
+  req,
+}: {
+  doc: GlobalBlock;
+  previousDoc?: GlobalBlock;
+  req: PayloadRequest;
+}): Promise<boolean> {
+  if (isPublishedGlobalBlock(doc)) return true;
+  if (!isPublishedGlobalBlock(previousDoc)) return false;
+
+  const live = await req.payload.findByID({
+    collection: "globalBlock",
+    depth: 0,
+    id: doc.id,
+    overrideAccess: true,
+    req,
+    select: { _status: true },
+  });
+
+  return !isPublishedGlobalBlock(live);
+}
 
 export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBlock> = async ({
   doc,
@@ -14,9 +38,8 @@ export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBl
   req,
 }) => {
   const { context, payload } = req;
-  const affectsPublished = doc._status === "published" || previousDoc?._status === "published";
 
-  if (context.disableRevalidate || !affectsPublished) {
+  if (context.disableRevalidate || !(await changesPublishedContent({ doc, previousDoc, req }))) {
     return doc;
   }
 
@@ -25,11 +48,8 @@ export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBl
     return doc;
   }
 
-  const editedLocale = getLocaleFromRequest(req);
-
-  // Every locale is revalidated because locale fallback can render this block on pages of other locales.
   for (const { code: locale } of I18N_CONFIG.locales) {
-    const { docs: pages } = await payload.find({
+    const { docs: publishedPages } = await payload.find({
       collection: "page",
       depth: 0,
       locale,
@@ -39,10 +59,10 @@ export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBl
       where: { _status: { equals: "published" }, id: { in: pageIds } },
     });
 
-    for (const page of pages) {
+    for (const page of publishedPages) {
       revalidatePageCache({ doc: page, locale, payload });
 
-      if (locale === editedLocale && !context.skipEmbedding) {
+      if (!context.skipEmbedding) {
         await upsertPageEmbedding({ locale, page, req });
       }
     }
diff --git a/apps/cms/src/collections/GlobalBlock/slots.ts b/apps/cms/src/collections/GlobalBlock/slots.ts
new file mode 100644
index 000000000..496ded718
--- /dev/null
+++ b/apps/cms/src/collections/GlobalBlock/slots.ts
@@ -0,0 +1,21 @@
+import { relationId } from "@/lib/contentExtraction";
+import type { GlobalBlock } from "@/payload-types";
+
+interface BlockLike {
+  blockType: string;
+  reference?: unknown;
+}
+
+export function collectGlobalBlockIds(blocks: readonly BlockLike[]): (string | number)[] {
+  const ids = new Set<string | number>();
+
+  for (const block of blocks) {
+    const id = block.blockType === "globalSectionSlot" ? relationId(block.reference) : null;
+    if (id != null) ids.add(id);
+  }
+
+  return [...ids];
+}
+
+export const isPublishedGlobalBlock = (doc: Pick<GlobalBlock, "_status"> | null | undefined) =>
+  doc?._status === "published";
diff --git a/apps/cms/src/collections/Page/extractPageContent.ts b/apps/cms/src/collections/Page/extractPageContent.ts
index 8a3a879f4..9d8562017 100644
--- a/apps/cms/src/collections/Page/extractPageContent.ts
+++ b/apps/cms/src/collections/Page/extractPageContent.ts
@@ -6,6 +6,7 @@ import type {
   DocStore,
 } from "@focus-reactive/payload-plugin-seo/content";
 
+import { collectGlobalBlockIds, isPublishedGlobalBlock } from "@/collections/GlobalBlock/slots";
 import { I18N_CONFIG } from "@/lib/config/i18n";
 import {
   actionLinks,
@@ -21,7 +22,6 @@ import type { ImageGroup, LinkResolveCtx, LinkValue, Upload } from "@/lib/conten
 import type { GlobalBlock, Page } from "@/payload-types";
 
 type Block = Page["blocks"][number];
-type GlobalBlockContent = NonNullable<GlobalBlock["block"]>[number];
 
 export function extractPageBlockContent(
   block: Block,
@@ -153,9 +153,9 @@ export function extractPageBlockContent(
       const gid = relationId(b.reference);
       const resolved =
         gid != null
-          ? (docs.get("globalBlock", gid) as { block?: GlobalBlockContent[] } | undefined)
+          ? (docs.get("globalBlock", gid) as Pick<GlobalBlock, "_status" | "block"> | undefined)
           : undefined;
-      const inner = resolved?.block?.[0];
+      const inner = isPublishedGlobalBlock(resolved) ? resolved?.block?.[0] : undefined;
 
       return inner ? extractPageBlockContent(inner as unknown as Block, ctx, docs, helpers) : [];
     }
@@ -164,19 +164,6 @@ export function extractPageBlockContent(
   }
 }
 
-function collectGlobalBlockIds(blocks: Block[]): (string | number)[] {
-  const ids = new Set<string | number>();
-
-  for (const block of blocks) {
-    if (block.blockType === "globalSectionSlot") {
-      const id = relationId((block as { reference?: unknown }).reference);
-      if (id != null) ids.add(id);
-    }
-  }
-
-  return [...ids];
-}
-
 function mergeStores(...stores: (DocStore | null)[]): DocStore {
   return {
     get: (collection, id) => {
@@ -199,16 +186,15 @@ const extractPageContent: ContentExtractor = async (values, ctx, { resolveDocs,
     phase1Queries.push({
       collection: "globalBlock",
       ids: globalIds,
-      select: ["block"],
+      select: ["block", "_status"],
       depth: 0,
     });
   }
   const docs1: DocStore = await resolveDocs(phase1Queries);
 
-  const globalDocs = globalIds.map((id) => docs1.get("globalBlock", id)).filter(Boolean) as Record<
-    string,
-    unknown
-  >[];
+  const globalDocs = globalIds
+    .map((id) => docs1.get("globalBlock", id) as Pick<GlobalBlock, "_status"> | undefined)
+    .filter(isPublishedGlobalBlock) as Record<string, unknown>[];
   const phase2Queries: DocQuery[] = globalDocs.flatMap((doc) => buildRefQueries(doc));
   const docs2: DocStore | null = phase2Queries.length > 0 ? await resolveDocs(phase2Queries) : null;
 
diff --git a/apps/cms/src/collections/Page/extractPageText.ts b/apps/cms/src/collections/Page/extractPageText.ts
index 9940d60fb..8327ce0a1 100644
--- a/apps/cms/src/collections/Page/extractPageText.ts
+++ b/apps/cms/src/collections/Page/extractPageText.ts
@@ -8,6 +8,7 @@ import { extractFaqText } from "@/blocks/Faq/extractText";
 import { extractHeroText } from "@/blocks/Hero/extractText";
 import { extractLogosText } from "@/blocks/Logos/extractText";
 import { extractTestimonialsText } from "@/blocks/TestimonialsList/extractText";
+import { isPublishedGlobalBlock } from "@/collections/GlobalBlock/slots";
 import { extractLexicalText, joinText } from "@/lib/utils/text";
 import type { Page } from "@/payload-types";
 
@@ -52,7 +53,8 @@ export function extractPageBlockText(block: Page["blocks"][number]): string {
       return extractStatsText(block);
     }
     case "globalSectionSlot": {
-      const inner = typeof block.reference === "object" ? block.reference.block?.[0] : undefined;
+      const reference = typeof block.reference === "object" ? block.reference : null;
+      const inner = isPublishedGlobalBlock(reference) ? reference?.block?.[0] : undefined;
       return inner ? extractPageBlockText(inner) : "";
     }
     default: {
diff --git a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
index 5cbccc5b1..d14eaf791 100644
--- a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
+++ b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
@@ -1,13 +1,10 @@
 import type { PayloadRequest } from "payload";
 
+import { collectGlobalBlockIds, isPublishedGlobalBlock } from "@/collections/GlobalBlock/slots";
+import { relationId } from "@/lib/contentExtraction";
 import type { Locale } from "@/lib/types";
 import type { Page } from "@/payload-types";
 
-type Slot = Extract<Page["blocks"][number], { blockType: "globalSectionSlot" }>;
-
-const slotId = (slot: Slot) =>
-  typeof slot.reference === "object" ? slot.reference.id : slot.reference;
-
 export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
   locale,
   page,
@@ -18,7 +15,7 @@ export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
   req: PayloadRequest;
 }): Promise<T> {
   const blocks = page.blocks ?? [];
-  const ids = blocks.flatMap((b) => (b.blockType === "globalSectionSlot" ? [slotId(b)] : []));
+  const ids = collectGlobalBlockIds(blocks);
 
   if (ids.length === 0) {
     return page;
@@ -31,16 +28,21 @@ export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
     overrideAccess: true,
     pagination: false,
     req,
-    where: { _status: { equals: "published" }, id: { in: ids } },
+    where: { id: { in: ids } },
   });
-  const published = new Map(docs.map((d) => [d.id, d]));
+  const publishedById = new Map(
+    docs.filter(isPublishedGlobalBlock).map((doc) => [String(doc.id), doc])
+  );
 
   return {
     ...page,
-    blocks: blocks.map((b) =>
-      b.blockType === "globalSectionSlot"
-        ? { ...b, reference: published.get(slotId(b)) ?? slotId(b) }
-        : b
-    ),
+    blocks: blocks.map((block) => {
+      if (block.blockType !== "globalSectionSlot") return block;
+
+      const id = relationId(block.reference);
+      const published = id == null ? undefined : publishedById.get(String(id));
+
+      return published ? { ...block, reference: published } : block;
+    }),
   };
 }

From 5d71bebccf703f4aae01f8ca69a608429848e49d Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 27 Oct 2026 12:55:43 +0000
Subject: [PATCH 3/5] feat(cms): translation, preview, depth and search for
 global blocks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up to the global blocks correctness fixes (#211). Addresses the
remaining gaps from #210, parts 1, 2, 4, 5 and 6:

- Wire `globalBlock` into the translator, scheduling and comments plugins
  so a shared block can be AI-translated, scheduled and commented on.
- Add a standalone preview route (`/[locale]/preview/global-block/[id]`)
  and wire `admin.livePreview` / `admin.preview`, so an editor can see a
  global block before publishing it to every page that embeds it.
- Re-populate the slot reference at the page render depth so a global
  block's inner relationships get the same population as page blocks.
- Index `rawHtml` block text for semantic search, stripping tags and
  dropping `<script>` / `<style>` content.
- Re-index every locale on page and global block saves, because locale
  fallback can change the rendered text of locales other than the edited
  one. Both re-index paths now extract at the same depth so neither
  overwrites the other's embedding with less text.

Part 3 (a "make this block global" admin action) is intentionally left
for a dedicated follow-up — it is an interactive admin-form mutation that
needs live iteration in the panel to get right.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0166RzePhuVEPA8r65QFJV5J
---
 .../preview/global-block/[id]/page.tsx        | 35 +++++++++++++++
 .../blocks/GlobalSectionSlot/Component.tsx    | 17 +++-----
 .../GlobalSectionSlot/GlobalBlockRenderer.tsx | 42 ++++++++++++++++++
 apps/cms/src/blocks/RawHtml/extractText.ts    | 33 ++++++++++++++
 .../cms/src/collections/GlobalBlock/config.ts | 20 +++++++++
 .../hooks/revalidatePagesUsingGlobalBlock.ts  | 12 +++---
 .../src/collections/Page/extractPageText.ts   |  9 +++-
 .../collections/Page/hooks/indexEmbedding.ts  | 43 +++++++++++++++++--
 .../collections/Page/resolveGlobalBlocks.ts   |  6 ++-
 apps/cms/src/lib/dal/getPageBySlug.ts         |  6 ++-
 apps/cms/src/lib/dal/index.ts                 |  2 +-
 apps/cms/src/lib/plugins/index.ts             | 17 ++++++--
 apps/cms/src/lib/utils/generatePreviewPath.ts |  2 +-
 13 files changed, 214 insertions(+), 30 deletions(-)
 create mode 100644 apps/cms/src/app/(frontend)/[locale]/preview/global-block/[id]/page.tsx
 create mode 100644 apps/cms/src/blocks/GlobalSectionSlot/GlobalBlockRenderer.tsx
 create mode 100644 apps/cms/src/blocks/RawHtml/extractText.ts

diff --git a/apps/cms/src/app/(frontend)/[locale]/preview/global-block/[id]/page.tsx b/apps/cms/src/app/(frontend)/[locale]/preview/global-block/[id]/page.tsx
new file mode 100644
index 000000000..b60a3630b
--- /dev/null
+++ b/apps/cms/src/app/(frontend)/[locale]/preview/global-block/[id]/page.tsx
@@ -0,0 +1,35 @@
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+
+import { GlobalBlockRenderer } from "@/blocks/GlobalSectionSlot/GlobalBlockRenderer";
+import type { Locale } from "@/lib/types";
+
+export const metadata: Metadata = {
+  robots: { follow: false, index: false },
+  title: "Global Block Preview",
+};
+
+interface Args {
+  params: Promise<{
+    id: string;
+    locale: Locale;
+  }>;
+}
+
+// Standalone preview for a single global block, so editors can see it before publishing — publishing
+// a global block affects every page that embeds it. Reached through the admin preview / live-preview
+// buttons (see the GlobalBlock collection config).
+export default async function GlobalBlockPreviewPage({ params }: Args) {
+  const { id, locale } = await params;
+  const referenceId = Number(id);
+
+  if (!Number.isInteger(referenceId)) {
+    notFound();
+  }
+
+  return (
+    <main>
+      <GlobalBlockRenderer locale={locale} referenceId={referenceId} />
+    </main>
+  );
+}
diff --git a/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx b/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx
index 265e1b869..94ef91d77 100644
--- a/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx
+++ b/apps/cms/src/blocks/GlobalSectionSlot/Component.tsx
@@ -1,17 +1,10 @@
-import { draftMode } from "next/headers";
-
-import { renderContentBlock } from "@/blocks/contentBlockComponents";
-import { filterHiddenBlocks } from "@/lib/fields/section/filterHiddenBlocks";
 import type { GlobalSectionSlotBlock } from "@/payload-types";
 
-export const GlobalSectionSlotBlockComponent = async ({ reference }: GlobalSectionSlotBlock) => {
-  if (!reference || typeof reference === "number") return null;
-
-  const { isEnabled: draft } = await draftMode();
-  if (!draft && reference._status !== "published") return null;
+import { GlobalBlockRenderer } from "./GlobalBlockRenderer";
 
-  const [inner] = filterHiddenBlocks(reference.block);
-  if (!inner) return null;
+export const GlobalSectionSlotBlockComponent = ({ reference }: GlobalSectionSlotBlock) => {
+  const referenceId = typeof reference === "object" && reference ? reference.id : reference;
+  if (referenceId == null) return null;
 
-  return renderContentBlock(inner, inner.id ?? "global-section-inner");
+  return <GlobalBlockRenderer referenceId={referenceId} />;
 };
diff --git a/apps/cms/src/blocks/GlobalSectionSlot/GlobalBlockRenderer.tsx b/apps/cms/src/blocks/GlobalSectionSlot/GlobalBlockRenderer.tsx
new file mode 100644
index 000000000..670854e53
--- /dev/null
+++ b/apps/cms/src/blocks/GlobalSectionSlot/GlobalBlockRenderer.tsx
@@ -0,0 +1,42 @@
+import { draftMode } from "next/headers";
+
+import { renderContentBlock } from "@/blocks/contentBlockComponents";
+import { getPayloadClient, PAGE_RENDER_DEPTH } from "@/dal";
+import { filterHiddenBlocks } from "@/lib/fields/section/filterHiddenBlocks";
+import type { Locale } from "@/lib/types";
+import { resolveLocale } from "@/lib/utils/resolveLocale";
+
+// Loads the referenced global block at the page's render depth and renders its single inner block.
+// Re-fetching here (rather than reading the already-populated relationship) spends no page-render
+// depth level on the slot, so the inner block's own relationships get the same population depth they
+// would as a page block. Shared by the `globalSectionSlot` page block and the standalone preview route.
+export const GlobalBlockRenderer = async ({
+  locale,
+  referenceId,
+}: {
+  locale?: Locale;
+  referenceId: number;
+}) => {
+  const { isEnabled: draft } = await draftMode();
+  const resolvedLocale = await resolveLocale(locale);
+  const payload = await getPayloadClient();
+
+  const globalBlock = await payload
+    .findByID({
+      collection: "globalBlock",
+      depth: PAGE_RENDER_DEPTH,
+      draft,
+      id: referenceId,
+      locale: resolvedLocale,
+      overrideAccess: true,
+    })
+    .catch(() => null);
+
+  if (!globalBlock) return null;
+  if (!draft && globalBlock._status !== "published") return null;
+
+  const [inner] = filterHiddenBlocks(globalBlock.block);
+  if (!inner) return null;
+
+  return renderContentBlock(inner, inner.id ?? "global-section-inner");
+};
diff --git a/apps/cms/src/blocks/RawHtml/extractText.ts b/apps/cms/src/blocks/RawHtml/extractText.ts
new file mode 100644
index 000000000..388ebb246
--- /dev/null
+++ b/apps/cms/src/blocks/RawHtml/extractText.ts
@@ -0,0 +1,33 @@
+import type { RawHtmlBlock } from "@/payload-types";
+
+// `<script>` / `<style>` content is code, not prose — drop it entirely before stripping tags. The
+// opening-tag match skips over quoted attribute values so a `>` inside an attribute does not end it early.
+const SCRIPT_OR_STYLE = /<(script|style)\b(?:"[^"]*"|'[^']*'|[^>])*>[\s\S]*?<\/\1\s*>/giu;
+const HTML_COMMENT = /<!--[\s\S]*?-->/gu;
+const HTML_TAG = /<[^>]+>/gu;
+const NAMED_ENTITIES: Record<string, string> = {
+  "&amp;": "&",
+  "&gt;": ">",
+  "&lt;": "<",
+  "&nbsp;": " ",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'",
+};
+
+function decodeEntities(input: string): string {
+  return input.replace(
+    /&(?:amp|gt|lt|nbsp|quot|apos|#39);/gu,
+    (match) => NAMED_ENTITIES[match] ?? match
+  );
+}
+
+export function stripHtml(html: string): string {
+  const withoutCode = html.replace(SCRIPT_OR_STYLE, " ").replace(HTML_COMMENT, " ");
+  const withoutTags = withoutCode.replace(HTML_TAG, " ");
+  return decodeEntities(withoutTags).replace(/\s+/gu, " ").trim();
+}
+
+export function extractRawHtmlText(block: RawHtmlBlock): string {
+  return stripHtml(block.html ?? "");
+}
diff --git a/apps/cms/src/collections/GlobalBlock/config.ts b/apps/cms/src/collections/GlobalBlock/config.ts
index f5ca9d6fb..37f4cdab9 100644
--- a/apps/cms/src/collections/GlobalBlock/config.ts
+++ b/apps/cms/src/collections/GlobalBlock/config.ts
@@ -3,10 +3,25 @@ import type { CollectionConfig } from "payload";
 import { contentBlocks } from "@/blocks/contentBlocks";
 import { anyone, author, or, superAdmin, user } from "@/lib/access";
 import { createLocalizedDefault } from "@/lib/utils/createLocalizedDefault";
+import { generatePreviewPath } from "@/lib/utils/generatePreviewPath";
+import { shouldIncludeLocalePrefix } from "@/lib/utils/localePrefix";
 
 import { preventDeleteIfReferenced } from "./hooks/preventDeleteIfReferenced";
 import { revalidatePagesUsingGlobalBlock } from "./hooks/revalidatePagesUsingGlobalBlock";
 
+// A global block is rendered standalone (no page URL of its own) at this route, so editors can
+// preview it before publishing — publishing affects every page that embeds it. The locale prefix is
+// added only when the routing config needs it (the default locale is unprefixed under `as-needed`).
+const globalBlockPreviewPath = (id: unknown, locale: string): string => {
+  const prefix = shouldIncludeLocalePrefix(locale) ? `/${locale}` : "";
+
+  return generatePreviewPath({
+    collection: "globalBlock",
+    path: `${prefix}/preview/global-block/${id}`,
+    slug: String(id ?? ""),
+  });
+};
+
 export const GlobalBlock: CollectionConfig<"globalBlock"> = {
   access: {
     create: or(superAdmin, user, author),
@@ -17,6 +32,11 @@ export const GlobalBlock: CollectionConfig<"globalBlock"> = {
   admin: {
     defaultColumns: ["title", "block", "updatedAt"],
     group: "Global Components",
+    livePreview: {
+      url: ({ data, locale }) =>
+        globalBlockPreviewPath(data?.id, locale.code ?? locale.fallbackLocale),
+    },
+    preview: (data, { locale }) => globalBlockPreviewPath(data?.id, locale),
     useAsTitle: "title",
   },
   dbName: "gsec",
diff --git a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
index d0e668394..b9582ff14 100644
--- a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
+++ b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
@@ -1,8 +1,7 @@
 import type { CollectionAfterChangeHook } from "payload";
 
-import { upsertPageEmbedding } from "@/collections/Page/hooks/indexEmbedding";
+import { PAGE_EMBEDDING_DEPTH, upsertPageEmbedding } from "@/collections/Page/hooks/indexEmbedding";
 import { I18N_CONFIG } from "@/lib/config/i18n";
-import { getLocaleFromRequest } from "@/lib/utils/getLocaleFromRequest";
 import { revalidatePageCache } from "@/lib/utils/revalidatePageCache";
 import type { GlobalBlock } from "@/payload-types";
 
@@ -25,13 +24,12 @@ export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBl
     return doc;
   }
 
-  const editedLocale = getLocaleFromRequest(req);
-
-  // Every locale is revalidated because locale fallback can render this block on pages of other locales.
+  // Every locale is revalidated and re-indexed because locale fallback can render this block — and
+  // its edited text — on pages of other locales, not just the one that was edited.
   for (const { code: locale } of I18N_CONFIG.locales) {
     const { docs: pages } = await payload.find({
       collection: "page",
-      depth: 0,
+      depth: PAGE_EMBEDDING_DEPTH,
       locale,
       overrideAccess: true,
       pagination: false,
@@ -42,7 +40,7 @@ export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBl
     for (const page of pages) {
       revalidatePageCache({ doc: page, locale, payload });
 
-      if (locale === editedLocale && !context.skipEmbedding) {
+      if (!context.skipEmbedding) {
         await upsertPageEmbedding({ locale, page, req });
       }
     }
diff --git a/apps/cms/src/collections/Page/extractPageText.ts b/apps/cms/src/collections/Page/extractPageText.ts
index 9940d60fb..8c029a6a1 100644
--- a/apps/cms/src/collections/Page/extractPageText.ts
+++ b/apps/cms/src/collections/Page/extractPageText.ts
@@ -3,11 +3,13 @@ import { extractCarouselText } from "@/blocks/Carousel/extractText";
 import { extractChartText } from "@/blocks/Chart/extractText";
 import { extractCtaBandText } from "@/blocks/CtaBand/extractText";
 import { extractNewsletterText } from "@/blocks/Newsletter/extractText";
+import { extractRawHtmlText } from "@/blocks/RawHtml/extractText";
 import { extractStatsText } from "@/blocks/Stats/extractText";
 import { extractFaqText } from "@/blocks/Faq/extractText";
 import { extractHeroText } from "@/blocks/Hero/extractText";
 import { extractLogosText } from "@/blocks/Logos/extractText";
 import { extractTestimonialsText } from "@/blocks/TestimonialsList/extractText";
+import { filterHiddenBlocks } from "@/lib/fields/section/filterHiddenBlocks";
 import { extractLexicalText, joinText } from "@/lib/utils/text";
 import type { Page } from "@/payload-types";
 
@@ -51,8 +53,13 @@ export function extractPageBlockText(block: Page["blocks"][number]): string {
     case "stats": {
       return extractStatsText(block);
     }
+    case "rawHtml": {
+      return extractRawHtmlText(block);
+    }
     case "globalSectionSlot": {
-      const inner = typeof block.reference === "object" ? block.reference.block?.[0] : undefined;
+      // Match the renderer: it shows the first visible inner block, so index that one, not a hidden one.
+      const [inner] =
+        typeof block.reference === "object" ? filterHiddenBlocks(block.reference.block) : [];
       return inner ? extractPageBlockText(inner) : "";
     }
     default: {
diff --git a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
index 1f12d1116..d5fe87d7a 100644
--- a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
+++ b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
@@ -3,12 +3,18 @@ import type { Pool } from "pg";
 
 import { extractPageText } from "@/collections/Page/extractPageText";
 import { resolveGlobalBlocks } from "@/collections/Page/resolveGlobalBlocks";
-import { getLocaleFromRequest } from "@/lib/utils/getLocaleFromRequest";
+import { I18N_CONFIG } from "@/lib/config/i18n";
 import type { Locale } from "@/lib/types";
 import type { Page } from "@/payload-types";
 import { upsertEmbedding, deleteEmbedding } from "@/lib/search/dbOperations";
 import { generateEmbedding } from "@/lib/search/generateEmbedding";
 
+// Depth to load a page at before extracting its search text. Some block extractors read a relationship
+// (e.g. TestimonialsList reads the related testimonial's text), so the page must be populated past
+// depth 0. Every path that re-indexes a page must use this same depth, or one path would overwrite the
+// embedding another path wrote with more (or less) text.
+export const PAGE_EMBEDDING_DEPTH = 2;
+
 export async function upsertPageEmbedding({
   locale,
   page,
@@ -19,7 +25,9 @@ export async function upsertPageEmbedding({
   req: PayloadRequest;
 }): Promise<void> {
   try {
-    const text = extractPageText(await resolveGlobalBlocks({ locale, page, req }));
+    const text = extractPageText(
+      await resolveGlobalBlocks({ depth: PAGE_EMBEDDING_DEPTH, locale, page, req })
+    );
     const embedding = await generateEmbedding(text);
     const { pool } = req.payload.db as unknown as { pool: Pool };
 
@@ -35,6 +43,35 @@ export async function upsertPageEmbedding({
   }
 }
 
+// Locale fallback means a page can render different text per locale (its own content, or a fallback
+// to another locale), so an edit in one locale must refresh every locale's embedding — not only the
+// edited one. The same holds for global block edits (see revalidatePagesUsingGlobalBlock).
+export async function reindexPageForAllLocales({
+  pageId,
+  req,
+}: {
+  pageId: number | string;
+  req: PayloadRequest;
+}): Promise<void> {
+  for (const { code } of I18N_CONFIG.locales) {
+    const locale = code as Locale;
+    const page = await req.payload
+      .findByID({
+        collection: "page",
+        depth: PAGE_EMBEDDING_DEPTH,
+        id: pageId,
+        locale,
+        overrideAccess: true,
+        req,
+      })
+      .catch(() => null);
+
+    if (page?._status === "published") {
+      await upsertPageEmbedding({ locale, page, req });
+    }
+  }
+}
+
 export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc, req }) => {
   if (doc._status !== "published") {
     return doc;
@@ -43,7 +80,7 @@ export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc,
     return doc;
   }
 
-  await upsertPageEmbedding({ locale: getLocaleFromRequest(req), page: doc, req });
+  await reindexPageForAllLocales({ pageId: doc.id, req });
 
   return doc;
 };
diff --git a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
index 5cbccc5b1..3aef9dec2 100644
--- a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
+++ b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
@@ -9,10 +9,14 @@ const slotId = (slot: Slot) =>
   typeof slot.reference === "object" ? slot.reference.id : slot.reference;
 
 export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
+  depth = 0,
   locale,
   page,
   req,
 }: {
+  // Depth to load the referenced blocks at. Callers that extract text from inner blocks pass a depth
+  // that populates the inner block's own relationships (e.g. a testimonialsList's testimonials).
+  depth?: number;
   locale: Locale;
   page: T;
   req: PayloadRequest;
@@ -26,7 +30,7 @@ export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
 
   const { docs } = await req.payload.find({
     collection: "globalBlock",
-    depth: 0,
+    depth,
     locale,
     overrideAccess: true,
     pagination: false,
diff --git a/apps/cms/src/lib/dal/getPageBySlug.ts b/apps/cms/src/lib/dal/getPageBySlug.ts
index 1d50e010b..98d8fa2c1 100644
--- a/apps/cms/src/lib/dal/getPageBySlug.ts
+++ b/apps/cms/src/lib/dal/getPageBySlug.ts
@@ -10,6 +10,10 @@ import { getPayloadClient } from "@/dal/payload-client";
 
 import { getAllDocuments } from "./getAllDocuments";
 
+// Depth pages are rendered at. Shared so a global block embedded through `globalSectionSlot` can be
+// re-populated at the same depth, giving its inner blocks the same relationship population as page blocks.
+export const PAGE_RENDER_DEPTH = 3;
+
 export async function getPageBySlugQuery(
   payload: Payload,
   pathSegmentsNorm: string[],
@@ -20,7 +24,7 @@ export async function getPageBySlugQuery(
   const lastSegment = pathSegmentsNorm.at(-1)!;
 
   const docs = await getAllDocuments(payload, "page", {
-    depth: 3,
+    depth: PAGE_RENDER_DEPTH,
     draft,
     locale: resolvedLocale,
     overrideAccess: true,
diff --git a/apps/cms/src/lib/dal/index.ts b/apps/cms/src/lib/dal/index.ts
index 2352a91f3..2b9ccd7fc 100644
--- a/apps/cms/src/lib/dal/index.ts
+++ b/apps/cms/src/lib/dal/index.ts
@@ -8,7 +8,7 @@
 export { getPayloadClient } from "./payload-client";
 
 // Pages
-export { getPageBySlug } from "./getPageBySlug";
+export { getPageBySlug, PAGE_RENDER_DEPTH } from "./getPageBySlug";
 
 // Posts
 export { getPostBySlug } from "./getPostBySlug";
diff --git a/apps/cms/src/lib/plugins/index.ts b/apps/cms/src/lib/plugins/index.ts
index f63d03e65..a6d5d9594 100644
--- a/apps/cms/src/lib/plugins/index.ts
+++ b/apps/cms/src/lib/plugins/index.ts
@@ -18,6 +18,7 @@ import type { Field, PayloadRequest, Plugin } from "payload";
 import { Authors } from "@/collections/Authors";
 import { Categories } from "@/collections/Categories";
 import { Footer } from "@/collections/Footer/config";
+import { GlobalBlock } from "@/collections/GlobalBlock/config";
 import { Header } from "@/collections/Header/config";
 import { Page as PageCollection } from "@/collections/Page/Page";
 import serverExtractPageContent from "@/collections/Page/serverExtractPageContent";
@@ -299,6 +300,7 @@ export const plugins: Plugin[] = [
       { slug: "testimonials", titleField: "author" },
       { slug: "header", titleField: "name" },
       { slug: "footer", titleField: "name" },
+      { slug: "globalBlock", titleField: "title" },
     ],
 
     translations: {
@@ -333,7 +335,7 @@ export const plugins: Plugin[] = [
   }),
 
   schedulePublicationPlugin({
-    collections: ["page", "posts"],
+    collections: ["page", "posts", "globalBlock"],
     globals: ["site-settings"],
     schedulePublish: {
       timeIntervals: 60,
@@ -342,8 +344,17 @@ export const plugins: Plugin[] = [
   }),
 
   translatorPlugin({
-    collections: [PageCollection, Posts, Categories, Authors, Testimonials, Header, Footer].map(
-      (col) => JSON.parse(JSON.stringify(col, (_, v) => (typeof v === "function" ? undefined : v)))
+    collections: [
+      PageCollection,
+      Posts,
+      Categories,
+      Authors,
+      Testimonials,
+      Header,
+      Footer,
+      GlobalBlock,
+    ].map((col) =>
+      JSON.parse(JSON.stringify(col, (_, v) => (typeof v === "function" ? undefined : v)))
     ),
     access: { check: ({ req }) => Boolean(req.user) },
     runner: createSyncRunner(),
diff --git a/apps/cms/src/lib/utils/generatePreviewPath.ts b/apps/cms/src/lib/utils/generatePreviewPath.ts
index a0c6a20b2..ee15db173 100644
--- a/apps/cms/src/lib/utils/generatePreviewPath.ts
+++ b/apps/cms/src/lib/utils/generatePreviewPath.ts
@@ -1,7 +1,7 @@
 import type { BLOG_CONFIG } from "@/lib/config/blog";
 
 interface Props {
-  collection: "page" | typeof BLOG_CONFIG.collection;
+  collection: "page" | "globalBlock" | typeof BLOG_CONFIG.collection;
   slug: string;
   path: string;
 }

From 1e8ae34ab1dda4dbf9f8ab53eb3b45c31458d7f7 Mon Sep 17 00:00:00 2001
From: Maksim Hodasevich <maksim.hodasevich@gmail.com>
Date: Tue, 27 Oct 2026 14:20:38 +0100
Subject: [PATCH 4/5] refactor(cms): keep global block text out of page search
 vectors

- Page search: `globalSectionSlot` contributes no text, so one global block
  edit no longer re-embeds every page that uses it.
- GlobalBlock: the revalidation hook only refreshes page caches now, and
  loads only `breadcrumbs` and `slug`.
- Remove `resolveGlobalBlocks` and restore the original page embedding hook.
- `revalidatePageCache` takes only the page fields it reads.
---
 .../hooks/revalidatePagesUsingGlobalBlock.ts  |  6 +--
 .../src/collections/Page/extractPageText.ts   |  6 +--
 .../collections/Page/hooks/indexEmbedding.ts  | 37 +++++---------
 .../collections/Page/resolveGlobalBlocks.ts   | 48 -------------------
 apps/cms/src/lib/utils/revalidatePageCache.ts |  6 ++-
 5 files changed, 20 insertions(+), 83 deletions(-)
 delete mode 100644 apps/cms/src/collections/Page/resolveGlobalBlocks.ts

diff --git a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
index 14eb4f1ca..dc3c9a23c 100644
--- a/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
+++ b/apps/cms/src/collections/GlobalBlock/hooks/revalidatePagesUsingGlobalBlock.ts
@@ -1,6 +1,5 @@
 import type { CollectionAfterChangeHook, PayloadRequest } from "payload";
 
-import { upsertPageEmbedding } from "@/collections/Page/hooks/indexEmbedding";
 import { I18N_CONFIG } from "@/lib/config/i18n";
 import { revalidatePageCache } from "@/lib/utils/revalidatePageCache";
 import type { GlobalBlock } from "@/payload-types";
@@ -56,15 +55,12 @@ export const revalidatePagesUsingGlobalBlock: CollectionAfterChangeHook<GlobalBl
       overrideAccess: true,
       pagination: false,
       req,
+      select: { breadcrumbs: true, slug: true },
       where: { _status: { equals: "published" }, id: { in: pageIds } },
     });
 
     for (const page of publishedPages) {
       revalidatePageCache({ doc: page, locale, payload });
-
-      if (!context.skipEmbedding) {
-        await upsertPageEmbedding({ locale, page, req });
-      }
     }
   }
 
diff --git a/apps/cms/src/collections/Page/extractPageText.ts b/apps/cms/src/collections/Page/extractPageText.ts
index 8327ce0a1..299c2904f 100644
--- a/apps/cms/src/collections/Page/extractPageText.ts
+++ b/apps/cms/src/collections/Page/extractPageText.ts
@@ -8,7 +8,6 @@ import { extractFaqText } from "@/blocks/Faq/extractText";
 import { extractHeroText } from "@/blocks/Hero/extractText";
 import { extractLogosText } from "@/blocks/Logos/extractText";
 import { extractTestimonialsText } from "@/blocks/TestimonialsList/extractText";
-import { isPublishedGlobalBlock } from "@/collections/GlobalBlock/slots";
 import { extractLexicalText, joinText } from "@/lib/utils/text";
 import type { Page } from "@/payload-types";
 
@@ -53,9 +52,8 @@ export function extractPageBlockText(block: Page["blocks"][number]): string {
       return extractStatsText(block);
     }
     case "globalSectionSlot": {
-      const reference = typeof block.reference === "object" ? block.reference : null;
-      const inner = isPublishedGlobalBlock(reference) ? reference?.block?.[0] : undefined;
-      return inner ? extractPageBlockText(inner) : "";
+      // Shared text stays out of page vectors, so one global block edit does not re-embed every page using it.
+      return "";
     }
     default: {
       return "";
diff --git a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
index 1f12d1116..3e6830724 100644
--- a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
+++ b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
@@ -1,31 +1,29 @@
-import type { CollectionAfterChangeHook, CollectionAfterDeleteHook, PayloadRequest } from "payload";
+import type { CollectionAfterChangeHook, CollectionAfterDeleteHook } from "payload";
 import type { Pool } from "pg";
 
 import { extractPageText } from "@/collections/Page/extractPageText";
-import { resolveGlobalBlocks } from "@/collections/Page/resolveGlobalBlocks";
 import { getLocaleFromRequest } from "@/lib/utils/getLocaleFromRequest";
-import type { Locale } from "@/lib/types";
 import type { Page } from "@/payload-types";
 import { upsertEmbedding, deleteEmbedding } from "@/lib/search/dbOperations";
 import { generateEmbedding } from "@/lib/search/generateEmbedding";
 
-export async function upsertPageEmbedding({
-  locale,
-  page,
-  req,
-}: {
-  locale: Locale;
-  page: Page;
-  req: PayloadRequest;
-}): Promise<void> {
+export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc, req }) => {
+  if (doc._status !== "published") {
+    return doc;
+  }
+  if (req.context?.skipEmbedding) {
+    return doc;
+  }
+
   try {
-    const text = extractPageText(await resolveGlobalBlocks({ locale, page, req }));
+    const locale = getLocaleFromRequest(req);
+    const text = extractPageText(doc);
     const embedding = await generateEmbedding(text);
     const { pool } = req.payload.db as unknown as { pool: Pool };
 
     await upsertEmbedding({
       collection: "page",
-      documentId: String(page.id),
+      documentId: String(doc.id),
       embedding,
       locale,
       pool,
@@ -33,17 +31,6 @@ export async function upsertPageEmbedding({
   } catch (error) {
     req.payload.logger.error({ error }, "Failed to index page embedding");
   }
-}
-
-export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc, req }) => {
-  if (doc._status !== "published") {
-    return doc;
-  }
-  if (req.context?.skipEmbedding) {
-    return doc;
-  }
-
-  await upsertPageEmbedding({ locale: getLocaleFromRequest(req), page: doc, req });
 
   return doc;
 };
diff --git a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts b/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
deleted file mode 100644
index d14eaf791..000000000
--- a/apps/cms/src/collections/Page/resolveGlobalBlocks.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { PayloadRequest } from "payload";
-
-import { collectGlobalBlockIds, isPublishedGlobalBlock } from "@/collections/GlobalBlock/slots";
-import { relationId } from "@/lib/contentExtraction";
-import type { Locale } from "@/lib/types";
-import type { Page } from "@/payload-types";
-
-export async function resolveGlobalBlocks<T extends Pick<Page, "blocks">>({
-  locale,
-  page,
-  req,
-}: {
-  locale: Locale;
-  page: T;
-  req: PayloadRequest;
-}): Promise<T> {
-  const blocks = page.blocks ?? [];
-  const ids = collectGlobalBlockIds(blocks);
-
-  if (ids.length === 0) {
-    return page;
-  }
-
-  const { docs } = await req.payload.find({
-    collection: "globalBlock",
-    depth: 0,
-    locale,
-    overrideAccess: true,
-    pagination: false,
-    req,
-    where: { id: { in: ids } },
-  });
-  const publishedById = new Map(
-    docs.filter(isPublishedGlobalBlock).map((doc) => [String(doc.id), doc])
-  );
-
-  return {
-    ...page,
-    blocks: blocks.map((block) => {
-      if (block.blockType !== "globalSectionSlot") return block;
-
-      const id = relationId(block.reference);
-      const published = id == null ? undefined : publishedById.get(String(id));
-
-      return published ? { ...block, reference: published } : block;
-    }),
-  };
-}
diff --git a/apps/cms/src/lib/utils/revalidatePageCache.ts b/apps/cms/src/lib/utils/revalidatePageCache.ts
index 4007fe782..62a095e45 100644
--- a/apps/cms/src/lib/utils/revalidatePageCache.ts
+++ b/apps/cms/src/lib/utils/revalidatePageCache.ts
@@ -7,7 +7,11 @@ import { getPathFromBreadcrumbs } from "../utils/path/getPathFromBreadcrumbs";
 import { cacheTag } from "./cacheTags";
 import { revalidateScopedTag } from "./scopedCache";
 
-export function revalidatePageCache(params: { doc: Page; locale: Locale; payload: Payload }): void {
+export function revalidatePageCache(params: {
+  doc: Pick<Page, "breadcrumbs" | "slug">;
+  locale: Locale;
+  payload: Payload;
+}): void {
   const path = getPathFromBreadcrumbs(params.doc.breadcrumbs) ?? "home";
   params.payload.logger?.info?.(`Revalidating page with slug: ${params.doc.slug}`);
   revalidateScopedTag(cacheTag({ locale: params.locale, path, type: "page" }), "max");

From ba295e5c443b3b120cd45e1f64fac1ae7de9f033 Mon Sep 17 00:00:00 2001
From: Maksim Hodasevich <maksim.hodasevich@gmail.com>
Date: Tue, 27 Oct 2026 14:39:38 +0100
Subject: [PATCH 5/5] fix(cms): index a new page for search once, not twice

Page: skip the embedding on `create`. The nested-docs plugin re-saves every
new page as an update (resaveSelfAfterCreate), and that update already
indexes it, so each new page sent two OpenAI requests per locale.
---
 apps/cms/src/collections/Page/hooks/indexEmbedding.ts | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
index 70d521d95..25e14f959 100644
--- a/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
+++ b/apps/cms/src/collections/Page/hooks/indexEmbedding.ts
@@ -54,7 +54,15 @@ async function reindexPageInEveryLocale({ id, req }: { id: number; req: PayloadR
   }
 }
 
-export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({ doc, req }) => {
+export const indexPageEmbedding: CollectionAfterChangeHook<Page> = async ({
+  doc,
+  operation,
+  req,
+}) => {
+  // nested-docs re-saves every new page as an update (resaveSelfAfterCreate), and that update indexes it.
+  if (operation === "create") {
+    return doc;
+  }
   if (doc._status !== "published") {
     return doc;
   }