@phtngyn/cms 0.2.0-beta.8 → 0.3.0

package/src/previewContext-dt3ZUh-w.js

@@ -0,0 +1,4 @@
+//#region src/internal/previewContext.ts
+const previewContextKey = Symbol("cms-preview-context");
+//#endregion
+export { previewContextKey as t };

package/src/previewRegions-CXjk5cbP.js

@@ -0,0 +1,145 @@
+import { o as parsePreviewSource, s as previewTargetKey } from "./PreviewFocus-C_EelZO5.js";
+//#region src/internal/blockRendering.ts
+const blockRenderingKey = Symbol("cms-block-rendering");
+/** References and slot projection share the installed block contract. */
+function blockRenderingCatalog(blocks) {
+	return new Map(blocks.map((definition) => [definition.name, {
+		definition,
+		inlineSlots: new Set(definition.slots.filter((slot) => slot.kind === "inline-text").map((slot) => slot.name))
+	}]));
+}
+//#endregion
+//#region src/internal/previewRegions.ts
+/** Keep an editor selection visible without moving an already visible preview. */
+function revealPreviewElement(element, viewport) {
+	const rect = element.getBoundingClientRect();
+	if (rect.bottom > 0 && rect.top < viewport.innerHeight && rect.right > 0 && rect.left < viewport.innerWidth) return;
+	element.scrollIntoView({
+		behavior: "instant",
+		block: "center",
+		inline: "nearest"
+	});
+}
+function renderedRegion(element) {
+	if (element.closest("[hidden]")) return false;
+	const view = element.ownerDocument.defaultView;
+	for (let ancestor = element; ancestor; ancestor = ancestor.parentElement) {
+		const style = view?.getComputedStyle(ancestor);
+		if (style?.display === "none" || style?.visibility === "hidden" || style?.visibility === "collapse") return false;
+	}
+	if (element.textContent?.trim() || element.matches("img, video, audio, iframe, input, textarea, select") || element.querySelector("img, video, audio, iframe, input, textarea, select")) return true;
+	const rect = element.getBoundingClientRect();
+	return rect.width > 0 && rect.height > 0;
+}
+function sourceRegions(root) {
+	const owner = root.ownerDocument ?? (root instanceof Document ? root : null);
+	if (!owner) return [];
+	const comments = owner.createTreeWalker(root, NodeFilter.SHOW_COMMENT);
+	const starts = /* @__PURE__ */ new Map();
+	const found = [];
+	while (comments.nextNode()) {
+		const node = comments.currentNode;
+		if (!(node instanceof Comment) || !node.data.startsWith("cms-source:")) continue;
+		const marker = /^cms-source:(.+):(start|end)$/u.exec(node.data);
+		const encoded = marker?.[1];
+		const source = parsePreviewSource(encoded ?? null);
+		if (!source || !encoded) continue;
+		if (marker?.[2] === "start") {
+			const stack = starts.get(encoded) ?? [];
+			stack.push(node);
+			starts.set(encoded, stack);
+		} else {
+			const start = starts.get(encoded)?.pop();
+			if (!start) continue;
+			const range = owner.createRange();
+			range.setStartAfter(start);
+			range.setEndBefore(node);
+			found.push({
+				source,
+				range
+			});
+		}
+	}
+	return found;
+}
+function sourceRegionElement(root, range) {
+	const common = range.commonAncestorContainer;
+	if (range.collapsed) return null;
+	const walker = (root.ownerDocument ?? (root instanceof Document ? root : null))?.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+	while (walker?.nextNode()) {
+		const node = walker.currentNode;
+		if (node instanceof Element && range.intersectsNode(node) && !node.contains(range.startContainer) && renderedRegion(node)) return node;
+	}
+	if (common instanceof Element && common !== root && !common.matches("[data-cms-document]") && range.cloneContents().textContent?.trim() && renderedRegion(common)) return common;
+	return null;
+}
+/** Resolve generated fields, fragment roots, rich-text nodes, and cross-document query output. */
+function previewSourceAt(root, clicked, documentId) {
+	let marked = clicked.closest("[data-cms-source]");
+	while (marked && documentId && parsePreviewSource(marked.getAttribute("data-cms-source"))?.documentId !== documentId) marked = marked.parentElement?.closest("[data-cms-source]") ?? null;
+	const markedSource = marked && root.contains(marked) ? parsePreviewSource(marked.getAttribute("data-cms-source")) : null;
+	let source = markedSource;
+	let containingRange = null;
+	for (const region of sourceRegions(root)) {
+		if (documentId && region.source.documentId !== documentId) continue;
+		if (!region.range.intersectsNode(clicked) || region.range.collapsed) continue;
+		const element = sourceRegionElement(root, region.range);
+		if (!element || clicked !== element && clicked.contains(element)) continue;
+		if (marked && markedSource && region.range.intersectsNode(marked) && !marked.contains(region.range.startContainer)) continue;
+		if (containingRange && (region.range.compareBoundaryPoints(Range.START_TO_START, containingRange) < 0 || region.range.compareBoundaryPoints(Range.END_TO_END, containingRange) > 0)) continue;
+		source = region.source.target.kind === "block" ? {
+			...region.source,
+			approximate: true
+		} : region.source;
+		containingRange = region.range;
+	}
+	return source;
+}
+/** Find an exact identity first, then a containing control, block, or document. */
+function previewMatchForSource(root, documentId, target) {
+	const marked = [...root.querySelectorAll("[data-cms-source]")].flatMap((element) => {
+		const source = parsePreviewSource(element.getAttribute("data-cms-source"));
+		return source?.documentId === documentId ? [{
+			element,
+			source
+		}] : [];
+	});
+	const regions = sourceRegions(root).filter((region) => region.source.documentId === documentId);
+	function match(candidate, exact) {
+		const key = previewTargetKey(candidate);
+		const element = marked.find((entry) => previewTargetKey(entry.source.target) === key && renderedRegion(entry.element));
+		if (element) return {
+			element: element.element,
+			exact: exact && !element.source.approximate
+		};
+		for (const region of regions) {
+			if (previewTargetKey(region.source.target) !== key) continue;
+			const element = sourceRegionElement(root, region.range);
+			if (element) return {
+				element,
+				exact: exact && !region.source.approximate
+			};
+		}
+		return null;
+	}
+	const exact = match(target, true);
+	if (exact) return exact;
+	if (target.kind === "field" || target.kind === "blockField") for (let length = target.path.length - 1; length > 0; length--) {
+		const parent = match({
+			...target,
+			path: target.path.slice(0, length)
+		}, false);
+		if (parent) return parent;
+	}
+	if (target.kind === "blockField" || target.kind === "body" && target.blockId) {
+		const blockId = target.blockId;
+		const block = blockId ? match({
+			kind: "block",
+			blockId
+		}, false) : null;
+		if (block) return block;
+	}
+	return match({ kind: "document" }, false);
+}
+//#endregion
+export { blockRenderingKey as a, blockRenderingCatalog as i, previewSourceAt as n, revealPreviewElement as r, previewMatchForSource as t };

package/src/previewSource-fb-q3ESM.js

@@ -0,0 +1,144 @@
+import { s as previewTargetKey } from "./PreviewFocus-C_EelZO5.js";
+import { Schema } from "effect";
+import { toRaw } from "vue";
+//#region src/internal/previewSource.ts
+/** Per-preview object provenance; authored values and public delivery stay untouched. */
+function createPreviewSources(collections = [], blocks = []) {
+	const origins = /* @__PURE__ */ new WeakMap();
+	function fields(values, definitions, documentId, blockId, path = []) {
+		const properties = /* @__PURE__ */ new Map();
+		if (!blockId && !path.length) properties.set("title", {
+			documentId,
+			target: { kind: "title" },
+			approximate: false
+		});
+		const fallback = {
+			documentId,
+			target: blockId ? {
+				kind: "block",
+				blockId
+			} : { kind: "document" },
+			approximate: true
+		};
+		for (const definition of definitions) {
+			const fieldPath = [...path, {
+				kind: "field",
+				name: definition.name
+			}];
+			const source = {
+				documentId,
+				target: blockId ? {
+					kind: "blockField",
+					blockId,
+					path: fieldPath
+				} : definition.name === "title" && !path.length ? { kind: "title" } : {
+					kind: "field",
+					path: fieldPath
+				},
+				approximate: false
+			};
+			properties.set(definition.name, source);
+			const value = values[definition.name];
+			if (definition.kind === "object" && Schema.is(Schema.JsonObject)(value)) fields(value, definition.fields, documentId, blockId, fieldPath);
+			else if (definition.kind === "list" && Array.isArray(value)) {
+				for (const item of value) {
+					if (!Schema.is(Schema.JsonObject)(item) || !Schema.is(Schema.NonEmptyString)(item.id)) continue;
+					fields(item, definition.fields, documentId, blockId, [...fieldPath, {
+						kind: "item",
+						id: item.id
+					}]);
+				}
+				origins.set(toRaw(value), {
+					source,
+					properties: /* @__PURE__ */ new Map()
+				});
+			} else if (value !== null && Schema.is(Schema.JsonObject)(value)) origins.set(toRaw(value), {
+				source,
+				properties: new Map(Object.keys(value).map((key) => [key, source]))
+			});
+		}
+		const target = path.length ? blockId ? {
+			kind: "blockField",
+			blockId,
+			path
+		} : {
+			kind: "field",
+			path
+		} : fallback.target;
+		origins.set(toRaw(values), {
+			source: {
+				documentId,
+				target,
+				approximate: path.length === 0
+			},
+			properties
+		});
+	}
+	function register(source, documentId, collection) {
+		const definitions = collections.find((candidate) => candidate.collection === collection)?.fields ?? [];
+		fields(source.fields, definitions, documentId);
+		origins.set(toRaw(source), {
+			source: {
+				documentId,
+				target: { kind: "document" },
+				approximate: true
+			},
+			properties: /* @__PURE__ */ new Map()
+		});
+	}
+	function document(value) {
+		const identity = value.identity;
+		const source = value.source;
+		register(source, identity.documentId, identity.collection);
+		origins.set(toRaw(value), {
+			source: {
+				documentId: identity.documentId,
+				target: { kind: "document" },
+				approximate: true
+			},
+			properties: /* @__PURE__ */ new Map()
+		});
+	}
+	function block(values, name, blockId, documentId) {
+		fields(values, blocks.find((candidate) => candidate.name === name)?.fields ?? [], documentId, blockId);
+		return Object.fromEntries(origins.get(toRaw(values))?.properties ?? []);
+	}
+	function property(value, name) {
+		if (!value || !Schema.is(Schema.JsonObject)(value)) return null;
+		return origins.get(toRaw(value))?.properties.get(name) ?? origins.get(toRaw(value))?.source ?? null;
+	}
+	function object(value) {
+		if (!value || !Schema.is(Schema.JsonObject)(value) && !Array.isArray(value)) return null;
+		return origins.get(toRaw(value))?.source ?? null;
+	}
+	return {
+		document,
+		register,
+		block,
+		property,
+		object
+	};
+}
+/** Ambiguous output always selects its common containing block or document. */
+function combinePreviewSources(sources) {
+	const available = sources.filter((source) => source !== null);
+	const first = available[0];
+	if (!first) return null;
+	if (available.every((source) => source.documentId === first.documentId && previewTargetKey(source.target) === previewTargetKey(first.target))) return {
+		...first,
+		approximate: available.some((source) => source.approximate)
+	};
+	if (available.some((source) => source.documentId !== first.documentId)) return null;
+	const blockId = first.target.kind === "block" || first.target.kind === "blockField" ? first.target.blockId : null;
+	const sameBlock = blockId && available.every((source) => (source.target.kind === "block" || source.target.kind === "blockField") && source.target.blockId === blockId);
+	return {
+		documentId: first.documentId,
+		target: sameBlock ? {
+			kind: "block",
+			blockId
+		} : { kind: "document" },
+		approximate: true
+	};
+}
+//#endregion
+export { createPreviewSources as n, combinePreviewSources as t };

package/src/rendering-D9LVeEKX.js

@@ -0,0 +1,47 @@
+import { i as MediaId, m as mediaPath, u as MediaSelection } from "./Media-DSyvd14o.js";
+import { n as safeLinkHref, t as LinkTarget } from "./Links-CJYyy7rC.js";
+import { a as imagePath } from "./Image-CJWPLnhP.js";
+import { Schema } from "effect";
+//#region src/internal/rendering.ts
+/** Stable Vue registration name for a configured site block. */
+function blockComponentName(name) {
+	return `CmsBlock${name.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("")}`;
+}
+/** Resolve authored references immediately before passing block props to a site component. */
+function resolveBlockProps(props, blockId, referencePaths, fields) {
+	function resolve(value, field, path) {
+		if (field.kind === "link" && Schema.is(LinkTarget)(value)) {
+			if (value.kind === "url") return safeLinkHref(value.href) ? value.href : "";
+			const destination = referencePaths[path] ?? value.path;
+			return destination.startsWith("/") && safeLinkHref(destination) ? destination : "";
+		}
+		if (field.kind === "media" && Schema.is(MediaSelection)(value)) return mediaPath(MediaId.make(value.mediaId));
+		if (field.kind === "list" && Array.isArray(value)) return value.map((item, index) => Schema.is(Schema.JsonObject)(item) ? resolveObject(item, field.fields, `${path}[${index}]`) : item);
+		if (field.kind === "object" && Schema.is(Schema.JsonObject)(value)) return resolveObject(value, field.fields, path);
+		return value;
+	}
+	function resolveObject(values, definitions, path) {
+		const resolved = Object.assign({}, values);
+		for (const field of definitions) {
+			const value = values[field.name];
+			if (value !== void 0) resolved[field.name] = resolve(value, field, `${path}.${field.name}`);
+		}
+		return resolved;
+	}
+	return resolveObject(props, fields, `body.${blockId}`);
+}
+const widths = [
+	640,
+	1280,
+	1920
+];
+/** Use the same bounded delivery policy for body and structured images. */
+function responsiveImageSrcSet(mediaId) {
+	return widths.map((width) => `${imagePath(mediaId, {
+		width,
+		format: "webp",
+		quality: 80
+	})} ${width}w`).join(", ");
+}
+//#endregion
+export { resolveBlockProps as n, responsiveImageSrcSet as r, blockComponentName as t };

package/src/rolldown-runtime-8H4AJuhK.js

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/src/runtime/CmsImage.js

@@ -0,0 +1,38 @@
+import { i as MediaId, m as mediaPath } from "../Media-DSyvd14o.js";
+import { i as imageAspectRatio, o as imagePlacementStyle, t as AuthoredImage } from "../Image-CJWPLnhP.js";
+import { r as responsiveImageSrcSet } from "../rendering-D9LVeEKX.js";
+import { Schema } from "effect";
+import { defineComponent, h } from "vue";
+//#region src/runtime/CmsImage.ts
+var CmsImage_default = defineComponent({
+	name: "CmsImage",
+	props: {
+		image: {
+			type: Object,
+			default: void 0
+		},
+		sizes: {
+			type: String,
+			default: "100vw"
+		}
+	},
+	setup(props) {
+		return () => {
+			const image = Schema.is(AuthoredImage)(props.image) ? props.image : void 0;
+			return h("div", {
+				class: "relative block overflow-hidden",
+				style: { aspectRatio: String(imageAspectRatio(image?.frame)) }
+			}, image ? h("img", {
+				src: mediaPath(MediaId.make(image.mediaId)),
+				srcset: responsiveImageSrcSet(MediaId.make(image.mediaId)),
+				sizes: props.sizes,
+				alt: image.alt ?? "",
+				loading: "lazy",
+				class: "absolute inset-0 size-full max-w-none",
+				style: imagePlacementStyle(image)
+			}) : void 0);
+		};
+	}
+});
+//#endregion
+export { CmsImage_default as default };

package/src/runtime/DocumentPage.vue

@@ -0,0 +1,10 @@
+<script setup lang="ts">
+import { definePageMeta } from '#imports'
+import DocumentPageContent from './DocumentPageContent'
+
+definePageMeta({ key: (route) => route.fullPath })
+</script>
+
+<template>
+  <DocumentPageContent :key="$route.fullPath" />
+</template>

package/src/runtime/DocumentPageContent.js

@@ -0,0 +1,48 @@
+import { f as revisionPreviewRequested } from "../RevisionPreview-IVwbJ9Wy.js";
+import { t as DocumentRenderer_default } from "../DocumentRenderer-Wz2xaNyf.js";
+import { i as revisionPreviewDestination, r as useCmsDocumentSeo, t as useCmsDocument } from "../nuxtDelivery-BYX_Cddb.js";
+import { n as previewDocumentId, r as previewDocumentQueryKey, t as decodeLocaleConfiguration } from "../localeConfiguration-BPbkLi7-.js";
+import "./delivery/useCmsDocument.js";
+import "./delivery/useCmsDocumentSeo.js";
+import { h } from "vue";
+import { createError, defineNuxtComponent, navigateTo, useNuxtApp, useRouter, useRuntimeConfig } from "nuxt/app";
+//#region src/runtime/DocumentPageContent.ts
+var DocumentPageContent_default = defineNuxtComponent({
+	name: "CmsDocumentPage",
+	async setup() {
+		const nuxtApp = useNuxtApp();
+		const route = useRouter().currentRoute.value;
+		const previewId = previewDocumentId(route.query[previewDocumentQueryKey]);
+		const savedPreview = revisionPreviewRequested(route);
+		const locales = decodeLocaleConfiguration(useRuntimeConfig().public.cmsLocales);
+		const request = await useCmsDocument(() => route.path);
+		if (request.error.value || !request.data.value) throw createError({
+			statusCode: request.error.value?.status ?? 404,
+			statusMessage: previewId || savedPreview ? "Preview unavailable" : "Document not found"
+		});
+		const delivered = request.data.value;
+		if ("redirectTo" in delivered) {
+			await navigateTo(`${delivered.redirectTo}${route.fullPath.slice(route.path.length)}`, {
+				redirectCode: 301,
+				replace: true
+			});
+			return () => void 0;
+		}
+		if (!previewId && !savedPreview && delivered.draft) throw createError({
+			statusCode: 503,
+			statusMessage: "Public document unavailable"
+		});
+		const destination = revisionPreviewDestination(delivered, route, locales);
+		if (destination) {
+			await navigateTo(destination, {
+				redirectCode: 302,
+				replace: true
+			});
+			return () => void 0;
+		}
+		await nuxtApp.runWithContext(() => useCmsDocumentSeo(delivered));
+		return () => h(DocumentRenderer_default, { value: delivered });
+	}
+});
+//#endregion
+export { DocumentPageContent_default as default };

package/src/runtime/DocumentRenderer.d.ts

@@ -0,0 +1,129 @@
+import { n as FormDefinition } from "../Forms-BuKAXQxr.js";
+import { n as DocumentSource } from "../Document-TgwYKJZM.js";
+import { r as DeliveredQueryItem, t as DeliveredDocument } from "../forms-3xuf0Ym7.js";
+import { Schema } from "effect";
+import { PropType } from "vue";
+//#region ../model/src/PreviewFocus.d.ts
+declare const PreviewFocusTarget: Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"title">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"document">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"field">;
+  readonly path: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"field">;
+    readonly name: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"item">;
+    readonly id: Schema.NonEmptyString;
+  }>]>>;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"blockField">;
+  readonly blockId: Schema.NonEmptyString;
+  readonly path: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"field">;
+    readonly name: Schema.NonEmptyString;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"item">;
+    readonly id: Schema.NonEmptyString;
+  }>]>>;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"block">;
+  readonly blockId: Schema.NonEmptyString;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"body">;
+  readonly path: Schema.$Array<Schema.Int>;
+  readonly nodeId: Schema.optionalKey<Schema.NonEmptyString>;
+  readonly blockId: Schema.optionalKey<Schema.NonEmptyString>;
+}>]>;
+type PreviewFocusTarget = typeof PreviewFocusTarget.Type;
+//#endregion
+//#region src/runtime/DocumentRenderer.d.ts
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  value: {
+    type: PropType<DeliveredDocument | DeliveredQueryItem>;
+  };
+  source: {
+    type: PropType<DocumentSource>;
+  };
+  documentId: {
+    type: StringConstructor;
+  };
+  forms: {
+    type: PropType<ReadonlyArray<FormDefinition>>;
+  };
+  formBlockNames: {
+    type: PropType<ReadonlyArray<string>>;
+  };
+  referencePaths: {
+    type: PropType<Readonly<Record<string, string>>>;
+  };
+  previewFocus: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  focusTarget: (_target: PreviewFocusTarget) => true;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  value: {
+    type: PropType<DeliveredDocument | DeliveredQueryItem>;
+  };
+  source: {
+    type: PropType<DocumentSource>;
+  };
+  documentId: {
+    type: StringConstructor;
+  };
+  forms: {
+    type: PropType<ReadonlyArray<FormDefinition>>;
+  };
+  formBlockNames: {
+    type: PropType<ReadonlyArray<string>>;
+  };
+  referencePaths: {
+    type: PropType<Readonly<Record<string, string>>>;
+  };
+  previewFocus: {
+    type: BooleanConstructor;
+    default: undefined;
+  };
+}>> & Readonly<{
+  onFocusTarget?: ((_target: {
+    readonly kind: "title";
+  } | {
+    readonly kind: "document";
+  } | {
+    readonly kind: "field";
+    readonly path: readonly ({
+      readonly kind: "field";
+      readonly name: string;
+    } | {
+      readonly kind: "item";
+      readonly id: string;
+    })[];
+  } | {
+    readonly kind: "blockField";
+    readonly blockId: string;
+    readonly path: readonly ({
+      readonly kind: "field";
+      readonly name: string;
+    } | {
+      readonly kind: "item";
+      readonly id: string;
+    })[];
+  } | {
+    readonly kind: "block";
+    readonly blockId: string;
+  } | {
+    readonly kind: "body";
+    readonly path: readonly number[];
+    readonly blockId?: string | undefined;
+    readonly nodeId?: string | undefined;
+  }) => any) | undefined;
+}>, {
+  previewFocus: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+//#endregion
+export { _default as default };

package/src/runtime/DocumentRenderer.js

@@ -0,0 +1,2 @@
+import { t as DocumentRenderer_default } from "../DocumentRenderer-Wz2xaNyf.js";
+export { DocumentRenderer_default as default };

package/src/runtime/api.js

@@ -1,9 +1,51 @@
-import { useCmsInstallation } from "./plugin.js";
-import { defineEventHandler, toWebRequest } from "h3";
-
+import { n as fetchCmsRequest } from "../plugin-DTYuDaQu.js";
+import { r as RuntimeConfiguration } from "../Config-CMiwciub.js";
+import { Schema } from "effect";
+import { defineEventHandler } from "nuxt/server";
+import { useRuntimeConfig } from "nitro/runtime-config";
+import { isIP } from "node:net";
+import { getRequestIP } from "nitro/h3";
+//#region src/internal/trustedClientIp.ts
+var InvalidClientIp = class extends Error {};
+/** Builds the only client-IP header Better Auth may trust from the network peer. */
+function withTrustedClientIp(request, peerAddress, trustedProxies) {
+	const headers = new Headers(request.headers);
+	headers.delete("x-cms-client-ip");
+	const clientIp = resolveTrustedClientIp(peerAddress, request.headers.get("x-forwarded-for"), trustedProxies);
+	if (clientIp) headers.set("x-cms-client-ip", clientIp);
+	const body = request.body;
+	const options = {
+		method: request.method,
+		headers,
+		body,
+		signal: request.signal
+	};
+	if (body) Object.assign(options, { duplex: "half" });
+	return new Request(request.url, options);
+}
+function resolveTrustedClientIp(peerAddress, forwardedFor, trustedProxies) {
+	if (!peerAddress || !isIP(peerAddress)) return void 0;
+	const peer = normalizeMappedAddress(peerAddress);
+	if (!trustedProxies.split(",").map((value) => normalizeMappedAddress(value.trim())).includes(peer)) return peer;
+	const forwarded = forwardedFor?.trim();
+	if (!forwarded || !isIP(forwarded)) throw new InvalidClientIp("Trusted proxy must supply one valid client IP.");
+	return normalizeMappedAddress(forwarded);
+}
+function normalizeMappedAddress(address) {
+	return address.startsWith("::ffff:") && isIP(address.slice(7)) === 4 ? address.slice(7) : address;
+}
+//#endregion
 //#region src/runtime/api.ts
-var api_default = defineEventHandler((event) => useCmsInstallation().then((installation) => installation.fetch(toWebRequest(event))));
-
+var api_default = defineEventHandler((event) => {
+	if (event.req.method === "GET" && new URL(event.req.url).pathname === "/_cms/health/ready") return fetchCmsRequest(event.req);
+	try {
+		const trustedProxies = Schema.decodeUnknownSync(RuntimeConfiguration.fields.trustedProxyIps)(useRuntimeConfig().cms.trustedProxyIps);
+		const request = withTrustedClientIp(event.req, getRequestIP(event), trustedProxies);
+		return fetchCmsRequest(request);
+	} catch (cause) {
+		if (cause instanceof InvalidClientIp) return Response.json({ error: cause.message }, { status: 400 });
+		throw cause;
+	}
+});
 //#endregion
 export { api_default as default };
-//# sourceMappingURL=api.js.map

package/src/runtime/delivery/useCmsDocument.js

@@ -0,0 +1,2 @@
+import { t as useCmsDocument } from "../../nuxtDelivery-BYX_Cddb.js";
+export { useCmsDocument };

package/src/runtime/delivery/useCmsDocumentQuery.js

@@ -0,0 +1,2 @@
+import { n as useCmsDocumentQuery } from "../../nuxtDelivery-BYX_Cddb.js";
+export { useCmsDocumentQuery };