@justanarthur/payload-www 0.1.1

package/dist/server.js

@@ -0,0 +1,2055 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/render/components/PageShowcase.tsx
+var exports_PageShowcase = {};
+__export(exports_PageShowcase, {
+  PageShowcase: () => PageShowcase
+});
+import * as React from "react";
+import { jsx as jsx5, jsxs } from "react/jsx-runtime";
+function PageShowcase({
+  children,
+  metadata,
+  jsonLd,
+  localeSwitcher,
+  metadataHeading = "Page metadata",
+  jsonLdHeading = "JSON-LD"
+}) {
+  const og = metadata.openGraph;
+  const twitter = metadata.twitter;
+  const rows = [
+    ["Title", resolveTitle(metadata.title)],
+    ["Description", metadata.description],
+    ["Canonical", metadata.alternates?.canonical],
+    [
+      "Languages",
+      metadata.alternates?.languages ? Object.entries(metadata.alternates.languages).map(([locale, url]) => `${locale}: ${url}`).join(`
+`) : undefined
+    ],
+    ["Open Graph title", og?.title],
+    ["Open Graph description", og?.description],
+    ["Open Graph type", og?.type],
+    ["Open Graph url", og?.url],
+    ["Open Graph site name", og?.siteName],
+    ["Twitter card", twitter?.card],
+    ["Twitter title", twitter?.title],
+    ["Twitter description", twitter?.description],
+    ["Twitter site", twitter?.site],
+    ["Twitter creator", twitter?.creator]
+  ];
+  return /* @__PURE__ */ jsxs("div", {
+    className: "page-showcase grid gap-8 lg:grid-cols-[1fr_320px]",
+    children: [
+      /* @__PURE__ */ jsx5("main", {
+        className: "page-showcase__main",
+        children
+      }),
+      /* @__PURE__ */ jsxs("aside", {
+        className: "page-showcase__sidebar flex flex-col gap-6 text-sm",
+        children: [
+          /* @__PURE__ */ jsxs("section", {
+            className: "page-showcase__locale",
+            children: [
+              /* @__PURE__ */ jsx5("h2", {
+                className: "m-0 mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+                children: "Language"
+              }),
+              localeSwitcher
+            ]
+          }),
+          /* @__PURE__ */ jsxs("section", {
+            className: "page-showcase__metadata",
+            children: [
+              /* @__PURE__ */ jsx5("h2", {
+                className: "m-0 mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+                children: metadataHeading
+              }),
+              /* @__PURE__ */ jsx5("dl", {
+                className: "m-0 grid grid-cols-[max-content_1fr] gap-x-3 gap-y-1.5",
+                children: rows.filter(([, value]) => value !== undefined && value !== "").map(([label, value]) => /* @__PURE__ */ jsxs(React.Fragment, {
+                  children: [
+                    /* @__PURE__ */ jsx5("dt", {
+                      className: "font-medium text-muted-foreground",
+                      children: label
+                    }),
+                    /* @__PURE__ */ jsx5("dd", {
+                      className: "m-0 whitespace-pre-wrap break-words font-mono text-xs",
+                      children: value
+                    })
+                  ]
+                }, label))
+              })
+            ]
+          }),
+          jsonLd.length > 0 ? /* @__PURE__ */ jsxs("section", {
+            className: "page-showcase__jsonld",
+            children: [
+              /* @__PURE__ */ jsx5("h2", {
+                className: "m-0 mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+                children: jsonLdHeading
+              }),
+              jsonLd.map(({ id, schema }) => /* @__PURE__ */ jsxs("details", {
+                className: "mb-2 rounded border border-border bg-muted/30 p-2",
+                children: [
+                  /* @__PURE__ */ jsx5("summary", {
+                    className: "cursor-pointer font-mono text-xs",
+                    children: id
+                  }),
+                  /* @__PURE__ */ jsx5("pre", {
+                    className: "mt-2 overflow-x-auto whitespace-pre-wrap break-words font-mono text-[10px] leading-snug",
+                    children: JSON.stringify(schema, null, 2)
+                  })
+                ]
+              }, id))
+            ]
+          }) : null
+        ]
+      })
+    ]
+  });
+}
+function resolveTitle(title) {
+  if (!title)
+    return;
+  if (typeof title === "string")
+    return title;
+  if (title === null)
+    return;
+  const t = title;
+  return t.absolute ?? t.template ?? t.default;
+}
+var init_PageShowcase = () => {};
+
+// src/render/components/LocaleSwitcher.tsx
+var exports_LocaleSwitcher = {};
+__export(exports_LocaleSwitcher, {
+  LocaleSwitcher: () => LocaleSwitcher
+});
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+function LocaleSwitcher({
+  currentLocale,
+  hreflangAlternates,
+  labels
+}) {
+  const locales = Object.keys(hreflangAlternates).filter((k) => k !== "x-default");
+  return /* @__PURE__ */ jsx6("nav", {
+    "aria-label": "Language",
+    className: "locale-switcher",
+    children: /* @__PURE__ */ jsxs2("ul", {
+      className: "flex flex-wrap gap-2 list-none p-0 m-0",
+      children: [
+        locales.map((locale) => {
+          const href = hreflangAlternates[locale];
+          if (!href)
+            return null;
+          const isCurrent = locale === currentLocale;
+          return /* @__PURE__ */ jsx6("li", {
+            children: /* @__PURE__ */ jsx6("a", {
+              href,
+              "aria-current": isCurrent ? "true" : undefined,
+              hrefLang: locale,
+              className: "locale-switcher__link",
+              "data-locale": locale,
+              children: labels?.[locale] ?? locale.toUpperCase()
+            })
+          }, locale);
+        }),
+        hreflangAlternates["x-default"] ? /* @__PURE__ */ jsx6("li", {
+          children: /* @__PURE__ */ jsx6("a", {
+            href: hreflangAlternates["x-default"],
+            hrefLang: "x-default",
+            className: "locale-switcher__link",
+            "data-locale": "x-default",
+            children: labels?.["x-default"] ?? "Default"
+          })
+        }, "x-default") : null
+      ]
+    })
+  });
+}
+var init_LocaleSwitcher = () => {};
+
+// src/core/access/index.ts
+var anyone = () => true;
+var authenticated = ({ req: { user } }) => Boolean(user);
+var authenticatedOrPublished = ({ req: { user } }) => {
+  if (user)
+    return true;
+  return { _status: { equals: "published" } };
+};
+
+// src/render/_locale.ts
+function prefixFor(locale, defaultLocale, mode) {
+  if (mode === "never")
+    return "";
+  if (mode === "as-needed" && locale === defaultLocale)
+    return "";
+  return `/${locale}`;
+}
+function resolveLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const r = req;
+  if (typeof r.locale === "string" && r.locale.length > 0)
+    return r.locale;
+  const fallback = r.payload?.config?.localization?.defaultLocale;
+  if (typeof fallback === "string" && fallback.length > 0)
+    return fallback;
+  return "";
+}
+function allLocales(req) {
+  if (!req || typeof req !== "object")
+    return [];
+  const r = req;
+  const list = r.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.push(entry);
+    } else if (entry && typeof entry === "object" && "code" in entry) {
+      const code = entry.code;
+      if (typeof code === "string" && code.length > 0)
+        out.push(code);
+    }
+  }
+  return out;
+}
+
+// src/render/hooks/_shared.ts
+var cachePromise = null;
+function nextCacheImport() {
+  return cachePromise ??= import("next/cache");
+}
+function shouldSkipRevalidate(context) {
+  return Boolean(context?.disableRevalidate);
+}
+async function safeRevalidatePath(payload, path) {
+  try {
+    const { revalidatePath } = await nextCacheImport();
+    revalidatePath(path);
+  } catch (error) {
+    payload.logger.error(`revalidatePath("${path}") failed: ${String(error)}`);
+  }
+}
+async function safeRevalidateTag(payload, tag, profile = "max") {
+  try {
+    const { revalidateTag } = await nextCacheImport();
+    revalidateTag(tag, profile);
+  } catch (error) {
+    payload.logger.error(`revalidateTag("${tag}") failed: ${String(error)}`);
+  }
+}
+
+// src/render/hooks/revalidateCollection.ts
+function createRevalidateCollectionHook(options) {
+  const {
+    collectionSlug,
+    urlPathPrefix = "",
+    sitemapTag,
+    localePrefix: modeOption,
+    defaultLocale: defaultLocaleOption,
+    pathMode = "url"
+  } = options;
+  const resolvedSitemapTag = sitemapTag === false ? false : sitemapTag ?? `${collectionSlug}-sitemap`;
+  const resolveDefaults = (req) => {
+    const mode = modeOption ?? "always";
+    const defaultLocale = defaultLocaleOption ?? req?.payload?.config?.localization?.defaultLocale ?? "";
+    return { mode, defaultLocale };
+  };
+  const localesToFanOut = (req) => {
+    const all = allLocales(req);
+    if (all.length > 0)
+      return all;
+    const single = resolveLocale(req);
+    return single ? [single] : [];
+  };
+  const collectionPath = (slug, locale, mode, defaultLocale) => {
+    const prefix = prefixFor(locale, defaultLocale, mode);
+    if (!slug)
+      return `${prefix}${urlPathPrefix}` || "/";
+    return `${prefix}${urlPathPrefix}/${slug}`;
+  };
+  const fanOutPaths = async (payload, req, slug, label) => {
+    const { mode, defaultLocale } = resolveDefaults(req);
+    const locales = localesToFanOut(req);
+    for (const locale of locales) {
+      const path = collectionPath(slug, locale, mode, defaultLocale);
+      payload.logger.info?.(`${label} ${path}`);
+      await safeRevalidatePath(payload, path);
+    }
+  };
+  const fireCollectionTags = async (payload, docId, req) => {
+    if (typeof docId === "string" || typeof docId === "number") {
+      await safeRevalidateTag(payload, `collection_${collectionSlug}_${docId}`);
+    }
+    if (resolvedSitemapTag !== false) {
+      await safeRevalidateTag(payload, resolvedSitemapTag);
+    }
+  };
+  const afterChange = async ({ doc, previousDoc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc;
+    const { payload } = req;
+    const typed = doc;
+    const prev = previousDoc;
+    const isPublished = typed._status === "published";
+    const wasPublished = prev?._status === "published";
+    const prevSlugIsString = typeof prev?.slug === "string";
+    const slugChanged = prevSlugIsString && prev?.slug !== typed.slug;
+    if (isPublished) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, typed.slug, `Revalidating ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    if (wasPublished && (!isPublished || slugChanged)) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, prev?.slug, `Revalidating old ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    return doc;
+  };
+  const afterDelete = async ({ doc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc ?? null;
+    const { payload } = req;
+    const typed = doc;
+    if (pathMode !== "tag-only") {
+      await fanOutPaths(payload, req, typed?.slug, `Revalidating deleted ${collectionSlug} at path:`);
+    }
+    await fireCollectionTags(payload, typed?.id, req);
+    return doc ?? null;
+  };
+  return { afterChange, afterDelete };
+}
+var createRevalidatePageHooks = (opts = {}) => createRevalidateCollectionHook({
+  collectionSlug: "pages",
+  urlPathPrefix: "",
+  ...opts
+});
+
+// src/config/constants.ts
+var PAGES_RENDER_PATH = "@justanarthur/payload-www/render-pages#PagesPage";
+var POSTS_RENDER_PATH = "@justanarthur/payload-www/render-pages#PostsPage";
+var HEADER_RENDER_PATH = "@justanarthur/payload-www/render-pages#HeaderPage";
+var FOOTER_RENDER_PATH = "@justanarthur/payload-www/render-pages#FooterPage";
+var LIVE_PREVIEW_LISTENER_PATH = "@justanarthur/payload-www/render-components#LivePreviewListener";
+var PAGES_SLUG = "pages";
+var POSTS_SLUG = "posts";
+var STATIC_PAGES_SLUG = "staticPages";
+
+// src/data/collections/Pages/index.ts
+var HOME_PAGE_SLUG = "";
+var PAGES_SLUG2 = PAGES_SLUG;
+var createPagesCollection = (blocks, options = {}) => {
+  const {
+    renderPath = PAGES_RENDER_PATH,
+    slug: collectionSlug = PAGES_SLUG2,
+    localePrefix,
+    defaultLocale
+  } = options;
+  const slugField = {
+    name: "slug",
+    type: "text",
+    required: true,
+    unique: true,
+    index: true,
+    admin: { position: "sidebar" },
+    validate: (value) => {
+      if (typeof value !== "string")
+        return "Slug must be a string";
+      if (value !== "" && !/^[a-z0-9-]+$/.test(value)) {
+        return "Slug must be lowercase, with hyphens (no spaces or special characters)";
+      }
+      return true;
+    }
+  };
+  const baseFields = [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      localized: true
+    },
+    {
+      type: "tabs",
+      tabs: [
+        {
+          fields: [
+            {
+              name: "blocks",
+              type: "blocks",
+              blocks,
+              required: true,
+              admin: { initCollapsed: true }
+            }
+          ],
+          label: "Content"
+        }
+      ]
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: { position: "sidebar" }
+    },
+    slugField
+  ];
+  const { afterChange: revalidateAfterChange, afterDelete: revalidateAfterDelete } = createRevalidateCollectionHook({
+    collectionSlug,
+    urlPathPrefix: "",
+    localePrefix,
+    defaultLocale
+  });
+  return {
+    slug: collectionSlug,
+    custom: { path: renderPath },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: baseFields,
+    hooks: {
+      afterChange: [revalidateAfterChange],
+      afterDelete: [revalidateAfterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/data/collections/Posts/index.ts
+var POSTS_SLUG2 = "posts";
+var createPostsCollection = (options = {}) => {
+  const {
+    renderPath = POSTS_RENDER_PATH,
+    slug: collectionSlug = POSTS_SLUG2,
+    localePrefix,
+    defaultLocale
+  } = options;
+  const slugField = {
+    name: "slug",
+    type: "text",
+    required: true,
+    unique: true,
+    index: true,
+    admin: { position: "sidebar" }
+  };
+  const baseFields = [
+    {
+      name: "title",
+      type: "text",
+      required: true,
+      localized: true
+    },
+    {
+      name: "excerpt",
+      type: "text",
+      required: false,
+      localized: true
+    },
+    {
+      name: "content",
+      type: "richText",
+      required: false,
+      localized: true
+    },
+    {
+      name: "publishedAt",
+      type: "date",
+      admin: { position: "sidebar" }
+    },
+    slugField
+  ];
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug,
+    urlPathPrefix: "/posts",
+    localePrefix,
+    defaultLocale
+  });
+  return {
+    slug: collectionSlug,
+    custom: { path: renderPath },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: baseFields,
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/data/collections/StaticPages/index.ts
+var createStaticPagesCollection = (blocks) => {
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug: STATIC_PAGES_SLUG,
+    pathMode: "tag-only",
+    sitemapTag: "static-pages"
+  });
+  return {
+    slug: STATIC_PAGES_SLUG,
+    dbName: "sp",
+    admin: { group: "System", useAsTitle: "title" },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: [
+      {
+        name: "kind",
+        type: "select",
+        required: true,
+        unique: true,
+        index: true,
+        options: [
+          { label: "Not found (404)", value: "not-found" },
+          { label: "Server error (500)", value: "server-error" },
+          { label: "Search empty", value: "search-empty" },
+          { label: "Offline", value: "offline" }
+        ],
+        admin: {
+          position: "sidebar",
+          description: "Which system page this row powers. One row per kind."
+        }
+      },
+      {
+        name: "title",
+        type: "text",
+        required: true,
+        localized: true,
+        admin: { description: "Admin-only label. Not rendered." }
+      },
+      {
+        type: "tabs",
+        tabs: [
+          {
+            fields: [
+              {
+                name: "blocks",
+                type: "blocks",
+                localized: true,
+                blocks,
+                admin: { initCollapsed: true },
+                dbName: "b"
+              }
+            ],
+            label: "Content"
+          }
+        ]
+      },
+      {
+        name: "publishedAt",
+        type: "date",
+        admin: { position: "sidebar" }
+      }
+    ],
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/core/fields/link.ts
+var appearanceOptions = {
+  default: { label: "Default", value: "default" },
+  outline: { label: "Outline", value: "outline" }
+};
+var link = (options = {}) => {
+  const {
+    appearances,
+    disableLabel = false,
+    relationTo = [PAGES_SLUG],
+    localized = false,
+    overrides = {}
+  } = options;
+  const result = {
+    name: "link",
+    type: "group",
+    admin: { hideGutter: true },
+    fields: [
+      {
+        type: "row",
+        fields: [
+          {
+            name: "type",
+            type: "radio",
+            admin: { layout: "horizontal", width: "50%" },
+            defaultValue: "reference",
+            options: [
+              { label: "Internal link", value: "reference" },
+              { label: "Custom URL", value: "custom" }
+            ]
+          },
+          {
+            name: "newTab",
+            type: "checkbox",
+            admin: { style: { alignSelf: "flex-end" }, width: "50%" },
+            label: "Open in new tab"
+          }
+        ]
+      }
+    ]
+  };
+  const linkTypes = [
+    {
+      name: "reference",
+      type: "relationship",
+      admin: { condition: (_, siblingData) => siblingData?.type === "reference" },
+      label: "Document to link to",
+      relationTo,
+      required: true,
+      localized
+    },
+    {
+      name: "url",
+      type: "text",
+      admin: { condition: (_, siblingData) => siblingData?.type === "custom" },
+      label: "Custom URL",
+      required: true,
+      localized
+    }
+  ];
+  if (!disableLabel) {
+    result.fields.push({
+      type: "row",
+      fields: [
+        ...linkTypes,
+        {
+          name: "label",
+          type: "text",
+          admin: { width: "50%" },
+          label: "Label",
+          required: true,
+          localized
+        }
+      ]
+    });
+  } else {
+    result.fields = [...result.fields, ...linkTypes];
+  }
+  if (appearances !== false) {
+    const opts = appearances ? appearances.map((a) => appearanceOptions[a]) : [appearanceOptions.default, appearanceOptions.outline];
+    result.fields.push({
+      name: "appearance",
+      type: "select",
+      admin: { description: "Choose how the link should be rendered." },
+      defaultValue: "default",
+      options: opts
+    });
+  }
+  return { ...result, ...overrides };
+};
+
+// src/render/hooks/revalidateGlobal.ts
+function createRevalidateGlobalHook(slug) {
+  return async ({ doc, req: { payload, context, locale } }) => {
+    if (shouldSkipRevalidate(context))
+      return doc;
+    const tags = [`global_${slug}`, `global_${slug}_${locale}`];
+    payload.logger.info?.(`Revalidating global: ${tags.join(", ")}`);
+    for (const tag of tags) {
+      await safeRevalidateTag(payload, tag);
+    }
+    return doc;
+  };
+}
+
+// src/data/collections/globals/Header/config.ts
+var createHeaderGlobal = (options = {}) => {
+  const { renderPath = HEADER_RENDER_PATH, linkRelationTo = [PAGES_SLUG] } = options;
+  const navColumnBlock = {
+    slug: "navColumn",
+    fields: [
+      { name: "title", type: "text", required: true, localized: true },
+      { name: "links", type: "array", fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })] }
+    ]
+  };
+  const navItemBlock = {
+    slug: "navItem",
+    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })]
+  };
+  return {
+    slug: "header",
+    custom: { path: renderPath },
+    access: { read: () => true },
+    fields: [
+      {
+        name: "nav",
+        type: "blocks",
+        required: true,
+        blocks: [navColumnBlock, navItemBlock]
+      }
+    ],
+    hooks: {
+      afterChange: [createRevalidateGlobalHook("header")]
+    }
+  };
+};
+
+// src/data/collections/globals/Footer/config.ts
+var createFooterGlobal = (options = {}) => {
+  const { renderPath = FOOTER_RENDER_PATH, linkRelationTo = [PAGES_SLUG] } = options;
+  const navColumnBlock = {
+    slug: "navColumn",
+    fields: [
+      { name: "title", type: "text", required: true, localized: true },
+      { name: "links", type: "array", fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })] }
+    ]
+  };
+  const navItemBlock = {
+    slug: "navItem",
+    fields: [link({ appearances: false, localized: true, relationTo: linkRelationTo })]
+  };
+  return {
+    slug: "footer",
+    custom: { path: renderPath },
+    access: { read: () => true },
+    fields: [
+      {
+        name: "nav",
+        type: "blocks",
+        required: true,
+        blocks: [navColumnBlock, navItemBlock]
+      }
+    ],
+    hooks: {
+      afterChange: [createRevalidateGlobalHook("footer")]
+    }
+  };
+};
+
+// src/config/createWWWConfig.ts
+import openAIResolver from "@justanarthur/payload-plugin-translator/resolvers/openAI";
+
+// src/render/preview/createPreviewHandler.ts
+function createPreviewHandler(options) {
+  const { getServerSideURL: _getServerSideURL, secret, enableDraftMode = true } = options;
+  return async function GET(req) {
+    const { draftMode } = await import("next/headers");
+    const { redirect } = await import("next/navigation");
+    const url = new URL(req.url);
+    const path = url.searchParams.get("path") ?? "/";
+    const previewSecret = url.searchParams.get("previewSecret");
+    if (!previewSecret || previewSecret !== secret) {
+      return new Response("Invalid preview secret", { status: 401 });
+    }
+    if (enableDraftMode) {
+      (await draftMode()).enable();
+    }
+    redirect(path);
+    return new Response(null, { status: 204 });
+  };
+}
+// src/render/metadata/hreflang.ts
+async function buildHreflangAlternates({
+  siteUrl,
+  locale,
+  urlPrefix,
+  storedSlug,
+  queryAllLocaleSlugs,
+  nested,
+  homeSlug,
+  defaultLocale,
+  locales,
+  localePrefix = "always"
+}) {
+  const allLocaleSlugs = await queryAllLocaleSlugs(storedSlug, locale);
+  const languages = {};
+  const urlFor = (l, slug) => {
+    const trimmedPrefix = urlPrefix.replace(/^\/|\/$/g, "");
+    const prefixSegment = trimmedPrefix ? `/${trimmedPrefix}` : "";
+    const urlPath = slug === homeSlug ? "/" : nested ? "/" + slug.replaceAll("_", "/") : "/" + slug;
+    const localeSegment = localePrefix === "never" ? "" : localePrefix === "as-needed" && l === defaultLocale ? "" : `/${l}`;
+    return `${siteUrl}${localeSegment}${prefixSegment}${urlPath}`;
+  };
+  for (const l of locales) {
+    const slugForLocale = allLocaleSlugs?.[l];
+    if (!slugForLocale)
+      continue;
+    languages[l] = urlFor(l, slugForLocale);
+  }
+  if (allLocaleSlugs?.[defaultLocale]) {
+    languages["x-default"] = urlFor(defaultLocale, allLocaleSlugs[defaultLocale]);
+  }
+  return languages;
+}
+
+// src/render/metadata/query.ts
+import { getPayload } from "payload";
+import { cache } from "react";
+
+// src/core/utils/getFromImportMap.ts
+function getFromImportMap(key, importMap) {
+  return importMap[key.includes("#") ? key : key + "#default"];
+}
+
+// src/render/metadata/query.ts
+var queryDocBySlug = cache(async function queryDocBySlug2({
+  collectionSlug,
+  slug,
+  slugField = "slug",
+  locale,
+  draft = false,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft,
+    limit: 1,
+    pagination: false,
+    overrideAccess: draft,
+    where: { [slugField]: { equals: slug } },
+    locale
+  });
+  return result.docs?.[0] ?? null;
+});
+var queryAllDocs = cache(async function queryAllDocs2({
+  collectionSlug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft: false,
+    limit: 1000,
+    pagination: false,
+    overrideAccess: false,
+    select: { [slugField]: true },
+    locale
+  });
+  return result.docs ?? [];
+});
+var queryAllLocaleSlugs = cache(async function queryAllLocaleSlugs2({
+  collectionSlug,
+  slug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft: false,
+    limit: 1,
+    pagination: false,
+    overrideAccess: false,
+    locale,
+    where: { [slugField]: { equals: slug } },
+    select: { [slugField]: true }
+  });
+  const doc = result.docs?.[0];
+  if (!doc)
+    return;
+  const fieldValue = doc?.[slugField];
+  if (fieldValue && typeof fieldValue === "object") {
+    return fieldValue;
+  }
+  const resolved = await config;
+  const rawLocales = Array.isArray(resolved?.localization?.localeCodes) ? resolved.localization.localeCodes : resolved?.localization?.locales?.map((l) => l.code) ?? [];
+  const out = {};
+  for (const l of rawLocales)
+    out[l] = String(fieldValue ?? slug);
+  return out;
+});
+var queryGlobal = cache(async function queryGlobal2({
+  globalSlug,
+  locale,
+  depth = 0,
+  draft = false,
+  config
+}) {
+  const payload = await getPayload({ config });
+  try {
+    const global = await payload.findGlobal({
+      slug: globalSlug,
+      depth,
+      draft,
+      locale
+    });
+    return global;
+  } catch {
+    return null;
+  }
+});
+function getRenderModuleExports(exportName, collection, importMap) {
+  const path = collection?.custom?.path;
+  if (!path)
+    return;
+  const mod = getFromImportMap(path, importMap);
+  return mod?.[exportName];
+}
+
+// src/render/sitemap/createSitemapFile.ts
+function createSitemapFile(options) {
+  const { collections } = options;
+  return async function sitemap() {
+    const cfg = await options.config;
+    const allLocales2 = Array.isArray(cfg.localization?.locales) ? cfg.localization.locales.map((l) => typeof l === "string" ? l : l.code) : [cfg.localization?.defaultLocale ?? "en"];
+    const defaultLocale = cfg.localization?.defaultLocale ?? allLocales2[0];
+    const activeLocales = Array.isArray(options.locales) && options.locales.length > 0 ? options.locales.filter((l) => allLocales2.includes(l)) : allLocales2;
+    const entries = [];
+    const seen = new Set;
+    for (const collectionSlug of collections) {
+      const collectionDefaults = options.perCollection?.[collectionSlug] ?? {};
+      const urlPrefix = (options.urlPrefixes?.[collectionSlug] ?? "").replace(/\/$/, "");
+      const siteUrl = options.getServerSideURL().replace(/\/$/, "");
+      for (const locale of activeLocales) {
+        const docs = await queryAllDocs({
+          collectionSlug,
+          slugField: "slug",
+          locale,
+          config: options.config
+        });
+        for (const doc of docs) {
+          const storedSlug = doc.slug;
+          if (typeof storedSlug !== "string" || storedSlug === "")
+            continue;
+          const dedupeKey = `${collectionSlug}:${locale}:${storedSlug}`;
+          if (seen.has(dedupeKey))
+            continue;
+          seen.add(dedupeKey);
+          const url = `${siteUrl}${prefixFor(locale, defaultLocale, options.localePrefix ?? "always")}${urlPrefix}/${storedSlug}`;
+          const languages = await buildHreflangAlternates({
+            siteUrl,
+            locale,
+            urlPrefix,
+            storedSlug,
+            nested: false,
+            homeSlug: "",
+            defaultLocale,
+            locales: activeLocales,
+            localePrefix: options.localePrefix,
+            queryAllLocaleSlugs: async (s, l) => {
+              const result = await queryAllLocaleSlugs({
+                collectionSlug,
+                slug: s,
+                slugField: "slug",
+                locale: l,
+                config: options.config
+              });
+              return result ?? undefined;
+            }
+          });
+          entries.push({
+            url,
+            lastModified: doc.updatedAt ? new Date(doc.updatedAt) : undefined,
+            changeFrequency: collectionDefaults.changefreq ?? "weekly",
+            priority: collectionDefaults.priority ?? 0.5,
+            alternates: { languages }
+          });
+        }
+      }
+    }
+    return entries;
+  };
+}
+// src/config/createWWWConfig.ts
+function createWWWConfig(options) {
+  const { locales, routing, blocks, linkRelationTo, registerPosts = true, defaultPlugins } = options;
+  const defaultLocale = routing?.defaultLocale ?? locales[0] ?? "";
+  const localePrefixMode = (() => {
+    const raw = routing?.localePrefix;
+    if (typeof raw === "string")
+      return raw;
+    return raw?.mode ?? "always";
+  })();
+  if (locales.length === 0) {
+    throw new Error("createWWWConfig: `locales` must contain at least one entry.");
+  }
+  const buildPagesCollection = () => createPagesCollection(blocks, {
+    localePrefix: localePrefixMode,
+    defaultLocale
+  });
+  const buildPostsCollection = () => createPostsCollection({
+    localePrefix: localePrefixMode,
+    defaultLocale
+  });
+  const buildStaticPagesCollection = () => createStaticPagesCollection(blocks);
+  const buildHeaderGlobal = () => createHeaderGlobal({ linkRelationTo });
+  const buildFooterGlobal = () => createFooterGlobal({ linkRelationTo });
+  async function withWWWConfig(config) {
+    const baseDefaults = [
+      buildPagesCollection(),
+      buildStaticPagesCollection()
+    ];
+    if (registerPosts)
+      baseDefaults.push(buildPostsCollection());
+    const defaultCollections = baseDefaults;
+    const collections = typeof config.collections === "function" ? config.collections({ defaultCollections }) : [...defaultCollections, ...config.collections || []];
+    const defaultGlobals = [buildHeaderGlobal(), buildFooterGlobal()];
+    const globals = typeof config.globals === "function" ? config.globals({ defaultGlobals }) : [...defaultGlobals, ...config.globals || []];
+    const renderDependencies = {
+      [PAGES_RENDER_PATH]: { path: PAGES_RENDER_PATH, type: "component" },
+      [POSTS_RENDER_PATH]: { path: POSTS_RENDER_PATH, type: "component" },
+      [HEADER_RENDER_PATH]: { path: HEADER_RENDER_PATH, type: "component" },
+      [FOOTER_RENDER_PATH]: { path: FOOTER_RENDER_PATH, type: "component" },
+      [LIVE_PREVIEW_LISTENER_PATH]: {
+        path: LIVE_PREVIEW_LISTENER_PATH,
+        type: "component"
+      }
+    };
+    for (const { slug, admin } of blocks) {
+      const path = admin?.custom?.path;
+      if (typeof path === "string" && slug)
+        renderDependencies[slug] = { path, type: "component" };
+    }
+    for (const entry of [...collections, ...globals]) {
+      const path = entry.custom?.path;
+      if (typeof path === "string")
+        renderDependencies[path] = { path, type: "component" };
+    }
+    const [
+      { seoPlugin },
+      { imageHashPlugin },
+      { translator }
+    ] = await Promise.all([
+      import("@justanarthur/payload-plugin-seo"),
+      import("@justanarthur/payload-imagehash-plugin"),
+      import("@justanarthur/payload-plugin-translator")
+    ]);
+    const defaultPluginList = [
+      seoPlugin({
+        collections: ["pages", "posts", "static-pages"],
+        autoGenerate: { mode: "onCreate", deriveFrom: "allScalars" }
+      }),
+      imageHashPlugin({ algorithm: "lqip-modern" }),
+      translator({
+        collections: ["pages", "posts", "static-pages"],
+        globals: ["header", "footer"],
+        resolvers: [
+          openAIResolver({
+            apiKey: process.env.OPENAI_API_KEY,
+            chunkLength: 31,
+            model: "gpt-5-mini"
+          })
+        ]
+      })
+    ];
+    const mergedPlugins = defaultPlugins ? defaultPlugins(defaultPluginList) : defaultPluginList;
+    return {
+      ...config,
+      collections,
+      globals,
+      plugins: mergedPlugins,
+      admin: {
+        ...config.admin ?? {},
+        dependencies: {
+          ...renderDependencies,
+          ...config.admin?.dependencies ?? {}
+        }
+      }
+    };
+  }
+  return { withWWWConfig };
+}
+
+// src/core/fields/linkGroup.ts
+var linkGroup = (options = {}) => ({
+  name: "links",
+  type: "array",
+  fields: [link(options)],
+  admin: { initCollapsed: true }
+});
+
+// src/core/utils/generateImportName.ts
+function generateImportName(type, slug) {
+  switch (type) {
+    case "block":
+      return `Block${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
+    case "page":
+      return `Page${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+
+// src/render/utils/renderCollectionModule.tsx
+import { jsx } from "react/jsx-runtime";
+function renderCollectionModule(collection = [], slug, importMap, props) {
+  const renderPath = collection?.find((c) => c.slug === slug)?.custom?.path;
+  if (!renderPath)
+    return null;
+  const CollectionRenderModule = getFromImportMap(renderPath, importMap);
+  if (!CollectionRenderModule) {
+    if (false) {}
+    return null;
+  }
+  return /* @__PURE__ */ jsx(CollectionRenderModule, {
+    importMap,
+    ...props
+  });
+}
+
+// src/render/utils/renderGlobalModule.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function renderGlobalModule(globals = [], slug, importMap, props) {
+  const renderPath = globals?.find((g) => g.slug === slug)?.custom?.path;
+  if (!renderPath)
+    return null;
+  const GlobalRenderModule = getFromImportMap(renderPath, importMap);
+  if (!GlobalRenderModule) {
+    if (false) {}
+    return null;
+  }
+  return /* @__PURE__ */ jsx2(GlobalRenderModule, {
+    importMap,
+    ...props
+  });
+}
+
+// src/render/utils/getCachedGlobal.ts
+import { unstable_cache } from "next/cache";
+var getCachedGlobal = (config, slug, depth = 0) => unstable_cache(async () => queryGlobal({
+  globalSlug: slug,
+  locale: "__ALL__",
+  depth,
+  config
+}), [slug], { tags: [`global_${slug}`] });
+
+// src/render/metadata/jsonld.ts
+function getImageUrl(doc, siteUrl) {
+  const img = doc?.meta?.image ?? doc?.heroImage ?? doc?.image;
+  if (!img)
+    return null;
+  if (typeof img === "string")
+    return img;
+  if (img?.url)
+    return img.url.startsWith("http") ? img.url : `${siteUrl}${img.url}`;
+  return null;
+}
+function resolveLocalizedField(value, locale) {
+  if (value == null)
+    return "";
+  if (typeof value === "string") {
+    if (!value.startsWith("{"))
+      return value;
+    try {
+      const parsed = JSON.parse(value);
+      return resolveLocalizedField(parsed, locale);
+    } catch {
+      return value;
+    }
+  }
+  if (typeof value !== "object")
+    return "";
+  const obj = value;
+  if (typeof obj[locale] === "string" && obj[locale].length > 0) {
+    return obj[locale];
+  }
+  return Object.values(obj).filter((v) => typeof v === "string" && v.length > 0).join(" / ");
+}
+function buildArticleLd({
+  doc,
+  url,
+  locale,
+  siteUrl,
+  type = "BlogPosting",
+  publisherName,
+  publisherLogo
+}) {
+  const name = publisherName ?? new URL(siteUrl).hostname;
+  const ld = {
+    "@context": "https://schema.org",
+    "@type": type,
+    "@id": `${url}#article`,
+    headline: resolveLocalizedField(doc.title, locale),
+    description: resolveLocalizedField(doc.meta?.description ?? doc.description ?? doc.excerpt, locale),
+    inLanguage: locale,
+    url,
+    dateModified: doc.updatedAt ? new Date(doc.updatedAt).toISOString() : undefined
+  };
+  const datePublished = doc.publishedAt ?? doc.createdAt;
+  if (datePublished)
+    ld.datePublished = new Date(datePublished).toISOString();
+  const imgUrl = getImageUrl(doc, siteUrl);
+  if (imgUrl)
+    ld.image = imgUrl;
+  ld.author = { "@type": "Organization", name, url: siteUrl };
+  const publisher = { "@type": "Organization", name };
+  if (publisherLogo !== undefined) {
+    if (publisherLogo !== null)
+      publisher.logo = { "@type": "ImageObject", url: publisherLogo };
+  }
+  ld.publisher = publisher;
+  return ld;
+}
+function buildBreadcrumbsLd({
+  items,
+  currentUrl
+}) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.label,
+      item: index === items.length - 1 ? currentUrl : item.url
+    }))
+  };
+}
+function buildOrganizationLd({
+  siteUrl,
+  name,
+  logo,
+  sameAs
+}) {
+  const org = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    "@id": `${siteUrl}#organization`,
+    url: siteUrl,
+    ...name && { name },
+    ...logo && { logo: { "@type": "ImageObject", url: logo } },
+    ...sameAs && sameAs.length > 0 && { sameAs }
+  };
+  return org;
+}
+
+// src/render/metadata/slug.ts
+var SLUG_NESTED_DIVIDER = "_";
+function segmentsToStoredSlug(segments, nested) {
+  if (!Array.isArray(segments))
+    return segments;
+  if (nested)
+    return segments.join(SLUG_NESTED_DIVIDER);
+  return segments[0] ?? "";
+}
+function segmentsToUrlPath(segments, nested) {
+  if (!Array.isArray(segments))
+    return "/" + segments;
+  if (nested)
+    return "/" + segments.join("/");
+  return "/" + (segments[0] ?? "");
+}
+function storedSlugToSegments(storedSlug, nested) {
+  if (nested)
+    return storedSlug.split(SLUG_NESTED_DIVIDER);
+  return storedSlug;
+}
+function buildCanonicalUrl({
+  siteUrl,
+  locale,
+  urlPrefix,
+  urlPath
+}) {
+  const trimmedPrefix = urlPrefix.replace(/^\/|\/$/g, "");
+  const prefixSegment = trimmedPrefix ? `/${trimmedPrefix}` : "";
+  return `${siteUrl}/${locale}${prefixSegment}${urlPath}`;
+}
+function getUrlPath(segments, nested, homeSlug) {
+  const urlPath = segmentsToUrlPath(segments, nested);
+  if (nested && !Array.isArray(segments)) {
+    if (segments === homeSlug)
+      return "/";
+  } else if (nested && Array.isArray(segments)) {
+    const stored = segments.join(SLUG_NESTED_DIVIDER);
+    if (stored === homeSlug)
+      return "/";
+  }
+  return urlPath;
+}
+
+// src/render/blocks/renderBlocks.tsx
+import { jsx as jsx3, Fragment } from "react/jsx-runtime";
+var RenderBlocks = ({
+  blocks,
+  blockProps,
+  config,
+  importMap,
+  locale,
+  searchParams
+}) => {
+  if (!blocks || !Array.isArray(blocks) || blocks.length === 0)
+    return null;
+  const rendered = [];
+  for (let i = 0;i < blocks.length; i++) {
+    const block = blocks[i];
+    const { blockType } = block;
+    const importMapPath = config.admin?.dependencies?.[blockType]?.path ?? generateImportName("block", blockType);
+    const Block = getFromImportMap(importMapPath, importMap);
+    if (!Block) {
+      console.warn(`No block found for type: ${blockType}, config.admin?.dependencies?.[blockType]: ${config.admin?.dependencies?.[blockType]}`);
+      continue;
+    }
+    rendered.push(/* @__PURE__ */ jsx3(Block, {
+      index: i,
+      ...blockProps,
+      ...block,
+      locale,
+      searchParams
+    }, i));
+  }
+  return /* @__PURE__ */ jsx3(Fragment, {
+    children: rendered
+  });
+};
+
+// src/data/seed/createBaseSeed.ts
+var simpleRichText = (text) => ({
+  root: {
+    type: "root",
+    format: "",
+    indent: 0,
+    version: 1,
+    direction: "ltr",
+    children: [
+      {
+        type: "paragraph",
+        format: "",
+        indent: 0,
+        version: 1,
+        direction: "ltr",
+        textFormat: 0,
+        children: [
+          { mode: "normal", text, type: "text", style: "", detail: 0, format: 0, version: 1 }
+        ]
+      }
+    ]
+  }
+});
+async function createBaseSeed(payload, options = {}) {
+  const localization = payload.config.localization;
+  const defaultLocale = options.defaultLocale ?? (typeof localization === "object" && localization ? typeof localization.defaultLocale === "string" ? localization.defaultLocale : "en" : "en");
+  const configLocales = typeof localization === "object" && localization ? (localization.locales ?? []).map((l) => typeof l === "string" ? l : l.code) : [];
+  const locales = options.locales ?? (configLocales.length > 0 ? configLocales : [defaultLocale]);
+  const result = { users: [], categories: [], pages: [], posts: [] };
+  const pagesCollection = payload.collections["pages"];
+  if (!pagesCollection) {
+    throw new Error("createBaseSeed: no `pages` collection registered with this payload instance");
+  }
+  const findBlocksField = (fields) => {
+    for (const f of fields) {
+      if (f.name === "blocks" && Array.isArray(f.blocks))
+        return f;
+      if (Array.isArray(f.fields)) {
+        const found = findBlocksField(f.fields);
+        if (found)
+          return found;
+      }
+      if (Array.isArray(f.tabs)) {
+        for (const t of f.tabs) {
+          if (Array.isArray(t.fields)) {
+            const found = findBlocksField(t.fields);
+            if (found)
+              return found;
+          }
+        }
+      }
+    }
+    return;
+  };
+  const layoutField = findBlocksField(pagesCollection.config.fields);
+  const validBlockSlugs = new Set((layoutField?.blocks ?? []).map((b) => b.slug));
+  for (const page of options.pages ?? []) {
+    for (const block of page.blocks ?? []) {
+      const slug = block.blockType;
+      if (!slug) {
+        throw new Error(`createBaseSeed: page "${page.slug}" has a block without blockType`);
+      }
+      if (!validBlockSlugs.has(slug)) {
+        throw new Error(`createBaseSeed: page "${page.slug}" references unknown block slug "${slug}". Allowed: ${[...validBlockSlugs].join(", ")}`);
+      }
+    }
+  }
+  if (options.dryRun)
+    return result;
+  for (const user of options.users ?? [{ email: "dev@payloadcms.com", password: "test", name: "Dev User" }]) {
+    const existing = await payload.find({
+      collection: "users",
+      where: { email: { equals: user.email } },
+      limit: 1,
+      overrideAccess: true
+    });
+    let id;
+    if (existing.docs.length > 0) {
+      id = existing.docs[0].id;
+    } else {
+      const created = await payload.create({
+        collection: "users",
+        data: { email: user.email, password: user.password ?? "test", name: user.name ?? "" },
+        overrideAccess: true
+      });
+      id = created.id;
+    }
+    result.users.push({ id, email: user.email });
+  }
+  for (const cat of options.categories ?? []) {
+    const slug = cat.slug ?? cat.title.toLowerCase().replace(/\s+/g, "-");
+    const existing = await payload.find({
+      collection: "categories",
+      where: { title: { equals: cat.title } },
+      limit: 1,
+      overrideAccess: true
+    });
+    let id;
+    if (existing.docs.length > 0) {
+      id = existing.docs[0].id;
+    } else {
+      const created = await payload.create({
+        collection: "categories",
+        data: { title: cat.title, slug },
+        overrideAccess: true
+      });
+      id = created.id;
+    }
+    result.categories.push({ id, title: cat.title, slug });
+  }
+  for (const page of options.pages ?? []) {
+    const existing = await payload.find({
+      collection: "pages",
+      where: { slug: { equals: page.slug } },
+      limit: 1,
+      overrideAccess: true
+    });
+    const data = {
+      slug: page.slug,
+      title: { ...page.title },
+      blocks: page.blocks ?? [],
+      publishedAt: page.publishedAt ?? new Date().toISOString(),
+      _status: page.status === "draft" ? "draft" : "published"
+    };
+    if (page.meta)
+      data.meta = { ...page.meta };
+    let id;
+    if (existing.docs.length === 0) {
+      const created = await payload.create({
+        collection: "pages",
+        data,
+        overrideAccess: true,
+        draft: page.status === "draft"
+      });
+      id = created.id;
+    } else {
+      id = existing.docs[0].id;
+      await payload.update({
+        collection: "pages",
+        id,
+        data,
+        overrideAccess: true,
+        draft: page.status === "draft"
+      });
+    }
+    for (const locale of locales)
+      result.pages.push({ id, slug: page.slug, locale });
+  }
+  for (const post of options.posts ?? []) {
+    const existing = await payload.find({
+      collection: "posts",
+      where: { slug: { equals: post.slug } },
+      limit: 1,
+      overrideAccess: true
+    });
+    const data = {
+      slug: post.slug,
+      title: { ...post.title },
+      ...post.excerpt ? { excerpt: { ...post.excerpt } } : {},
+      content: post.content ?? simpleRichText("Hello world"),
+      publishedAt: post.publishedAt ?? new Date().toISOString(),
+      authors: result.users.length > 0 ? [result.users[0].id] : [],
+      _status: post.status === "draft" ? "draft" : "published"
+    };
+    let id;
+    if (existing.docs.length === 0) {
+      const created = await payload.create({
+        collection: "posts",
+        data,
+        overrideAccess: true,
+        draft: post.status === "draft"
+      });
+      id = created.id;
+    } else {
+      id = existing.docs[0].id;
+      await payload.update({
+        collection: "posts",
+        id,
+        data,
+        overrideAccess: true,
+        draft: post.status === "draft"
+      });
+    }
+    for (const locale of locales)
+      result.posts.push({ id, slug: post.slug, locale });
+  }
+  return result;
+}
+
+// src/data/test/createTestPayload.ts
+import { sqliteAdapter } from "@payloadcms/db-sqlite";
+import { flattenAllFields, getPayload as getPayload2, inMemoryKVAdapter } from "payload";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+async function createTestPayload(options = {}) {
+  const filename = fileURLToPath(import.meta.url);
+  const dirname = path.dirname(filename);
+  const databaseFile = options.databaseFile ?? path.join(dirname, `.test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+  const locales = options.locales ?? ["en", "uk"];
+  const defaultLocale = locales[0] ?? "en";
+  const blocks = options.blocks ?? [];
+  const { withWWWConfig } = createWWWConfig({ locales: [...locales], blocks });
+  const config = await withWWWConfig({
+    admin: { user: "users" },
+    blocks: [],
+    collections: [
+      {
+        slug: "posts",
+        access: { read: () => true },
+        fields: [{ name: "title", type: "text" }]
+      }
+    ],
+    globals: [],
+    db: sqliteAdapter({
+      client: { url: `file:${databaseFile}` },
+      push: false
+    }),
+    secret: "test-secret-do-not-use-in-prod",
+    sharp: (await import("sharp")).default,
+    editor: {},
+    localization: { locales: [...locales], defaultLocale },
+    kv: inMemoryKVAdapter(),
+    typescript: { outputFile: "./payload-types.ts" }
+  });
+  const registered = new Set([
+    ...(config.collections ?? []).map((c) => c.slug),
+    ...(config.globals ?? []).map((g) => g.slug)
+  ]);
+  const findMissing = (fields) => {
+    const out = [];
+    const walk = (f) => {
+      if (Array.isArray(f)) {
+        for (const child of f)
+          walk(child);
+        return;
+      }
+      if (f.relationTo) {
+        const rels = Array.isArray(f.relationTo) ? f.relationTo : [f.relationTo];
+        for (const r of rels) {
+          if (typeof r === "string" && !registered.has(r))
+            out.push(r);
+        }
+      }
+      if (Array.isArray(f.fields))
+        walk(f.fields);
+    };
+    for (const f of fields)
+      walk(f);
+    return out;
+  };
+  for (const c of config.collections ?? []) {
+    const missing = findMissing(c.fields ?? []);
+    if (missing.length)
+      console.log("collection", c.slug, "missing relations:", missing);
+  }
+  for (const g of config.globals ?? []) {
+    const missing = findMissing(g.fields ?? []);
+    if (missing.length)
+      console.log("global", g.slug, "missing relations:", missing);
+  }
+  for (const c of config.collections ?? []) {
+    if (c.fields) {
+      c.flattenedFields = flattenAllFields({ fields: c.fields });
+    }
+    if (c.upload === undefined)
+      c.upload = false;
+    c.sanitizedIndexes = c.sanitizedIndexes ?? [];
+    c.polymorphicJoins = c.polymorphicJoins ?? [];
+    if (options.overridePagesVersions && c.slug === "pages") {
+      c.versions = false;
+    }
+  }
+  for (const g of config.globals ?? []) {
+    if (g.fields) {
+      g.flattenedFields = flattenAllFields({ fields: g.fields });
+    }
+    g.sanitizedIndexes = g.sanitizedIndexes ?? [];
+  }
+  const payload = await getPayload2({ config });
+  let destroyed = false;
+  const destroy = async () => {
+    if (destroyed)
+      return;
+    destroyed = true;
+    try {
+      await payload.destroy();
+    } catch {}
+  };
+  return { payload, databaseFile, destroy };
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import"server-only";
+import { Suspense } from "react";
+import { RichText } from "@payloadcms/richtext-lexical/react";
+
+// src/render/pages/PagesPage.tsx
+import { jsx as jsx4, Fragment as Fragment2 } from "react/jsx-runtime";
+async function PagesPage({ doc, ...props }) {
+  if (!doc)
+    return /* @__PURE__ */ jsx4(Fragment2, {});
+  const blocks = doc.blocks ?? [];
+  return /* @__PURE__ */ jsx4(Fragment2, {
+    children: /* @__PURE__ */ jsx4(RenderBlocks, {
+      blocks,
+      ...props
+    })
+  });
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import { jsx as jsx7, jsxs as jsxs3, Fragment as Fragment4 } from "react/jsx-runtime";
+var HOME_SLUG = "";
+function createCollectionPageExports({
+  slug = "pages",
+  config: configPromise,
+  routing,
+  importMap: importMapArg,
+  renderPath
+}, deps, options = {}) {
+  const importMap = importMapArg ?? {};
+  const { jsonLd: jsonLdOption = true, changefreq = "weekly", priority = 0.5, websiteName } = options;
+  const {
+    getServerSideURL,
+    generateMeta,
+    metadataType: metadataTypeOverride,
+    showcase: showcaseOption,
+    homeExtras
+  } = deps;
+  const showcaseEnabled = showcaseOption?.enabled === true;
+  const { metadataHeading, jsonLdHeading } = showcaseOption ?? {};
+  const locales = routing.locales;
+  const defaultLocale = routing.defaultLocale;
+  const metadataType = metadataTypeOverride ?? (slug === POSTS_SLUG ? "article" : "website");
+  const defaultRenderPath = slug === POSTS_SLUG ? POSTS_RENDER_PATH : PAGES_RENDER_PATH;
+  const localePrefixMode = typeof routing.localePrefix === "string" ? routing.localePrefix : routing.localePrefix?.mode ?? "always";
+  const buildLocalePath = (locale, storedSlug) => {
+    const urlPath = getUrlPath(storedSlug, false, HOME_SLUG);
+    if (localePrefixMode === "never")
+      return urlPath;
+    if (localePrefixMode === "as-needed" && locale === defaultLocale)
+      return urlPath;
+    return `/${locale}${urlPath}`;
+  };
+  async function fetchDoc(locale, storedSlug, draft = false) {
+    return queryDocBySlug({
+      collectionSlug: slug,
+      slug: storedSlug,
+      locale,
+      draft,
+      config: configPromise
+    });
+  }
+  async function resolveHreflangAlternates(locale, storedSlug) {
+    const siteUrl = getServerSideURL();
+    const urlPath = buildLocalePath(locale, storedSlug);
+    const canonical = `${siteUrl}${urlPath}`;
+    const languages = await buildHreflangAlternates({
+      siteUrl,
+      locale,
+      urlPrefix: "",
+      storedSlug,
+      nested: false,
+      homeSlug: HOME_SLUG,
+      defaultLocale,
+      locales,
+      localePrefix: localePrefixMode,
+      queryAllLocaleSlugs: (s, l) => queryAllLocaleSlugs({ collectionSlug: slug, slug: s, slugField: "slug", locale: l, config: configPromise })
+    });
+    const alternates = {};
+    for (const [key, url] of Object.entries(languages)) {
+      alternates[key] = url;
+    }
+    return { alternates, canonical };
+  }
+  const default_ = async (props) => {
+    const { slug: rawSlugSegments, locale: incomingLocale } = await props.params ?? {};
+    const slugSegments = Array.isArray(rawSlugSegments) ? rawSlugSegments : [];
+    const locale = typeof incomingLocale === "string" ? incomingLocale : defaultLocale;
+    if (!locales.includes(locale)) {
+      const { notFound } = await import("next/navigation");
+      notFound();
+    }
+    const { setRequestLocale } = await import("next-intl/server");
+    setRequestLocale(locale);
+    const { draftMode } = await import("next/headers");
+    const { isEnabled: draft } = await draftMode();
+    const storedSlug = segmentsToStoredSlug(slugSegments, false);
+    const doc = await fetchDoc(locale, storedSlug, draft);
+    if (!doc) {
+      const { notFound } = await import("next/navigation");
+      notFound();
+    }
+    const cfg = await configPromise;
+    const collectionCustomPath = cfg.collections.find((c) => c.slug === slug)?.custom?.path;
+    const effectivePath = renderPath ?? collectionCustomPath ?? defaultRenderPath;
+    const render = effectivePath === PAGES_RENDER_PATH ? /* @__PURE__ */ jsx7(PagesPage, {
+      doc,
+      importMap,
+      config: cfg,
+      locale
+    }) : effectivePath === POSTS_RENDER_PATH ? doc ? await renderPostBody(doc, locale) : null : renderCollectionModule(cfg.collections, slug, importMap, {
+      ...props,
+      config: cfg,
+      locale,
+      searchParams: props.searchParams,
+      doc
+    });
+    const jsonLdNodes = doc ? await generateJsonLd(slugSegments, doc, locale) : [];
+    const { alternates: hreflangAlternates, canonical } = await resolveHreflangAlternates(locale, storedSlug);
+    console.log("render", { render, doc });
+    const inner = /* @__PURE__ */ jsxs3(Fragment4, {
+      children: [
+        jsonLdNodes.map(({ id, schema }) => /* @__PURE__ */ jsx7("script", {
+          type: "application/ld+json",
+          dangerouslySetInnerHTML: { __html: JSON.stringify(schema) }
+        }, id)),
+        render,
+        draft ? (() => {
+          const ResolvedListener = importMap?.[LIVE_PREVIEW_LISTENER_PATH];
+          if (!ResolvedListener)
+            return null;
+          return /* @__PURE__ */ jsx7(Suspense, {
+            fallback: null,
+            children: /* @__PURE__ */ jsx7(ResolvedListener, {})
+          });
+        })() : null,
+        storedSlug === HOME_SLUG && homeExtras ? await homeExtras({ locale, doc }) : null
+      ]
+    });
+    if (!showcaseEnabled || !doc)
+      return inner;
+    const { PageShowcase: PageShowcase2 } = await Promise.resolve().then(() => (init_PageShowcase(), exports_PageShowcase));
+    const { LocaleSwitcher: LocaleSwitcher2 } = await Promise.resolve().then(() => (init_LocaleSwitcher(), exports_LocaleSwitcher));
+    const meta = await generateMeta({
+      doc,
+      url: canonical,
+      type: metadataType,
+      locale
+    });
+    return /* @__PURE__ */ jsx7(PageShowcase2, {
+      metadata: meta,
+      metadataHeading,
+      jsonLdHeading,
+      jsonLd: jsonLdNodes,
+      localeSwitcher: /* @__PURE__ */ jsx7(LocaleSwitcher2, {
+        currentLocale: locale,
+        hreflangAlternates,
+        labels: routing.labels
+      }),
+      children: inner
+    });
+  };
+  async function generateMetadata(props) {
+    const cfg = await configPromise;
+    const { slug: rawSlugSegments, locale: incomingLocale } = await props.params ?? {};
+    const slugSegments = Array.isArray(rawSlugSegments) ? rawSlugSegments : [];
+    const locale = typeof incomingLocale === "string" ? incomingLocale : defaultLocale;
+    if (!locales.includes(locale))
+      return { title: "Not found", robots: { index: false, follow: false } };
+    const storedSlug = segmentsToStoredSlug(slugSegments, false);
+    const doc = await fetchDoc(locale, storedSlug);
+    if (!doc)
+      return { title: "Not found", robots: { index: false, follow: false } };
+    const collection = cfg.collections.find((c) => c.slug === slug);
+    if (!collection)
+      return {};
+    const { canonical, alternates } = await resolveHreflangAlternates(locale, storedSlug);
+    const meta = await generateMeta({
+      doc,
+      url: canonical,
+      type: metadataType,
+      locale
+    });
+    meta.alternates = {
+      canonical,
+      languages: Object.keys(alternates).length ? alternates : undefined
+    };
+    return meta;
+  }
+  async function generateJsonLd(slugSegments, doc, locale) {
+    if (jsonLdOption === false || !doc)
+      return [];
+    const siteUrl = getServerSideURL();
+    const storedSlug = segmentsToStoredSlug(slugSegments, false);
+    const urlPath = buildLocalePath(locale, storedSlug);
+    const canonical = `${siteUrl}${urlPath}`;
+    const entries = Array.isArray(jsonLdOption) ? jsonLdOption : metadataType === "article" ? [{ type: "article" }] : [{ type: "website" }];
+    const outputs = [];
+    for (const entry of entries) {
+      const id = entry.id ?? `jsonld-${entry.type}-${outputs.length}`;
+      let schema = null;
+      switch (entry.type) {
+        case "article": {
+          const articleOpts = {
+            doc,
+            url: canonical,
+            locale,
+            siteUrl,
+            type: entry.schemaType ?? "BlogPosting"
+          };
+          if (entry.publisherName !== undefined)
+            articleOpts.publisherName = entry.publisherName;
+          if (entry.publisherLogo !== undefined)
+            articleOpts.publisherLogo = entry.publisherLogo;
+          schema = buildArticleLd(articleOpts);
+          break;
+        }
+        case "website": {
+          schema = {
+            "@context": "https://schema.org",
+            "@type": "WebSite",
+            "@id": `${siteUrl}#website`,
+            url: siteUrl,
+            name: entry.name ?? websiteName ?? new URL(siteUrl).hostname,
+            ...entry.alternateName ? { alternateName: entry.alternateName } : {},
+            inLanguage: locale
+          };
+          break;
+        }
+        case "organization": {
+          schema = buildOrganizationLd({
+            siteUrl,
+            name: entry.name,
+            logo: entry.logo,
+            sameAs: entry.sameAs
+          });
+          break;
+        }
+        case "breadcrumbs": {
+          let items = entry.items ?? [];
+          if (!items.length && entry.buildItems)
+            items = entry.buildItems(doc, canonical);
+          if (items.length > 0)
+            schema = buildBreadcrumbsLd({ items, currentUrl: canonical });
+          break;
+        }
+        case "custom": {
+          schema = entry.build({ doc, url: canonical, locale, siteUrl });
+          break;
+        }
+      }
+      if (schema)
+        outputs.push({ id, schema });
+    }
+    return outputs;
+  }
+  async function generateStaticParams() {
+    const params = [];
+    for (const locale of locales) {
+      const docs = await queryAllDocs({ collectionSlug: slug, slugField: "slug", locale, config: configPromise });
+      for (const doc of docs) {
+        const slugVal = doc.slug;
+        if (typeof slugVal !== "string" || slugVal === "")
+          continue;
+        const segments = storedSlugToSegments(slugVal, false);
+        params.push({ slug: Array.isArray(segments) ? segments : [segments], locale });
+      }
+    }
+    return params;
+  }
+  async function generateSitemap() {
+    const docs = await queryAllDocs({
+      collectionSlug: slug,
+      slugField: "slug",
+      locale: defaultLocale,
+      config: configPromise
+    });
+    const siteUrl = getServerSideURL().replace(/\/$/, "");
+    const urls = [];
+    for (const doc of docs) {
+      const slugVal = doc.slug;
+      if (typeof slugVal !== "string" || slugVal === "")
+        continue;
+      for (const locale of locales) {
+        const urlPath = buildLocalePath(locale, slugVal);
+        const updatedAt = doc.updatedAt;
+        const lastmod = typeof updatedAt === "string" ? new Date(updatedAt).toISOString() : undefined;
+        urls.push({ url: `${siteUrl}${urlPath}`, lastModified: lastmod, changeFrequency: changefreq, priority });
+      }
+    }
+    return urls;
+  }
+  return {
+    default: default_,
+    generateMetadata,
+    generateStaticParams,
+    generateSitemap,
+    generateJsonLd
+  };
+}
+function addCollectionsToSitemap(exports) {
+  async function buildSitemap() {
+    const all = await Promise.all(exports.map((e) => e.generateSitemap()));
+    return all.flat();
+  }
+  return { default: buildSitemap, generateSitemap: buildSitemap };
+}
+async function renderPostBody(doc, locale) {
+  const typedDoc = doc;
+  const title = typedDoc.title ?? "";
+  const excerpt = typedDoc.excerpt ?? null;
+  const content = typedDoc.content;
+  return /* @__PURE__ */ jsxs3("article", {
+    className: "posts-page prose prose-neutral dark:prose-invert mx-auto max-w-3xl py-10",
+    children: [
+      /* @__PURE__ */ jsxs3("header", {
+        className: "posts-page__header not-prose mb-8",
+        children: [
+          /* @__PURE__ */ jsx7("h1", {
+            className: "posts-page__title text-4xl font-semibold tracking-tight",
+            children: title
+          }),
+          excerpt ? /* @__PURE__ */ jsx7("p", {
+            className: "posts-page__excerpt mt-3 text-lg text-muted-foreground",
+            children: excerpt
+          }) : null
+        ]
+      }),
+      content ? /* @__PURE__ */ jsx7("div", {
+        className: "posts-page__content",
+        children: /* @__PURE__ */ jsx7(RichText, {
+          data: content
+        })
+      }) : null
+    ]
+  });
+}
+
+// src/render/pages/createStaticPageExports.tsx
+import"server-only";
+import { jsx as jsx8 } from "react/jsx-runtime";
+function createStaticPageExports({
+  kind = "not-found",
+  config: configPromise,
+  importMap: importMapArg
+}) {
+  const importMap = importMapArg ?? {};
+  const default_ = async () => {
+    const { getLocale } = await import("next-intl/server");
+    const locale = await getLocale();
+    const doc = await queryDocBySlug({
+      collectionSlug: STATIC_PAGES_SLUG,
+      slug: kind,
+      slugField: "kind",
+      locale,
+      config: configPromise
+    });
+    if (!doc) {
+      console.warn("[createStaticPageExports] !doc: STATIC_PAGES_SLUG=", STATIC_PAGES_SLUG, "slug:" + kind);
+      return /* @__PURE__ */ jsx8("section", {
+        children: /* @__PURE__ */ jsx8("h1", {
+          children: "404"
+        })
+      });
+    }
+    const cfg = await configPromise;
+    return /* @__PURE__ */ jsx8(PagesPage, {
+      doc,
+      locale,
+      importMap,
+      config: cfg
+    });
+  };
+  return { default: default_ };
+}
+
+// src/data/collections/previewPath.ts
+var collectionPrefixMap = {
+  posts: "/posts",
+  pages: ""
+};
+function generatePreviewPath({
+  collection,
+  slug
+}) {
+  if (slug === undefined || slug === null)
+    return null;
+  const encodedSlug = encodeURIComponent(slug);
+  const params = new URLSearchParams({
+    path: `${collectionPrefixMap[collection] ?? ""}/${encodedSlug}`,
+    previewSecret: process.env.PREVIEW_SECRET || ""
+  });
+  return `/next/preview?${params.toString()}`;
+}
+
+// src/exports/server.ts
+var server_default = createWWWConfig;
+export {
+  storedSlugToSegments,
+  segmentsToUrlPath,
+  segmentsToStoredSlug,
+  renderGlobalModule,
+  renderCollectionModule,
+  queryGlobal,
+  queryDocBySlug,
+  queryAllLocaleSlugs,
+  queryAllDocs,
+  linkGroup,
+  link,
+  getUrlPath,
+  getRenderModuleExports,
+  getFromImportMap,
+  getCachedGlobal,
+  generatePreviewPath,
+  generateImportName,
+  server_default as default,
+  createWWWConfig,
+  createTestPayload,
+  createStaticPagesCollection,
+  createStaticPageExports,
+  createRevalidatePageHooks,
+  createRevalidateGlobalHook,
+  createRevalidateCollectionHook,
+  createPostsCollection,
+  createPagesCollection,
+  createHeaderGlobal,
+  createFooterGlobal,
+  createCollectionPageExports,
+  createBaseSeed,
+  buildOrganizationLd,
+  buildHreflangAlternates,
+  buildCanonicalUrl,
+  buildBreadcrumbsLd,
+  buildArticleLd,
+  authenticatedOrPublished,
+  authenticated,
+  appearanceOptions,
+  anyone,
+  addCollectionsToSitemap,
+  STATIC_PAGES_SLUG,
+  RenderBlocks,
+  POSTS_SLUG2 as POSTS_SLUG,
+  PAGES_SLUG2 as PAGES_SLUG,
+  HOME_PAGE_SLUG
+};