@websolutespa/bom-next 3.0.0

package/dist/exports/server.js

@@ -0,0 +1,1974 @@
+import { t as getRouteLinkCategory } from "../route-DzFwERQP.js";
+import { c as guest, i as buildStrategy, l as buildBreadcrumb } from "../store-CJzqrHsl.js";
+import { o as localApiGet } from "../http-_2M-UFRx.js";
+import { a as sanitizeRedirectTo, c as getLink, i as sanitizeRedirectFrom, o as sanitizeRedirectUrl, r as sanitizeHref, u as getLabelFromLabels } from "../utils-Ca7xh5mm.js";
+import { n as getNextUrl, t as getHrefBeforeRedirect } from "../utils-YwteTbk7.js";
+import { collectRoutes, defaultLocale, defaultMarket, eachMarketLocale, getCategorySegments, getHost, getOrigin, getRootCategory, isDevelopment, isObject, isProduction, qsDeserialize, qsSerialize } from "@websolutespa/bom-core";
+import { cache } from "react";
+import { NextResponse } from "next/server";
+import { InMemoryCache, getRouteSnapshot, getRoutes as getRoutes$1, sortCollection, whereCollection } from "@websolutespa/payload-plugin-bowl";
+import { createPayloadRequest, getPayload as getPayload$1 } from "payload";
+import { draftMode, headers } from "next/headers";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { ResponseNotFound, ResponseSuccess } from "@websolutespa/payload-utils/server";
+//#region src/server/mixer.ts
+const USE_CACHE = true;
+const getRouteCache = () => {
+	let cache = globalThis._route;
+	if (!cache) {
+		cache = new InMemoryCache();
+		globalThis._route = cache;
+	}
+	return cache;
+};
+const getMixerCache = () => {
+	let cache = globalThis._mixer;
+	if (!cache) {
+		cache = new InMemoryCache();
+		globalThis._mixer = cache;
+	}
+	return cache;
+};
+function getCacheKey({ market = "all", locale = "all", user = guest, draft = "false" }) {
+	const roles = user?.roles || ["guest"];
+	const tenants = "tenants" in user && Array.isArray(user.tenants) ? user.tenants.map((x) => isObject(x) ? x.id : x) : [];
+	roles.sort();
+	tenants.sort();
+	return `context-${[
+		market,
+		locale,
+		draft === "false" ? "published" : "draft",
+		...roles,
+		...tenants
+	].join("-")}`;
+}
+async function getContext() {
+	let context = globalThis._context;
+	if (!context) {
+		context = {
+			payload: void 0,
+			context: void 0
+		};
+		globalThis._context = context;
+	}
+	return context;
+}
+async function setContext(data) {
+	const context = await getContext();
+	if (data.payload) context.payload = data.payload;
+	if (data.context) context.context = data.context;
+}
+function getSearchParams(request) {
+	const searchParams = request.nextUrl.searchParams;
+	const params = Object.fromEntries(searchParams.entries());
+	return {
+		market: params.market || defaultMarket,
+		locale: params.locale || defaultLocale,
+		defaultMarket,
+		defaultLocale,
+		params,
+		searchParams: request.nextUrl.searchParams
+	};
+}
+const getPayloadInstance = cache(async (props) => await getPayload$1(props));
+function getOptions({ locale = "all", user = guest, draft = false }) {
+	return {
+		localized: {
+			locale,
+			fallbackLocale: defaultLocale,
+			draft,
+			depth: 0,
+			pagination: false,
+			limit: 1e4,
+			user,
+			overrideAccess: false
+		},
+		unlocalized: {
+			locale: "all",
+			fallbackLocale: defaultLocale,
+			draft,
+			depth: 0,
+			pagination: false,
+			limit: 1e4,
+			user,
+			overrideAccess: false
+		}
+	};
+}
+async function getRoutes({ payload, market = "all", locale = "all", user = guest, draft = false }) {
+	const cacheKey = getCacheKey({
+		market,
+		locale,
+		user,
+		draft: draft ? "true" : "false"
+	});
+	const routeCache = getRouteCache();
+	if (routeCache.has(cacheKey)) {
+		console.log("getRoutes from cache", cacheKey);
+		return routeCache.get(cacheKey);
+	}
+	let routes = [];
+	if (!user) return routes;
+	const { localized, unlocalized } = getOptions({
+		locale,
+		user,
+		draft
+	});
+	const markets = (await payload.find({
+		...localized,
+		collection: "market",
+		where: { isActive: { equals: true } }
+	})).docs;
+	const locales = (await payload.findGlobal({
+		...localized,
+		slug: "locale"
+	})).items.filter((x) => x.isActive);
+	if (locales.length > 0 && markets.length > 0) {
+		const keys = payload.config.collections.filter((x) => {
+			return x.fields.find((x) => "name" in x && x.name === "slug");
+		}).map((x) => x.slug);
+		const pages = Object.fromEntries(keys.map((x) => [x, []]));
+		for (const key of keys) pages[key] = (await payload.find({
+			...unlocalized,
+			collection: key
+		})).docs;
+		const categories = (await payload.find({
+			...unlocalized,
+			collection: "category",
+			depth: 1
+		})).docs;
+		const medias = (await payload.find({
+			...unlocalized,
+			collection: "media",
+			depth: 1
+		})).docs;
+		routes = collectRoutes(pages, categories, markets, locales, medias);
+	}
+	routeCache.set(cacheKey, routes);
+	return routes;
+}
+async function getMixerContext({ payload, market, locale, user = guest, draft = false }) {
+	const cacheKey = getCacheKey({
+		market,
+		locale,
+		user,
+		draft: draft ? "true" : "false"
+	});
+	const mixerCache = getMixerCache();
+	if (mixerCache.has(cacheKey) && USE_CACHE) {
+		console.log("getContext from cache", cacheKey);
+		return mixerCache.get(cacheKey);
+	}
+	const { localized } = getOptions({
+		locale,
+		user,
+		draft
+	});
+	const locales = (await payload.findGlobal({
+		...localized,
+		slug: "locale"
+	})).items.filter((x) => x.isActive);
+	const localeIds = locales.map((x) => x.id);
+	const markets = (await payload.find({
+		...localized,
+		collection: "market"
+	})).docs.filter((x) => x.isActive);
+	const marketIds = markets.map((x) => x.id);
+	const categories = (await payload.find({
+		...localized,
+		collection: "category",
+		depth: 2
+	})).docs;
+	const routes = await getRoutes({
+		payload,
+		market,
+		locale,
+		user,
+		draft
+	});
+	const context = {
+		locale,
+		localeIds,
+		locales,
+		market,
+		marketIds,
+		markets,
+		routes,
+		currentRoutes: filterRoutes(routes, market, locale),
+		categories,
+		richText: false
+	};
+	mixerCache.set(cacheKey, context);
+	await setContext({ context });
+	return context;
+}
+/**
+* Runtime (request-time) payload accessor.
+*
+* By default, operates as the guest user for static generation. For auth:
+* call getHeaders() directly in your page/route/layout, then pass it here.
+*
+* Example:
+*   const headers = await getHeaders();
+*   const { payload, user, getContext } = await getPayload({ config, headers });
+*/
+async function getPayload({ config, headers }) {
+	const payload = await getPayload$1({ config });
+	await setContext({ payload });
+	let user = guest;
+	if (headers) try {
+		const auth = await payload.auth({
+			headers,
+			canSetHeaders: false
+		});
+		if (auth.user) user = auth.user;
+	} catch (error) {
+		console.log("getPayload.error", error);
+	}
+	const draft = false;
+	return {
+		payload,
+		user,
+		getContext: (market, locale) => getMixerContext({
+			payload,
+			market,
+			locale,
+			user,
+			draft
+		})
+	};
+}
+function filterRoutes(routes, market, locale) {
+	market = market === "all" ? defaultMarket : market;
+	locale = locale === "all" ? defaultLocale : locale;
+	return routes.filter((x) => x.market === market && x.locale === locale);
+}
+function getAuthHeaders(token) {
+	if (token) return new Headers({ Authorization: `JWT ${token.value}` });
+	else return new Headers({ Authorization: `users API-Key ${process.env.STORE_API_KEY}` });
+}
+/**
+* Produces the common option block shared across all payload.find / payload.findGlobal calls.
+* For payload.find, add pagination: false and limit: 10000 at the call site.
+* For payload.findByID, spread directly — extra find-only fields are ignored.
+*/
+function buildBaseOptions(user, locale, draft) {
+	return {
+		locale,
+		fallbackLocale: defaultLocale,
+		draft: draft ?? false,
+		depth: 0,
+		user,
+		overrideAccess: false
+	};
+}
+/**
+* Payload proxy example
+*
+*
+* import type { Payload, PayloadRequest } from '../types/index.js'
+
+import { commitTransaction } from './commitTransaction.js'
+import { initTransaction } from './initTransaction.js'
+import { killTransaction } from './killTransaction.js'
+
+const localOperations = [
+'count',
+'countGlobalVersions',
+'countVersions',
+'create',
+'delete',
+'duplicate',
+'find',
+'findByID',
+'delete',
+'duplicate',
+'find',
+'findByID',
+'findGlobal',
+'findGlobalVersionByID',
+'findGlobalVersions',
+'findVersionByID',
+'findVersionByID',
+'login',
+'update',
+'updateGlobal',
+'restoreVersion',
+'restoreGlobalVersion',
+] satisfies (keyof Payload)[]
+
+type LocalOperation = (typeof localOperations)[number]
+
+const isLocalOperation = (key: string): key is LocalOperation => {
+return localOperations.includes(key as LocalOperation)
+}
+
+export const withTransaction = async <T>(
+payload: Payload,
+callback: (transaction: Payload) => Promise<T>,
+) => {
+const transactionReq = { payload } as PayloadRequest
+await initTransaction(transactionReq)
+
+const proxy = new Proxy(payload, {
+get(target, property: keyof Payload, receiver) {
+if (isLocalOperation(property)) {
+const operation = Reflect.get(target, property, receiver)
+
+return function (options) {
+let req: Partial<PayloadRequest> = options.req
+
+if (!req) {
+req = {}
+}
+
+if (!req.transactionID) {
+req = { ...req, transactionID: transactionReq.transactionID }
+}
+
+return (operation as (...args: unknown[]) => void)({
+...options,
+req,
+})
+}
+}
+
+return Reflect.get(target, property, receiver)
+},
+})
+
+try {
+const result = await callback(proxy)
+await commitTransaction(transactionReq)
+return result
+} catch (e) {
+await killTransaction(transactionReq)
+throw e
+}
+}
+
+// -----------------
+
+const { one, two } = await withTransaction(payload, async (transaction) => {
+const one = await transaction.create({ collection: 'posts', data: { title: 'one' } })
+const two = await transaction.create({ collection: 'posts', data: { title: 'two' } })
+
+return { one, two }
+})
+
+*/
+//#endregion
+//#region src/server/layout.ts
+/**
+* Builds the full ILayout object using Payload local API calls.
+*
+* All payload.find / payload.findGlobal calls pass `context: mixerContext` so
+* payload-plugin-bowl can enrich results (hrefs, richText serialisation, etc.).
+*
+* Collection and global slugs use the payload-plugin-bowl defaults:
+*   market     → 'market'   (collection)
+*   locale     → 'locale'   (global)
+*   label      → 'label'    (collection)
+*   app        → 'app'      (global)  ← defined in payload-plugin-bowl
+*   menu       → 'menu'     (collection)
+*
+* The route link tree is built from mixerContext.currentRoutes + mixerContext.categories
+* using getRouteLinkCategory (pure fn, no store calls) from bom-mixer-models/server.
+*/
+async function getLayout(market, locale, payload, user, mixerContext, draft) {
+	const base = buildBaseOptions(user, locale, draft);
+	const findOpts = {
+		...base,
+		pagination: false,
+		limit: 1e4
+	};
+	const markets = (await payload.find({
+		...findOpts,
+		collection: "market",
+		context: mixerContext
+	})).docs;
+	const locales = ((await payload.findGlobal({
+		...base,
+		slug: "locale",
+		context: mixerContext
+	}))?.items ?? []).filter((x) => x.isActive);
+	const labels = (await payload.find({
+		...findOpts,
+		collection: "label",
+		context: mixerContext
+	})).docs;
+	const app = await payload.findGlobal({
+		...base,
+		slug: "app",
+		context: mixerContext
+	});
+	const menusResult = await payload.find({
+		...findOpts,
+		collection: "menu",
+		context: mixerContext
+	});
+	const menu = {};
+	menusResult.docs.forEach((x) => {
+		menu[String(x.id)] = x;
+	});
+	const categories = mixerContext.categories ?? [];
+	const currentRoutes = mixerContext.currentRoutes ?? [];
+	const rootCategory = getRootCategory(categories);
+	const treeResult = rootCategory ? getRouteLinkCategory(locale, currentRoutes, categories, rootCategory, rootCategory) : void 0;
+	const tree = Array.isArray(treeResult) ? treeResult[0] : treeResult;
+	const firstLevelRoutes = tree?.items ?? [];
+	const flatTopLevelRoutes = tree ? [tree, ...firstLevelRoutes] : [];
+	const topLevelRoutes = flatTopLevelRoutes.reduce((object, routeLink) => {
+		if (!object[routeLink.schema] || routeLink.schema === String(routeLink.category)) object[routeLink.schema] = routeLink;
+		return object;
+	}, {});
+	return {
+		labels,
+		locale,
+		locales,
+		market,
+		markets,
+		app,
+		menu,
+		topLevelHrefs: flatTopLevelRoutes.reduce((object, routeLink) => {
+			if (routeLink.href && (!object[routeLink.schema] || routeLink.schema === String(routeLink.category))) object[routeLink.schema] = routeLink.href;
+			return object;
+		}, {}),
+		topLevelRoutes,
+		tree
+	};
+}
+//#endregion
+//#region src/server/page.ts
+/**
+* Fetches a single page document by ID using Payload local API and assembles
+* the IPage envelope (routes, alternates, breadcrumb, parentRoute).
+*
+* All data required for the envelope comes from mixerContext — no store calls.
+*   - routes/alternates : mixerContext.routes filtered by schema+id
+*   - segments          : getCategorySegments() from bom-core (pure)
+*   - breadcrumb        : findRouteOfCategory() from bom-core + mixerContext.currentRoutes
+*/
+async function getPage(slug, id, market, locale, payload, user, mixerContext, draftMode) {
+	try {
+		const base = buildBaseOptions(user, locale, draftMode);
+		const page = await payload.findByID({
+			collection: slug,
+			id,
+			locale: base.locale,
+			fallbackLocale: base.fallbackLocale,
+			draft: base.draft,
+			depth: base.depth,
+			user: base.user,
+			overrideAccess: base.overrideAccess,
+			disableErrors: true,
+			context: mixerContext
+		});
+		if (page) {
+			const routes = mixerContext.routes.filter((r) => r.schema === slug && String(r.page) === String(id));
+			const currentRoute = routes.find((r) => r.market === market && r.locale === locale);
+			const alternates = routes;
+			const categories = mixerContext.categories;
+			const segments = getCategorySegments(categories, page);
+			const currentRoutes = mixerContext.currentRoutes;
+			const breadcrumb = currentRoute ? buildBreadcrumb(segments, currentRoute, currentRoutes) : [];
+			const parentRoute = breadcrumb.length > 1 ? breadcrumb[breadcrumb.length - 2] : void 0;
+			return {
+				...page,
+				href: currentRoute?.id,
+				alternates,
+				breadcrumb,
+				parentRoute
+			};
+		} else {
+			console.log("PageService.getPage.notfound", slug, id, locale);
+			return;
+		}
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/server/context.ts
+/**
+* Per-request context store (React.cache ensures a fresh Map per RSC render).
+* Safe to use inside Next.js server components — do NOT call this at build time.
+*/
+const PageContext = cache(() => {
+	return /* @__PURE__ */ new Map();
+});
+async function getPageContext() {
+	return {
+		layout: PageContext().get("layout"),
+		page: PageContext().get("page"),
+		user: PageContext().get("user") || null,
+		label: PageContext().get("label"),
+		link: PageContext().get("link")
+	};
+}
+async function setPageContext(data) {
+	const context = PageContext();
+	for (const key in data) context.set(key, data[key]);
+}
+/**
+* Same as createPageContext but without draft mode — used for error/not-found pages
+* that should always show published content regardless of draft mode state.
+*/
+async function createNotFoundContext(market, locale, slug, id, config, headers) {
+	const { payload, user, getContext } = await getPayload({
+		config,
+		headers
+	});
+	const context = await getContext(market, locale);
+	const layout = await getLayout(market, locale, payload, user, context);
+	const page = await getPage(slug, id, market, locale, payload, user, context);
+	const label = getLabelFromLabels(layout.labels);
+	const link = (category) => getLink(category, layout);
+	const pageContext = {
+		layout,
+		page,
+		user,
+		label,
+		link
+	};
+	setPageContext(pageContext);
+	return pageContext;
+}
+/**
+* Initialises the full page context using Payload local API.
+*
+* Replaces the @websolutespa/bom-next/server createPageContext that goes through the store
+* abstraction. All data is fetched directly from Payload; the mixer context
+* (routes + categories) is passed to every payload.find call so that
+* payload-plugin-bowl can enrich responses.
+*/
+async function createPageContext(market, locale, slug, id, config, headers) {
+	const draft = { isEnabled: false };
+	const { payload, user, getContext } = await getPayload({
+		config,
+		headers
+	});
+	const context = await getContext(market, locale);
+	const layout = await getLayout(market, locale, payload, user, context, draft.isEnabled);
+	const page = await getPage(slug, id, market, locale, payload, user, context, draft.isEnabled);
+	const label = getLabelFromLabels(layout.labels);
+	const link = (category) => getLink(category, layout);
+	const pageContext = {
+		layout,
+		page,
+		user,
+		label,
+		link
+	};
+	setPageContext(pageContext);
+	return pageContext;
+}
+/**
+* Layout-only context — no page fetch. Used by RootLayout server components.
+*/
+async function createLayoutContext(market, locale, config, headers) {
+	const { payload, user, getContext } = await getPayload({
+		config,
+		headers
+	});
+	const layout = await getLayout(market, locale, payload, user, await getContext(market, locale));
+	const label = getLabelFromLabels(layout.labels);
+	const link = (category) => getLink(category, layout);
+	const pageContext = {
+		layout,
+		user,
+		label,
+		link
+	};
+	setPageContext(pageContext);
+	return pageContext;
+}
+//#endregion
+//#region src/server/handlers/error-response.ts
+const getStatus = (error) => {
+	return typeof error.status === "number" && error.status >= 400 && error.status < 600 ? error.status : 500;
+};
+const isPublic = (error, status) => {
+	return error.isPublic === true || error.isPublic === void 0 && status >= 400 && status < 500;
+};
+/**
+* Converts errors thrown by Next or Payload handlers into Payload-compatible
+* API responses without exposing messages or data from non-public errors.
+*/
+function getHandlerErrorResponse(error) {
+	const statusError = error && typeof error === "object" ? error : {};
+	const status = getStatus(statusError);
+	const publicError = isPublic(statusError, status);
+	const payloadError = { message: publicError && typeof statusError.message === "string" ? statusError.message : publicError && typeof statusError.statusText === "string" ? statusError.statusText : "Something went wrong." };
+	if (publicError && typeof statusError.name === "string") payloadError.name = statusError.name;
+	if (publicError && statusError.data !== null && statusError.data !== void 0) payloadError.data = statusError.data;
+	return Response.json({ errors: [payloadError] }, { status });
+}
+//#endregion
+//#region src/server/handlers/auth.handler.ts
+function getAuthMeHandler(config) {
+	return async function(request) {
+		try {
+			const { user } = await getPayload({
+				config,
+				headers: await headers()
+			});
+			if ((user?.roles || []).includes("user") && "firstName" in user) return Response.json({
+				id: user.id,
+				email: user.email,
+				firstName: user.firstName,
+				lastName: user.lastName
+			}, { status: 200 });
+			return Response.json(null, { status: 200 });
+		} catch (error) {
+			console.log("getAuthMeHandler.error", error);
+			return getHandlerErrorResponse(error);
+		}
+	};
+}
+//#endregion
+//#region src/server/handlers/captions.handler.ts
+function getCaptionsVTT(config) {
+	return async function(request) {
+		try {
+			const title = request.nextUrl.searchParams.get("title") || "Untitled";
+			const body = `WEBVTT
+
+00:00:01.000 --> 00:00:03.000
+- This video has no audio.
+
+${title ? `
+00:00:04.000 --> 00:00:06.000
+- The title of the video is "${title}".
+` : ""}`;
+			return new Response(body, {
+				status: 200,
+				headers: {
+					"Content-Type": "text/plain; charset=UTF-8",
+					"X-Frame-Options": "SAMEORIGIN",
+					"X-Robots-Tag": "noindex, follow"
+				}
+			});
+		} catch (error) {
+			console.error("getCaptionsVTT.error", error);
+			return getHandlerErrorResponse(error);
+		}
+	};
+}
+//#endregion
+//#region src/server/local-api.ts
+async function getLocalApi(config, slug) {
+	const payload = await getPayload$1({ config });
+	const collectionSlugs = payload.config.collections.map((x) => x.slug);
+	const globalSlugs = payload.config.globals.map((x) => x.slug);
+	[...collectionSlugs, ...globalSlugs].sort();
+	if (collectionSlugs.includes(slug)) {
+		const collectionSlug = slug;
+		return {
+			findMany: async (params) => {
+				return (await payload.find({
+					...params,
+					collection: collectionSlug,
+					pagination: false,
+					limit: 1e4,
+					overrideAccess: false
+				})).docs;
+			},
+			findPaged: async (params) => {
+				return await payload.find({
+					...params,
+					collection: collectionSlug,
+					overrideAccess: false
+				});
+			},
+			findOne: async (params) => {
+				return await payload.findByID({
+					id: "",
+					...params,
+					collection: collectionSlug,
+					disableErrors: true,
+					overrideAccess: false
+				});
+			}
+		};
+	} else if (globalSlugs.includes(slug)) {
+		const globalSlug = slug;
+		return {
+			findMany: async (params) => {
+				return await payload.findGlobal({
+					slug: globalSlug,
+					...params,
+					overrideAccess: false
+				});
+			},
+			findPaged: async (params) => {
+				throw "Not implemented";
+			},
+			findOne: async (params) => {
+				throw "Not implemented";
+			}
+		};
+	}
+}
+//#endregion
+//#region src/server/handlers/collection.handler.ts
+function collectionGetHandler(config) {
+	return async function(request, { params: getParams }) {
+		try {
+			const { payload, user, getContext } = await getPayload({
+				config,
+				headers: await headers()
+			});
+			const collectionSlugs = payload.config.collections.map((x) => x.slug);
+			const globalSlugs = payload.config.globals.map((x) => x.slug);
+			const keys = [...collectionSlugs, ...globalSlugs];
+			keys.sort();
+			const { collections } = await getParams;
+			if (!Array.isArray(collections) || collections?.length === 0) {
+				console.error("storeHandler.collectionGet", "method not allowed", collections);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			const slug = collections[0];
+			const id = collections[1];
+			const search = new URL(request.url).search;
+			const params = qsDeserialize(search);
+			const context = params.market && params.locale ? await getContext(params.market, params.locale) : void 0;
+			if (!keys.includes(slug)) {
+				console.error("storeHandler.collectionGet", "keys", slug);
+				console.error("storeHandler.collectionGet", "method not allowed", slug);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			const localApi = await getLocalApi(config, slug);
+			if (id) {
+				const item = await localApi.findOne({
+					...params,
+					id,
+					context,
+					user
+				});
+				if (item) return Response.json(item);
+				else return new Response("not found", {
+					status: 404,
+					statusText: "not found"
+				});
+			} else if (String(params.pagination) === "true") {
+				const items = await localApi.findPaged({
+					...params,
+					context,
+					user
+				});
+				return Response.json(items);
+			} else {
+				const items = await localApi.findMany({
+					...params,
+					context,
+					user
+				});
+				return Response.json(items);
+			}
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.collectionGet.error", response.status, error);
+			return response;
+		}
+	};
+}
+function collectionPostHandler(config) {
+	return async function(request, { params: getParams }) {
+		try {
+			const { payload } = await getPayload({ config });
+			const keys = [...payload.config.collections.map((x) => x.slug), ...payload.config.globals.map((x) => x.slug)];
+			keys.sort();
+			const { collections } = await getParams;
+			if (!Array.isArray(collections) || collections.length !== 1) {
+				console.error("method not allowed", collections);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			const slug = collections[0];
+			if (!keys.includes(slug)) {
+				console.error("storeHandler.collectionGet", "method not allowed", slug);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.collectionPost.error", response.status, error);
+			return response;
+		}
+	};
+}
+function collectionPatchHandler(config) {
+	return async function(request, { params: getParams }) {
+		try {
+			const { payload } = await getPayload({ config });
+			const keys = [...payload.config.collections.map((x) => x.slug), ...payload.config.globals.map((x) => x.slug)];
+			keys.sort();
+			const { collections } = await getParams;
+			if (!Array.isArray(collections) || collections.length !== 2) {
+				console.error("method not allowed", collections);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			const slug = collections[0];
+			if (!keys.includes(slug)) {
+				console.error("storeHandler.collectionGet", "method not allowed", slug);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.collectionPatch.error", response.status, error);
+			return response;
+		}
+	};
+}
+function collectionDeleteHandler(config) {
+	return async function(request, { params: getParams }) {
+		try {
+			const { payload } = await getPayload({ config });
+			const keys = [...payload.config.collections.map((x) => x.slug), ...payload.config.globals.map((x) => x.slug)];
+			keys.sort();
+			const { collections } = await getParams;
+			if (!Array.isArray(collections) || collections.length !== 2) {
+				console.error("method not allowed", collections);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			const slug = collections[0];
+			if (!keys.includes(slug)) {
+				console.error("storeHandler.collectionGet", "method not allowed", slug);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			collections[1];
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.collectionDelete.error", response.status, error);
+			return response;
+		}
+	};
+}
+//#endregion
+//#region src/server/handlers/index.handler.ts
+function indexGetHandler(config) {
+	return async function(request) {
+		try {
+			const payload = await getPayload$1({ config });
+			const keys = [...payload.config.collections.map((x) => x.slug), ...payload.config.globals.map((x) => x.slug)];
+			keys.sort();
+			const market = defaultMarket;
+			const locale = defaultLocale;
+			if (!Array.isArray(keys) || keys?.length === 0) {
+				console.error("apiHome.collectionGet", "collections not found", keys);
+				return new Response("method not allowed", {
+					status: 405,
+					statusText: "method not allowed"
+				});
+			}
+			return new Response(`
+    <html>
+    <head>
+      <title>REST Api</title>
+      <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+      <style type="text/css">
+        html {
+          padding: 0;
+          background: #09090A;
+          color: #fefefe;
+        }
+        body {
+          padding: 15px;
+          font-family: Inter,-apple-system,'Helvetica Neue','Segoe UI',Roboto,Arial,'Noto Sans',sans-serif;
+          font-size: 13px;
+          background: #09090A;
+          color: #fefefe;
+        }
+        .container {
+          margin: 0 auto;
+          max-width: 1280px;
+        }
+        a {
+          color: #fefefe;
+          text-decoration: none;
+        }
+        a:visited {
+          color: #9e9e9e;
+        }
+        a:hover {
+          text-decoration: underline;
+        }
+        table {
+          width: 100%;
+          margin: 10px 0;
+          border: none;
+          border-collapse: collapse;
+        }
+        td,
+        th {
+          text-align: left;
+          font-size: 12px;
+          padding: 3px;
+        }
+        th:not(:last-child),
+        td:not(:last-child) {
+          padding-right: 30px;
+        }
+        thead th {
+          border-bottom: 1px solid #0e0e0f;
+        }
+        #table tr:nth-child(odd) td {
+          background-color: #0e0e0f;
+        }
+        #table tbody tr:hover td {
+          background-color: #1A1A1B;
+        }
+        #table tbody tr:hover td,
+        #table tbody tr:hover td a {
+          color: #fefefe;
+        }
+        .wysiwyg {
+          margin: 0;
+          padding: 0 0 10px 0;
+          line-height: 1.2em;
+        }
+        .wysiwyg a {
+          color: #00ea4e;
+          font-weight: 600;
+        }
+        .wysiwyg a:visited {
+          color: #00ea4e;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <h1>REST API</h1>
+        <p class="wysiwyg">
+          This is the REST Api generated by <a href="https://github.com/websolutespa/bom" target="_blank" rel="noopener">Mixer</a>.
+        </p>
+        <p class="wysiwyg">
+          It contains a list of all the generic local api CRUD handlers of Mixer app. <br />
+          All methods should be called with market and locale parameters.
+        </p>
+        <table id="table" cellpadding="3">
+          <thead>
+            <tr>
+              <th width="150px">Method</th>
+              <th width="150px">Collection</th>
+              <th>Endpoint</th>
+            </tr>
+          </thead>
+          <tbody>
+          ${keys.map((c) => `
+            <tr>
+              <td>GET, POST, PATCH</td>
+              <td>${c}</td>
+              <td><a href="/api/${c}?market=${market}&locale=${locale}" target="_blank">/api/${c}</a></td>
+            </tr>
+            <tr>
+              <td>GET, DELETE</td>
+              <td>${c}</td>
+              <td><a href="/api/${c}/1?market=${market}&locale=${locale}" target="_blank">/api/${c}/{id}</a></td>
+            </tr>
+          `).join("\n")}
+          </tbody>
+        </table>
+      </div>
+    </body>
+    `, { headers: {
+				"Content-Type": "text/html; charset=UTF-8",
+				"X-Frame-Options": "SAMEORIGIN",
+				"X-Robots-Tag": "noindex, follow"
+			} });
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.indexGet.error", response.status, error);
+			return response;
+		}
+	};
+}
+//#endregion
+//#region src/server/handlers/preview.handler.ts
+async function previewHandler(request) {
+	const { searchParams } = new URL(request.url);
+	const { marketId, localeId, templateId, documentId, _status, _live } = Object.fromEntries(searchParams);
+	const destination = `/${marketId}/${localeId}/${templateId}/${documentId}${_live ? "?_live=true" : ""}`;
+	(await draftMode()).enable();
+	const path = `${process.env.NEXT_PUBLIC_URL}${destination}`;
+	return NextResponse.redirect(path, { status: 303 });
+}
+//#endregion
+//#region src/server/handlers/registry.handler.ts
+const REGISTRY_SCHEMA = "https://ui.shadcn.com/schema/registry.json";
+const REGISTRY_ITEM_SCHEMA = "https://ui.shadcn.com/schema/registry-item.json";
+const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".css",
+	".json",
+	".ts",
+	".tsx"
+]);
+const PUBLISHED_DIRECTORIES = /* @__PURE__ */ new Set([
+	"components",
+	"examples",
+	"hooks",
+	"lazy",
+	"lib",
+	"sections",
+	"theme"
+]);
+const SHADCN_COMPONENTS = /* @__PURE__ */ new Set([
+	"accordion",
+	"alert-dialog",
+	"alert",
+	"aspect-ratio",
+	"avatar",
+	"badge",
+	"breadcrumb",
+	"calendar",
+	"card",
+	"carousel",
+	"chart",
+	"checkbox",
+	"collapsible",
+	"combobox",
+	"command",
+	"context-menu",
+	"dialog",
+	"drawer",
+	"dropdown-menu",
+	"form",
+	"hover-card",
+	"input",
+	"input-otp",
+	"label",
+	"menubar",
+	"navigation-menu",
+	"pagination",
+	"popover",
+	"progress",
+	"radio-group",
+	"resizable",
+	"scroll-area",
+	"select",
+	"separator",
+	"sheet",
+	"sidebar",
+	"skeleton",
+	"slider",
+	"sonner",
+	"switch",
+	"table",
+	"tabs",
+	"textarea",
+	"toast",
+	"toggle",
+	"toggle-group",
+	"tooltip"
+]);
+function toKebabCase(value) {
+	return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[._\s]+/g, "-").toLowerCase();
+}
+function titleFromName(name) {
+	return name.replace(/(^|[-_])(\w)/g, (_, __, character) => character.toUpperCase());
+}
+function packageName(specifier) {
+	return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
+}
+function getOrigin$1(request) {
+	return process.env.NEXT_PUBLIC_URL?.replace(/\/$/, "") || request.nextUrl.origin;
+}
+async function directoryExists(directory) {
+	try {
+		return (await stat(directory)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function getUiSourceDirectory() {
+	if (process.env.UI_REGISTRY_SOURCE_DIR) {
+		const configuredPath = resolve(process.env.UI_REGISTRY_SOURCE_DIR);
+		if (await directoryExists(configuredPath)) return configuredPath;
+		throw new Error(`UI_REGISTRY_SOURCE_DIR does not exist: ${configuredPath}`);
+	}
+	let currentDirectory = process.cwd();
+	while (dirname(currentDirectory) !== currentDirectory) {
+		const candidate = join(currentDirectory, "packages", "ui", "src");
+		if (await directoryExists(candidate)) return candidate;
+		currentDirectory = dirname(currentDirectory);
+	}
+	throw new Error("Unable to find packages/ui/src. Set UI_REGISTRY_SOURCE_DIR to its absolute path.");
+}
+async function getSourceFiles(directory, sourceDirectory = directory) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		const absolutePath = join(directory, entry.name);
+		if (entry.isDirectory()) return getSourceFiles(absolutePath, sourceDirectory);
+		if (!SOURCE_EXTENSIONS.has(extname(entry.name)) || entry.name.endsWith(".d.ts") || /\.(test|spec)\.[^.]+$/.test(entry.name)) return [];
+		return [{
+			absolutePath,
+			relativePath: entry.name
+		}];
+	}))).flat().map((file) => ({
+		...file,
+		relativePath: relative(sourceDirectory, file.absolutePath).replaceAll("\\", "/")
+	}));
+}
+function getImportSpecifiers(source) {
+	return [...source.matchAll(/(?:import|export)\s+(?:type\s+)?(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g)].map((match) => match[1]);
+}
+function resolveSourceImport(sourceDirectory, sourceFile, specifier, sourceFiles) {
+	let candidate;
+	if (specifier.startsWith("@app/ui/")) candidate = specifier.slice(8);
+	if (specifier.startsWith(".")) candidate = relative(sourceDirectory, resolve(dirname(sourceFile), specifier)).replaceAll("\\", "/");
+	if (!candidate) return void 0;
+	const normalizedCandidate = candidate.replace(/^\.\//, "");
+	return sourceFiles.get(normalizedCandidate) || sourceFiles.get(`${normalizedCandidate}.ts`) || sourceFiles.get(`${normalizedCandidate}.tsx`) || sourceFiles.get(`${normalizedCandidate}/index.ts`) || sourceFiles.get(`${normalizedCandidate}/index.tsx`);
+}
+function rewriteUiImports(source, sourceFile, sourceDirectory, sourceFiles) {
+	return source.replace(/(['"])(@app\/ui\/[^'"]+|\.\.?\/[^'"]+)\1/g, (match, quote, specifier) => {
+		const importedFile = resolveSourceImport(sourceDirectory, sourceFile.absolutePath, specifier, sourceFiles);
+		return importedFile ? `${quote}${getImportPath(importedFile.relativePath)}${quote}` : match;
+	});
+}
+function getImportPath(relativePath) {
+	const extensionlessPath = relativePath.replace(/\.(tsx?|mts|cts)$/, "");
+	if (extensionlessPath.startsWith("components/")) return `@/components/ui/${extensionlessPath.slice(11)}`;
+	if (extensionlessPath.startsWith("hooks/")) return `@/hooks/${extensionlessPath.slice(6)}`;
+	if (extensionlessPath.startsWith("lib/")) return `@/lib/${extensionlessPath.slice(4)}`;
+	return `@/components/${extensionlessPath}`;
+}
+function getTargetPath(relativePath) {
+	if (relativePath.startsWith("components/")) return `@ui/${relativePath.slice(11)}`;
+	if (relativePath.startsWith("hooks/")) return `@hooks/${relativePath.slice(6)}`;
+	if (relativePath.startsWith("lib/")) return `@lib/${relativePath.slice(4)}`;
+	return `@components/${relativePath}`;
+}
+function getRegistryFileType(relativePath) {
+	if (relativePath.startsWith("components/")) return "registry:ui";
+	if (relativePath.startsWith("hooks/")) return "registry:hook";
+	if (relativePath.startsWith("theme/")) return "registry:style";
+	if (extname(relativePath) === ".json") return "registry:file";
+	return "registry:lib";
+}
+function isPublishedFile(file) {
+	const [directory] = file.relativePath.split("/");
+	return PUBLISHED_DIRECTORIES.has(directory) && !/(^|\/)index\.[^.]+$/.test(file.relativePath);
+}
+function getRegistryItemName(file) {
+	const [directory, ...path] = file.relativePath.split("/");
+	const name = toKebabCase(path.join("/").replace(extname(file.relativePath), "").replaceAll("/", "-"));
+	return directory === "components" ? name : `${directory}-${name}`;
+}
+async function createRegistryCatalog(sourceDirectory, origin) {
+	const files = (await getSourceFiles(sourceDirectory)).filter((file) => PUBLISHED_DIRECTORIES.has(file.relativePath.split("/")[0]));
+	const filesByRelativePath = new Map(files.map((file) => [file.relativePath, file]));
+	const entries = new Map(files.filter(isPublishedFile).map((file) => [getRegistryItemName(file), file]));
+	const entryNamesByPath = new Map([...entries].map(([name, file]) => [file.relativePath, name]));
+	const includedItems = new Set([...entries].filter(([name, file]) => !file.relativePath.startsWith("components/") || name === "button" || !SHADCN_COMPONENTS.has(name)).map(([name]) => name));
+	async function getItem(name) {
+		const entry = entries.get(name);
+		if (!entry || !includedItems.has(name)) return void 0;
+		const filesToInclude = /* @__PURE__ */ new Map();
+		const externalDependencies = /* @__PURE__ */ new Set();
+		const registryDependencies = /* @__PURE__ */ new Set();
+		const pendingFiles = [entry];
+		while (pendingFiles.length) {
+			const file = pendingFiles.pop();
+			if (filesToInclude.has(file.relativePath)) continue;
+			filesToInclude.set(file.relativePath, file);
+			const source = await readFile(file.absolutePath, "utf8");
+			for (const specifier of getImportSpecifiers(source)) {
+				const localFile = resolveSourceImport(sourceDirectory, file.absolutePath, specifier, filesByRelativePath);
+				const dependencyName = localFile && entryNamesByPath.get(localFile.relativePath);
+				if (localFile?.relativePath.startsWith("components/")) {
+					const componentName = toKebabCase(basename(localFile.relativePath, extname(localFile.relativePath)));
+					if (dependencyName !== name) registryDependencies.add(includedItems.has(componentName) ? `${origin}/r/${componentName}.json` : componentName);
+				} else if (localFile && dependencyName && dependencyName !== name && includedItems.has(dependencyName)) registryDependencies.add(`${origin}/r/${dependencyName}.json`);
+				else if (localFile) pendingFiles.push(localFile);
+				else if (!specifier.startsWith(".") && !specifier.startsWith("@app/ui/") && !specifier.startsWith("node:") && specifier !== "react" && specifier !== "react-dom") externalDependencies.add(packageName(specifier));
+			}
+		}
+		const registryFiles = await Promise.all([...filesToInclude.values()].sort((left, right) => left.relativePath.localeCompare(right.relativePath)).map(async (file) => ({
+			path: file.relativePath,
+			content: rewriteUiImports(await readFile(file.absolutePath, "utf8"), file, sourceDirectory, filesByRelativePath),
+			type: getRegistryFileType(file.relativePath),
+			target: getTargetPath(file.relativePath)
+		})));
+		return {
+			$schema: REGISTRY_ITEM_SCHEMA,
+			name,
+			type: "registry:ui",
+			title: titleFromName(name),
+			...externalDependencies.size && { dependencies: [...externalDependencies].sort() },
+			...registryDependencies.size && { registryDependencies: [...registryDependencies].sort() },
+			files: registryFiles
+		};
+	}
+	async function getCatalogItem(name) {
+		const item = await getItem(name);
+		if (!item) return void 0;
+		return {
+			...item,
+			files: item.files.map((file) => ({
+				path: file.path,
+				type: file.type,
+				target: file.target
+			}))
+		};
+	}
+	return {
+		items: includedItems,
+		getCatalogItem,
+		getItem
+	};
+}
+function jsonResponse(body, status = 200) {
+	return Response.json(body, {
+		status,
+		headers: {
+			"X-Frame-Options": "SAMEORIGIN",
+			"X-Robots-Tag": "noindex, follow"
+		}
+	});
+}
+function getRegistry() {
+	return async function(request) {
+		const catalog = await createRegistryCatalog(await getUiSourceDirectory(), getOrigin$1(request));
+		const items = (await Promise.all([...catalog.items].sort().map((name) => catalog.getCatalogItem(name)))).filter(Boolean);
+		return jsonResponse({
+			$schema: REGISTRY_SCHEMA,
+			name: "bom-ui",
+			homepage: getOrigin$1(request),
+			items
+		});
+	};
+}
+function getRegistryItem() {
+	return async function(request, { params: getParams }) {
+		const { slug } = await getParams;
+		const name = slug.at(-1)?.replace(/\.json$/, "");
+		if (!name) return jsonResponse({ error: "Registry item name is required." }, 404);
+		const item = await (await createRegistryCatalog(await getUiSourceDirectory(), getOrigin$1(request))).getItem(name);
+		return item ? jsonResponse(item) : jsonResponse({ error: `Registry item not found: ${name}` }, 404);
+	};
+}
+//#endregion
+//#region src/server/handlers/route.handler.ts
+/**
+* Creates the internal `/-route` GET handler used by middleware to resolve CMS
+* paths, route schemas, and redirects before a page is rendered.
+*
+* One Payload request is created per incoming API request so authentication and
+* query context are shared by every route operation. The route service then
+* reuses its snapshot cache, which avoids rebuilding the complete route graph
+* for repeated market, locale, and access contexts.
+*/
+function getRouteHandler(config) {
+	return async function(request) {
+		try {
+			const searchParams = request.nextUrl.searchParams;
+			const pathname = searchParams.get("pathname") || void 0;
+			const href = searchParams.get("href") || void 0;
+			const hrefBeforeRedirect = searchParams.get("hrefBeforeRedirect") || void 0;
+			const schema = searchParams.get("schema") || void 0;
+			const market = searchParams.get("market") || void 0;
+			const locale = searchParams.get("locale") || void 0;
+			const payload = await getPayload$1({ config });
+			const req = await createPayloadRequest({
+				config,
+				request
+			});
+			req.payload = payload;
+			req.user = guest;
+			if (schema && market && locale) {
+				req.query = {
+					locale,
+					market
+				};
+				const route = (await getRouteSnapshot(req)).getSchema(schema, market, locale);
+				return route ? ResponseSuccess({ route }) : ResponseNotFound();
+			}
+			if (pathname && href) {
+				const resolution = (await getRouteSnapshot(req)).resolve(pathname);
+				const route = resolution.route;
+				if (route !== void 0) return ResponseSuccess({
+					parent: resolution.parent,
+					route: {
+						...route,
+						...resolution.splat ? { splat: resolution.splat } : {}
+					}
+				});
+				else {
+					const url = new URL(href);
+					const urlBeforeRedirect = hrefBeforeRedirect ? new URL(hrefBeforeRedirect) : null;
+					const sanitizedHref = sanitizeHref(url, urlBeforeRedirect);
+					const { payload } = req;
+					const payloadResponse = await payload.find({
+						collection: "redirect",
+						where: { isActive: { equals: true } },
+						sort: "order",
+						depth: 0,
+						limit: 1e4,
+						pagination: false,
+						req,
+						overrideAccess: true
+					});
+					let redirects = payloadResponse.docs ? payloadResponse.docs : [];
+					redirects = redirects.map((x) => ({
+						...x,
+						from: sanitizeRedirectFrom(x.from, url, urlBeforeRedirect),
+						to: sanitizeRedirectTo(x.to)
+					}));
+					const exactMatchResolver = (redirect) => {
+						const status = parseInt(redirect.status) || 307;
+						if (status < 400) {
+							const redirectUrl = sanitizeRedirectUrl(redirect.to, url);
+							return Response.json({ redirectUrl }, { status });
+						} else return Response.json("gone", { status });
+					};
+					const exactMatchRedirect = redirects.find((x) => x.from === sanitizedHref);
+					if (exactMatchRedirect !== void 0) return exactMatchResolver(exactMatchRedirect);
+					const patternMatchResolver = (redirect) => {
+						const status = parseInt(redirect.status) || 307;
+						if (status < 400) {
+							const regexp = new RegExp(redirect.from);
+							let i = 0;
+							let redirectUrl = redirect.to.replace(/\*/g, (...rest) => {
+								return `$${++i}`;
+							});
+							redirectUrl = sanitizedHref.replace(regexp, redirectUrl);
+							return Response.json({ redirectUrl }, { status });
+						} else return Response.json("gone", { status });
+					};
+					redirects.forEach((x) => {
+						let expression = x.from;
+						expression = expression.replace(/\*(?!\))/g, "(.*)");
+						expression = `^${expression.replace(/(^\^)|(\$$)/g, "")}$`;
+						x.from = expression;
+					});
+					const firstMatch = redirects.find((x) => sanitizedHref.match(x.from));
+					if (firstMatch) return patternMatchResolver(firstMatch);
+					return ResponseSuccess({ parent: resolution.parent });
+				}
+			} else {
+				const query = qsDeserialize(decodeURIComponent(searchParams.toString()));
+				req.query = query;
+				const routes = await getRoutes$1(req);
+				let items = await whereCollection(routes, query.where);
+				items = await sortCollection(items, query.sort);
+				return ResponseSuccess(items);
+			}
+		} catch (error) {
+			console.error("routeGetHandler.error", error);
+			return getHandlerErrorResponse(error);
+		}
+	};
+}
+//#endregion
+//#region src/server/handlers/sitemap.handler.ts
+const origin = process.env.NEXT_PUBLIC_URL || "";
+function getSiteMapIndex(config) {
+	return async function(request) {
+		try {
+			const { getContext } = await getPayload({ config });
+			const { markets, locales, routes } = await getContext(defaultMarket, defaultLocale);
+			const sitemaps = [];
+			const getTime = (date) => {
+				return typeof date !== "undefined" ? (typeof date === "string" ? new Date(date) : date).getTime() : 0;
+			};
+			eachMarketLocale(markets, locales, (market, locale, markets, locales) => {
+				const sitemapRoutes = routes.filter((x) => x.market === market.id && x.locale === locale.id);
+				sitemapRoutes.sort((a, b) => getTime(a.updatedAt) - getTime(b.updatedAt));
+				sitemaps.push({
+					id: `/${market.id}/${locale.id}/sitemap.xml`,
+					updatedAt: sitemapRoutes.length > 0 ? sitemapRoutes[sitemapRoutes.length - 1].updatedAt : void 0
+				});
+			});
+			const body = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemaps.map((sitemap) => `
+  <sitemap>
+    <loc>${escapeHtml(encodeURI(`${origin}${sitemap.id}`))}</loc>${sitemap.updatedAt ? `
+    <lastmod>${escapeHtml(String(sitemap.updatedAt))}</lastmod>` : ""}
+  </sitemap>
+`).join("")}
+</sitemapindex>`;
+			return new Response(body, {
+				status: 200,
+				headers: {
+					"Content-Type": "application/xml; charset=UTF-8",
+					"X-Frame-Options": "SAMEORIGIN",
+					"X-Robots-Tag": "noindex, follow"
+				}
+			});
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.sitemapIndex.error", response.status, error);
+			return response;
+		}
+	};
+}
+function getSiteMapXML(config) {
+	return async function(request, { params: getParams }) {
+		try {
+			const params = await getParams;
+			const market = params?.market || defaultMarket;
+			const locale = params?.locale || defaultLocale;
+			const { getContext } = await getPayload({ config });
+			const { markets, locales, routes } = await getContext(market, locale);
+			const selectedMarket = markets.find((x) => market ? x.id === market : x.isDefault) || markets[0];
+			const selectedLocale = locales.find((x) => locale ? x.id === locale : x.isDefault) || locales[0];
+			const selectedMarketLocale = selectedMarket && selectedMarket.defaultLanguage ? selectedMarket.defaultLanguage : selectedLocale.id;
+			const isCanonicalRoute = market && locale ? (route) => {
+				return route.noindex !== true && route.market === selectedMarket.id && route.locale === selectedLocale.id;
+			} : (route) => {
+				return route.noindex !== true && route.market === selectedMarket.id && route.locale === selectedMarketLocale;
+			};
+			const getCanonicalAlternates = market && locale ? (canonical) => {
+				return [];
+			} : (canonical) => {
+				return routes.filter((alternate) => {
+					return alternate !== canonical && alternate.schema === canonical.schema && alternate.page === canonical.page;
+				});
+			};
+			const routeToRouteCanonical = (canonical) => {
+				const alternates = getCanonicalAlternates(canonical);
+				return {
+					...canonical,
+					alternates
+				};
+			};
+			const canonicalRoutes = routes.filter(isCanonicalRoute).map(routeToRouteCanonical);
+			const body = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xhtml="http://www.w3.org/1999/xhtml"
+        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
+${getSiteMapXMLUrls(origin, canonicalRoutes)}
+</urlset>
+ `;
+			return new Response(body, {
+				status: 200,
+				headers: {
+					"Content-Type": "application/xml; charset=UTF-8",
+					"X-Frame-Options": "SAMEORIGIN",
+					"X-Robots-Tag": "noindex, follow"
+				}
+			});
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.sitemapXml.error", response.status, error);
+			return response;
+		}
+	};
+}
+function getSiteMapXSL(config) {
+	return async function(request, { params: getParams }) {
+		try {
+			const body = `<?xml version="1.0" encoding="UTF-8"?>
+	<xsl:stylesheet version="2.0"
+		xmlns:html="http://www.w3.org/TR/REC-html40"
+		xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
+		xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+		xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+	<xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
+	<xsl:template match="/">
+		<html lang="${(await getParams)?.locale || defaultLocale}" xmlns="http://www.w3.org/1999/xhtml">
+		<head>
+			<title>XML Sitemap</title>
+			<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+			<style type="text/css">
+        html {
+          padding: 0;
+          background: #09090A;
+					color: #fefefe;
+        }
+				body {
+          padding: 15px;
+					font-family: Inter,-apple-system,'Helvetica Neue','Segoe UI',Roboto,Arial,'Noto Sans',sans-serif;
+					font-size: 13px;
+          background: #09090A;
+					color: #fefefe;
+				}
+				.container {
+					margin: 0 auto;
+					max-width: 1280px;
+				}
+				a {
+					color: #fefefe;
+					text-decoration: none;
+				}
+				a:visited {
+					color: #9e9e9e;
+				}
+				a:hover {
+					text-decoration: underline;
+				}
+				table {
+          width: 100%;
+          margin: 10px 0;
+					border: none;
+					border-collapse: collapse;
+				}
+				td,
+        th {
+					text-align: left;
+					font-size: 12px;
+          padding: 3px;
+				}
+				th:not(:last-child),
+        td:not(:last-child) {
+					padding-right: 30px;
+				}
+				thead th {
+					border-bottom: 1px solid #0e0e0f;
+				}
+				#sitemap tr:nth-child(odd) td {
+					background-color: #0e0e0f;
+				}
+				#sitemap tbody tr:hover td {
+					background-color: #1A1A1B;
+				}
+				#sitemap tbody tr:hover td,
+        #sitemap tbody tr:hover td a {
+					color: #fefefe;
+				}
+				.wysiwyg {
+          margin: 0;
+					padding: 0 0 10px 0;
+					line-height: 1.2em;
+				}
+				.wysiwyg a {
+					color: #00ea4e;
+					font-weight: 600;
+				}
+				.wysiwyg a:visited {
+					color: #00ea4e;
+				}
+			</style>
+		</head>
+		<body>
+		<div class="container">
+			<h1>XML Sitemap</h1>
+			<p class="wysiwyg">
+        This is an XML Sitemap meant for consumption by search engines, generated by <a href="https://github.com/websolutespa/bom" target="_blank" rel="noopener">Mixer</a>.
+      </p>
+      <p class="wysiwyg">
+				You can find more information about XML sitemaps on <a href="https://sitemaps.org" target="_blank" rel="noopener">sitemaps.org</a>.
+			</p>
+			<xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &gt; 0">
+				<p class="wysiwyg">
+					This sitemap index file contains <xsl:value-of select="count(sitemap:sitemapindex/sitemap:sitemap)"/> sitemaps.
+				</p>
+				<table id="sitemap" cellpadding="3">
+					<thead>
+            <tr>
+              <th width="75%">Sitemap</th>
+              <th width="25%" title="Last Modification Time">Updated At</th>
+            </tr>
+					</thead>
+					<tbody>
+					<xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
+						<xsl:variable name="sitemapURL">
+							<xsl:value-of select="sitemap:loc"/>
+						</xsl:variable>
+						<tr>
+							<td>
+								<a href="{$sitemapURL}"><xsl:value-of select="sitemap:loc"/></a>
+							</td>
+							<td>
+								<xsl:value-of select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+							</td>
+						</tr>
+					</xsl:for-each>
+					</tbody>
+				</table>
+			</xsl:if>
+			<xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &lt; 1">
+				<p class="wysiwyg">
+					This sitemap contains <xsl:value-of select="count(sitemap:urlset/sitemap:url)"/> URLs.
+				</p>
+				<table id="sitemap" cellpadding="3">
+					<thead>
+					<tr>
+						<th width="75%">URL</th>
+						<th width="15%" title="Last Modification Time">Updated At</th>
+						<th width="10%">Images</th>
+					</tr>
+					</thead>
+					<tbody>
+					<xsl:variable name="lower" select="'abcdefghijklmnopqrstuvwxyz'"/>
+					<xsl:variable name="upper" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>
+					<xsl:for-each select="sitemap:urlset/sitemap:url">
+						<tr>
+							<td>
+								<xsl:variable name="itemURL">
+									<xsl:value-of select="sitemap:loc"/>
+								</xsl:variable>
+								<a href="{$itemURL}">
+									<xsl:value-of select="sitemap:loc"/>
+								</a>
+							</td>
+							<td>
+								<xsl:value-of select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+							</td>
+							<td>
+								<xsl:value-of select="count(image:image)"/>
+							</td>
+						</tr>
+					</xsl:for-each>
+					</tbody>
+				</table>
+			</xsl:if>
+		</div>
+		</body>
+		</html>
+	</xsl:template>
+	</xsl:stylesheet>`;
+			return new Response(body, {
+				status: 200,
+				headers: {
+					"Content-Type": "application/xml; charset=UTF-8",
+					"X-Frame-Options": "SAMEORIGIN",
+					"X-Robots-Tag": "noindex, follow"
+				}
+			});
+		} catch (error) {
+			const response = getHandlerErrorResponse(error);
+			console.error("storeHandler.sitemapXsl.error", response.status, error);
+			return response;
+		}
+	};
+}
+function getSiteMapXMLLastMod(canonical) {
+	return canonical.updatedAt ? `
+    <lastmod>${escapeHtml(String(canonical.updatedAt))}</lastmod>` : "";
+}
+function getSiteMapXMLImage(canonical) {
+	return canonical.media ? `
+    <image:image>
+      <image:loc>${escapeHtml(encodeURI(`${canonical.media.src || canonical.media.url}`))}</image:loc>
+    </image:image>` : "";
+}
+function getSiteMapXMLAlternates(origin, canonical) {
+	return canonical.alternates.map((alternate) => `
+    <xhtml:link href="${escapeHtml(encodeURI(`${origin}${alternate.id}`))}" hreflang="${alternate.locale}-${alternate.market}" rel="alternate" />`).join("");
+}
+function getSiteMapXMLUrl(origin, canonical) {
+	return `
+  <url>
+    <loc>${escapeHtml(encodeURI(`${origin}${canonical.id}`))}</loc>${getSiteMapXMLLastMod(canonical)}${getSiteMapXMLAlternates(origin, canonical)}${getSiteMapXMLImage(canonical)}
+  </url>`;
+}
+function escapeHtml(string) {
+	const matchHtmlRegExp = /["'&<>]/;
+	const str = "" + string;
+	const match = matchHtmlRegExp.exec(str);
+	if (!match) return str;
+	let escape;
+	let html = "";
+	let index = 0;
+	let lastIndex = 0;
+	for (index = match.index; index < str.length; index++) {
+		switch (str.charCodeAt(index)) {
+			case 34:
+				escape = "&quot;";
+				break;
+			case 38:
+				escape = "&amp;";
+				break;
+			case 39:
+				escape = "&#39;";
+				break;
+			case 60:
+				escape = "&lt;";
+				break;
+			case 62:
+				escape = "&gt;";
+				break;
+			default: continue;
+		}
+		if (lastIndex !== index) html += str.substring(lastIndex, index);
+		lastIndex = index + 1;
+		html += escape;
+	}
+	return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+function getSiteMapXMLUrls(origin, canonicalRoutes) {
+	return canonicalRoutes.map((canonicalRoute) => getSiteMapXMLUrl(origin, canonicalRoute)).join("");
+}
+//#endregion
+//#region src/server/handlers/static-params.handler.ts
+/**
+* Returns a generateStaticParams function for a given page collection slug.
+*/
+function getStaticParams(slug, config) {
+	return async function generateStaticParams() {
+		if (isDevelopment || buildStrategy === "runtime") return [];
+		const { getContext } = await getPayload({ config });
+		const { routes } = await getContext("all", "all");
+		return routes.filter((r) => r.schema === slug).map((route) => ({
+			market: route.market,
+			locale: route.locale,
+			id: String(route.page)
+		}));
+	};
+}
+function getStaticParams_(schema) {
+	return async function generateStaticParams() {
+		if (isDevelopment || buildStrategy === "runtime") return [];
+		const query = qsSerialize({ where: { or: [{
+			schema: { equals: schema },
+			template: { equals: schema }
+		}] } });
+		return (await localApiGet(`/-route?${query}`)).map((route) => ({
+			market: route.market,
+			locale: route.locale,
+			id: String(route.page)
+		}));
+	};
+}
+function getStaticParamsFromPayload(schema, config) {
+	return async function generateStaticParams() {
+		if (isDevelopment || buildStrategy === "runtime") return [];
+		return (await getRoutes({
+			payload: await getPayloadInstance({ config }),
+			market: "all",
+			locale: "all",
+			user: guest,
+			draft: false
+		})).filter((route) => route.schema === schema || route.template === schema).map((route) => ({
+			market: route.market,
+			locale: route.locale,
+			id: String(route.page)
+		}));
+	};
+}
+//#endregion
+//#region src/server/handlers/vars.handler.ts
+const DISALLOWED_KEYS = ["__NEXT_PRIVATE_STANDALONE_CONFIG"];
+const getFilteredEnv = (env) => {
+	const entries = Object.entries(env).filter(([k, v]) => !DISALLOWED_KEYS.includes(k) && typeof v === "string");
+	entries.sort();
+	return Object.fromEntries(entries);
+};
+const sortKeys = (object) => {
+	const entries = Object.entries(object || {});
+	entries.sort();
+	return Object.fromEntries(entries);
+};
+function getVarsHandler(config) {
+	return async function(request) {
+		try {
+			const searchParams = request.nextUrl.searchParams;
+			const { market, locale, defaultMarket, defaultLocale, params } = getSearchParams(request);
+			const headers$1 = await headers();
+			const { payload, user, getContext } = await getPayload({
+				config,
+				headers: headers$1
+			});
+			if (!(user?.roles || []).includes("admin")) throw {
+				status: 401,
+				message: "Unauthorized"
+			};
+			const context = await getContext(market || defaultMarket, locale || defaultLocale);
+			const layout = await getLayout(market || defaultMarket, locale || defaultLocale, payload, user, context);
+			const info = {
+				production: isProduction,
+				development: isDevelopment,
+				origin: getOrigin(headers$1),
+				host: getHost(headers$1),
+				params: {},
+				searchParams: { ...sortKeys(Object.fromEntries(searchParams)) },
+				headers: { ...sortKeys(Object.fromEntries(headers$1)) },
+				env: { ...getFilteredEnv(process.env) },
+				user: { ...sortKeys(user) },
+				context: { ...sortKeys(context) },
+				layout: { ...sortKeys(layout) }
+			};
+			const accept = headers$1.get("accept");
+			if (!accept || !accept.includes("text/html")) return Response.json(info, { status: 200 });
+			return new Response(`<!DOCTYPE html>
+<html>
+<head>
+  <meta charSet="utf-8"/>
+  <style>
+    html, body {
+      background: #282828;
+      color: #7cacf8;
+    }
+    body {
+      padding: 0;
+      margin: 0;
+      font-family: monospace;
+      font-size: 14px;
+      line-height: 1.16;
+      font-weight: 100;
+    }
+    json-viewer {
+      padding: 20px;
+      min-height: 100vh;
+      box-sizing: border-box;
+      line-height: 1.2;
+      --background-color: #282828;
+      --color: #e3e3e3;
+      --property-color: #7cacf8;
+      --string-color: #53d5fb;
+      --number-color: #7b80ff;
+      --boolean-color: #9980ff;
+      --null-color: #6f6f6f;
+      --preview-color: #8f8f8f;
+      --highlight-color: #7b0000;
+      --font-family: monospace;
+      --font-size: 14px;
+      --indent-size: 1em;
+      --indentguide-size: 1px;
+      --indentguide-style: solid;
+      --indentguide-color: #333;
+      --indentguide-color-active: #666;
+      --indentguide: var(--indentguide-size) var(--indentguide-style) var(--indentguide-color);
+      --indentguide-active: var(--indentguide-size) var(--indentguide-style) var(--indentguide-color-active);
+    }
+
+    :root {
+      --scrollbar-size: 8px;
+      --scrollbar-border-radius: 2px;
+      --scrollbar-track-color: transparent;
+      --scrollbar-track-hover-color: transparent;
+      --scrollbar-thumb-color: #888888;
+      --scrollbar-thumb-hover-color: #aaaaaa;
+    }
+
+    ::-webkit-scrollbar {
+      width: var(--scrollbar-size);
+      height: var(--scrollbar-size);
+      border-radius: 0;
+    }
+
+    ::-webkit-scrollbar-button {
+      display: none;
+    }
+
+    ::-webkit-scrollbar-button:hover {
+      display: none;
+    }
+
+    ::-webkit-scrollbar-thumb {
+      background-color: var(--scrollbar-thumb-color);
+      box-shadow: none;
+      border-radius: calc(var(--scrollbar-size) * 0.5);
+    }
+
+    ::-webkit-scrollbar-thumb:hover {
+      background-color: var(--scrollbar-thumb-hover-color);
+    }
+
+    ::-webkit-scrollbar-track {
+      background-color: var(--scrollbar-track-color);
+      border-radius: 0;
+    }
+
+    ::-webkit-scrollbar-track:hover {
+      background-color: var(--scrollbar-track-hover-color);
+    }
+
+  </style>
+  <script src="https://unpkg.com/@alenaksu/json-viewer@2.0.0/dist/json-viewer.bundle.js"><\/script>
+  <script>
+    document.addEventListener('DOMContentLoaded', () => {
+      const viewer = document.querySelector('#json-viewer');
+      viewer.data = ${JSON.stringify(info)};
+      viewer.expand(/headers|env/);
+    });
+  <\/script>
+</head>
+<body>
+  <json-viewer id="json-viewer"></json-viewer>
+</body>
+</html>`, {
+				status: 200,
+				headers: { "Content-Type": "text/html" }
+			});
+		} catch (error) {
+			console.log("getVarsHandler.error", error);
+			return getHandlerErrorResponse(error);
+		}
+	};
+}
+//#endregion
+//#region src/server/lazy.ts
+const LAZY_PROPS = {};
+async function withLazyProps(key, getComponentProps) {
+	LAZY_PROPS[key] = getComponentProps;
+}
+async function decorateLazyComponents(extraComponents) {
+	const context = await getContext();
+	const pageContext = await getPageContext();
+	const page = pageContext.page;
+	if (!page) return;
+	const components = [...page.components || [], ...extraComponents || []];
+	const decoratedComponents = [];
+	for (const component of components) {
+		const key = component.blockType || component.schema || "unkown_type";
+		const getComponentProps = LAZY_PROPS[key];
+		if (typeof getComponentProps === "function") {
+			const decoratedComponent = await getComponentProps({
+				...context,
+				...pageContext,
+				component
+			});
+			decoratedComponents.push(decoratedComponent);
+		} else decoratedComponents.push(component);
+	}
+	page.components = decoratedComponents;
+}
+//#endregion
+//#region src/server/metadata.ts
+/**
+* Returns a generateMetadata function for a given page collection slug.
+* Uses bowl's createPageContext (Payload local API) instead of the store abstraction.
+*/
+function getMetadata(slug, config) {
+	return async function generateMetadata(props, parent) {
+		const { market, locale, id } = await props.params;
+		const { page } = await createPageContext(market, locale, slug, id, config);
+		return {
+			title: page.meta?.title || page.title,
+			description: page.meta?.description || page.abstract
+		};
+	};
+}
+//#endregion
+//#region src/server/utmz.ts
+function getUtmz(request) {
+	let utmz = "N/A";
+	if (typeof request.cookies.__utmz === "string") {
+		utmz = request.cookies.__utmz;
+		const i = utmz.indexOf("utmcsr");
+		utmz = utmz.substring(i === -1 ? 0 : i);
+	}
+	return utmz;
+}
+//#endregion
+export { buildBaseOptions, collectionDeleteHandler, collectionGetHandler, collectionPatchHandler, collectionPostHandler, createLayoutContext, createNotFoundContext, createPageContext, decorateLazyComponents, filterRoutes, getAuthHeaders, getAuthMeHandler, getCacheKey, getCaptionsVTT, getContext, getHrefBeforeRedirect, getLocalApi, getMetadata, getMixerContext, getNextUrl, getOptions, getPage, getPageContext, getPayload, getPayloadInstance, getRegistry, getRegistryItem, getRouteHandler, getRoutes, getSearchParams, getSiteMapIndex, getSiteMapXML, getSiteMapXSL, getStaticParams, getStaticParamsFromPayload, getStaticParams_, getUtmz, getVarsHandler, indexGetHandler, previewHandler, setContext, setPageContext, withLazyProps };
+
+//# sourceMappingURL=server.js.map