@rimelight/cms 0.0.3 → 0.0.5

package/dist/index.mjs

@@ -0,0 +1,2382 @@
+import { bylines, contentSearchIndex, pageDraftLocks, pageDrafts, pageTaxonomyTerms, pageTemplates, pageVersionApprovals, pageVersionComments, pageVersions, pages, siteSettings, taxonomyTerms } from "./schema/index.mjs";
+import { rimelightCms } from "./integration.mjs";
+import { deleteR2File, getR2Bucket, listR2Files, r2, uploadR2File } from "./storage/index.mjs";
+import { auth0Auth, cfAccessAuth, evaluateAccess, hasPermission, hasRole, mockAuth } from "@rimelight/auth";
+import { and, asc, desc, eq, isNotNull, isNull, lt, lte, or, sql } from "drizzle-orm";
+import { addToast, clearToasts, removeToast, showErrorToast, showSuccessToast, toast, toasts } from "@rimelight/ui/components/toast/store.ts";
+//#region src/core/types/blocks.ts
+const MIN_SECTION_HEADING_LEVEL = 2;
+const MAX_SECTION_HEADING_LEVEL = 6;
+const MAX_SECTION_DEPTH = 4;
+function calculateHeadingLevel(sectionDepth) {
+	return Math.min(6, Math.max(0, Math.floor(sectionDepth || 0)) + 2);
+}
+const ALLOWED_CHILDREN_MAP = {
+	Root: [
+		"SectionBlock",
+		"ParagraphBlock",
+		"CalloutBlock",
+		"ImageBlock",
+		"CodeBlock",
+		"ScriptBlock",
+		"SceneBlock",
+		"DialogueBlock",
+		"TableBlock",
+		"TabsBlock",
+		"StepsBlock",
+		"CardsBlock",
+		"FileTreeBlock",
+		"ComponentShowcaseBlock",
+		"ApiDocumentationBlock",
+		"LivePreviewBlock"
+	],
+	SectionBlock: [
+		"SectionBlock",
+		"ParagraphBlock",
+		"CalloutBlock",
+		"ImageBlock",
+		"CodeBlock",
+		"ScriptBlock",
+		"TableBlock",
+		"TabsBlock",
+		"StepsBlock",
+		"CardsBlock",
+		"FileTreeBlock",
+		"ComponentShowcaseBlock",
+		"ApiDocumentationBlock",
+		"LivePreviewBlock"
+	],
+	CalloutBlock: [
+		"ParagraphBlock",
+		"CalloutBlock",
+		"ImageBlock",
+		"CodeBlock",
+		"TableBlock",
+		"TabsBlock",
+		"StepsBlock",
+		"CardsBlock",
+		"FileTreeBlock",
+		"ComponentShowcaseBlock",
+		"ApiDocumentationBlock",
+		"LivePreviewBlock"
+	],
+	TabsBlock: ["TabItemBlock"],
+	TabItemBlock: [
+		"ParagraphBlock",
+		"CalloutBlock",
+		"ImageBlock",
+		"CodeBlock",
+		"TableBlock",
+		"StepsBlock",
+		"CardsBlock",
+		"FileTreeBlock",
+		"ComponentShowcaseBlock",
+		"ApiDocumentationBlock",
+		"LivePreviewBlock"
+	],
+	StepsBlock: ["StepItemBlock"],
+	StepItemBlock: [
+		"ParagraphBlock",
+		"CalloutBlock",
+		"ImageBlock",
+		"CodeBlock",
+		"TableBlock",
+		"TabsBlock",
+		"CardsBlock",
+		"FileTreeBlock",
+		"ComponentShowcaseBlock",
+		"ApiDocumentationBlock",
+		"LivePreviewBlock"
+	],
+	CardsBlock: ["CardBlock"],
+	ScriptBlock: ["SceneBlock"],
+	SceneBlock: [
+		"ParagraphBlock",
+		"CalloutBlock",
+		"DialogueBlock"
+	]
+};
+//#endregion
+//#region src/core/page-definitions.ts
+function uuid() {
+	return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2, 11);
+}
+function definePageDefinition(def) {
+	return def;
+}
+const DOCUMENT_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.document",
+	properties: {}
+});
+const BLOG_POST_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.blogPost",
+	properties: { meta: {
+		label: { en: "Post Metadata" },
+		defaultOpen: true,
+		fields: {
+			category: {
+				type: "enum",
+				label: { en: "Category" },
+				defaultValue: { en: "Company News" },
+				options: [
+					{ en: "Company News" },
+					{ en: "Development Log" },
+					{ en: "New Release" }
+				]
+			},
+			publishedAt: {
+				type: "text",
+				label: { en: "Published At" },
+				defaultValue: { en: "" }
+			},
+			author: {
+				type: "text",
+				label: { en: "Author" },
+				defaultValue: { en: "" }
+			}
+		}
+	} }
+});
+const PATCH_NOTE_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.patchNote",
+	properties: { version: {
+		label: { en: "Version Info" },
+		defaultOpen: true,
+		fields: {
+			versionNumber: {
+				type: "text",
+				label: { en: "Version Number" },
+				defaultValue: "1.0.0"
+			},
+			releaseDate: {
+				type: "text",
+				label: { en: "Release Date" },
+				defaultValue: { en: "" }
+			}
+		}
+	} }
+});
+const LOCATION_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.location",
+	properties: { geography: {
+		label: { en: "Geography" },
+		defaultOpen: true,
+		fields: {
+			region: {
+				type: "text",
+				label: { en: "Region" },
+				defaultValue: { en: "" }
+			},
+			climate: {
+				type: "text",
+				label: { en: "Climate" },
+				defaultValue: "Temperate"
+			}
+		}
+	} }
+});
+const SPECIES_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.species",
+	properties: { biology: {
+		label: { en: "Biology" },
+		defaultOpen: true,
+		fields: {
+			lifespan: {
+				type: "text",
+				label: { en: "Average Lifespan" },
+				defaultValue: { en: "" }
+			},
+			homeworld: {
+				type: "page",
+				label: { en: "Homeworld" },
+				defaultValue: "",
+				allowedPageTypes: ["Location"]
+			}
+		}
+	} }
+});
+const CHARACTER_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.character",
+	properties: {
+		identity: {
+			label: { en: "Identity" },
+			defaultOpen: true,
+			fields: {
+				name: {
+					type: "text",
+					label: { en: "Name" },
+					defaultValue: { en: "" }
+				},
+				title: {
+					type: "text",
+					label: { en: "Title" },
+					defaultValue: { en: "" }
+				},
+				aliases: {
+					type: "text-array",
+					label: { en: "Aliases" },
+					defaultValue: []
+				},
+				pronouns: {
+					type: "enum",
+					label: { en: "Pronouns" },
+					defaultValue: { en: "Unknown" },
+					options: [
+						{ en: "He/Him" },
+						{ en: "She/Her" },
+						{ en: "They/Them" },
+						{ en: "He/They" },
+						{ en: "She/They" },
+						{ en: "Other" },
+						{ en: "Unknown" }
+					]
+				},
+				flavourText: {
+					type: "text",
+					label: { en: "Flavour Text" },
+					defaultValue: { en: "" }
+				}
+			}
+		},
+		characteristics: {
+			label: { en: "Characteristics" },
+			defaultOpen: true,
+			fields: {
+				species: {
+					type: "page",
+					label: { en: "Species" },
+					defaultValue: "",
+					allowedPageTypes: ["Species"]
+				},
+				sex: {
+					type: "enum",
+					label: { en: "Sex" },
+					defaultValue: { en: "Unknown" },
+					options: [
+						{ en: "Male" },
+						{ en: "Female" },
+						{ en: "Other" },
+						{ en: "Unknown" }
+					]
+				},
+				height: {
+					type: "number",
+					label: { en: "Height" },
+					defaultValue: 0
+				},
+				weight: {
+					type: "number",
+					label: { en: "Weight" },
+					defaultValue: 0
+				},
+				dateOfBirth: {
+					type: "text",
+					label: { en: "Date of Birth" },
+					defaultValue: { en: "" }
+				},
+				placeOfBirth: {
+					type: "text",
+					label: { en: "Place of Birth" },
+					defaultValue: { en: "" }
+				},
+				dateOfDeath: {
+					type: "text",
+					label: { en: "Date of Death" },
+					defaultValue: { en: "" }
+				},
+				placeOfDeath: {
+					type: "text",
+					label: { en: "Place of Death" },
+					defaultValue: { en: "" }
+				}
+			}
+		},
+		inventory: {
+			label: { en: "Inventory & Assets" },
+			defaultOpen: false,
+			fields: {
+				equipment: {
+					type: "page-array",
+					label: { en: "Equipment" },
+					defaultValue: [],
+					allowedPageTypes: ["Object"]
+				},
+				pets: {
+					type: "page-array",
+					label: { en: "Pets" },
+					defaultValue: [],
+					allowedPageTypes: ["Character"]
+				},
+				mounts: {
+					type: "page-array",
+					label: { en: "Mounts" },
+					defaultValue: [],
+					allowedPageTypes: ["Character"]
+				}
+			}
+		},
+		affiliations: {
+			label: { en: "Affiliations" },
+			defaultOpen: false,
+			fields: {
+				currentAffiliations: {
+					type: "page-array",
+					label: { en: "Current Affiliations" },
+					defaultValue: [],
+					allowedPageTypes: ["Group"]
+				},
+				formerAffiliations: {
+					type: "page-array",
+					label: { en: "Former Affiliations" },
+					defaultValue: [],
+					allowedPageTypes: ["Group"]
+				}
+			}
+		},
+		other: {
+			label: { en: "Other" },
+			defaultOpen: false,
+			fields: { favouriteFood: {
+				type: "page",
+				label: { en: "Favourite Food" },
+				defaultValue: "",
+				allowedPageTypes: ["Object"]
+			} }
+		}
+	},
+	initialBlocks: () => [
+		{
+			id: uuid(),
+			type: "SectionBlock",
+			props: {
+				level: 2,
+				title: "Appearance",
+				children: []
+			},
+			isTemplated: true
+		},
+		{
+			id: uuid(),
+			type: "SectionBlock",
+			props: {
+				level: 2,
+				title: "Abilities",
+				children: []
+			},
+			isTemplated: true
+		},
+		{
+			id: uuid(),
+			type: "SectionBlock",
+			props: {
+				level: 2,
+				title: "History",
+				children: []
+			},
+			isTemplated: true
+		}
+	]
+});
+const SKILL_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.skill",
+	properties: { mechanics: {
+		label: { en: "Mechanics" },
+		defaultOpen: true,
+		fields: {
+			cooldown: {
+				type: "number",
+				label: { en: "Cooldown (sec)" },
+				defaultValue: 10
+			},
+			manaCost: {
+				type: "number",
+				label: { en: "Mana Cost" },
+				defaultValue: 50
+			},
+			damageType: {
+				type: "enum",
+				label: { en: "Damage Type" },
+				defaultValue: { en: "Physical" },
+				options: [
+					{ en: "Physical" },
+					{ en: "Magic" },
+					{ en: "True" },
+					{ en: "None" }
+				]
+			}
+		}
+	} }
+});
+const ITEM_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.item",
+	properties: { details: {
+		label: { en: "Item Details" },
+		defaultOpen: true,
+		fields: {
+			rarity: {
+				type: "enum",
+				label: { en: "Rarity" },
+				defaultValue: { en: "Common" },
+				options: [
+					{ en: "Common" },
+					{ en: "Uncommon" },
+					{ en: "Rare" },
+					{ en: "Epic" },
+					{ en: "Legendary" }
+				]
+			},
+			price: {
+				type: "number",
+				label: { en: "Gold Price" },
+				defaultValue: 100
+			},
+			isQuestItem: {
+				type: "enum",
+				label: { en: "Quest Item" },
+				defaultValue: { en: "No" },
+				options: [{ en: "Yes" }, { en: "No" }]
+			}
+		}
+	} }
+});
+const OBJECT_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.object",
+	properties: { details: {
+		label: { en: "Object Details" },
+		defaultOpen: true,
+		fields: { category: {
+			type: "text",
+			label: { en: "Category" },
+			defaultValue: { en: "Miscellaneous" }
+		} }
+	} }
+});
+const GROUP_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.group",
+	properties: { details: {
+		label: { en: "Group Details" },
+		defaultOpen: true,
+		fields: {
+			leader: {
+				type: "page",
+				label: { en: "Leader" },
+				defaultValue: "",
+				allowedPageTypes: ["Character"]
+			},
+			headquarters: {
+				type: "page",
+				label: { en: "Headquarters" },
+				defaultValue: "",
+				allowedPageTypes: ["Location"]
+			}
+		}
+	} }
+});
+const HERO_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.hero",
+	properties: {
+		combat: {
+			label: { en: "Combat Stats" },
+			defaultOpen: true,
+			fields: {
+				class: {
+					type: "enum",
+					label: { en: "Class" },
+					defaultValue: { en: "Warrior" },
+					options: [
+						{ en: "Warrior" },
+						{ en: "Mage" },
+						{ en: "Rogue" },
+						{ en: "Paladin" }
+					]
+				},
+				difficulty: {
+					type: "number",
+					label: { en: "Difficulty" },
+					defaultValue: 1
+				},
+				primaryRole: {
+					type: "enum",
+					label: { en: "Primary Role" },
+					defaultValue: { en: "Tank" },
+					options: [
+						{ en: "Tank" },
+						{ en: "DPS" },
+						{ en: "Support" }
+					]
+				}
+			}
+		},
+		progression: {
+			label: { en: "Progression" },
+			defaultOpen: true,
+			fields: {
+				baseHp: {
+					type: "number",
+					label: { en: "Base HP" },
+					defaultValue: 500
+				},
+				baseMana: {
+					type: "number",
+					label: { en: "Base Mana" },
+					defaultValue: 100
+				}
+			}
+		}
+	},
+	initialBlocks: () => [{
+		id: uuid(),
+		type: "SectionBlock",
+		props: {
+			level: 2,
+			title: "Playstyle",
+			children: []
+		},
+		isTemplated: true
+	}, {
+		id: uuid(),
+		type: "SectionBlock",
+		props: {
+			level: 2,
+			title: "Background Lore",
+			children: []
+		},
+		isTemplated: true
+	}]
+});
+const CARD_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.card",
+	properties: {},
+	initialBlocks: () => []
+});
+const SERIES_DEFINITION = definePageDefinition({
+	typeLabelKey: "page.type.series",
+	properties: { details: {
+		label: { en: "Details" },
+		defaultOpen: true,
+		fields: {
+			genre: {
+				type: "text",
+				label: { en: "Genre" },
+				defaultValue: { en: "Fantasy" }
+			},
+			status: {
+				type: "enum",
+				label: { en: "Status" },
+				defaultValue: { en: "In Development" },
+				options: [
+					{ en: "In Development" },
+					{ en: "Ongoing" },
+					{ en: "Completed" },
+					{ en: "Cancelled" }
+				]
+			},
+			seasons: {
+				type: "number",
+				label: { en: "Seasons" },
+				defaultValue: 1
+			}
+		}
+	} },
+	initialBlocks: () => [{
+		id: uuid(),
+		type: "SectionBlock",
+		props: {
+			level: 2,
+			title: "Overview",
+			children: []
+		},
+		isTemplated: true
+	}, {
+		id: uuid(),
+		type: "SectionBlock",
+		props: {
+			level: 2,
+			title: "Seasons",
+			children: []
+		},
+		isTemplated: true
+	}]
+});
+const PAGE_MAP = {
+	Document: DOCUMENT_DEFINITION,
+	BlogPost: BLOG_POST_DEFINITION,
+	PatchNote: PATCH_NOTE_DEFINITION,
+	Location: LOCATION_DEFINITION,
+	Species: SPECIES_DEFINITION,
+	Character: CHARACTER_DEFINITION,
+	Skill: SKILL_DEFINITION,
+	Item: ITEM_DEFINITION,
+	Object: OBJECT_DEFINITION,
+	Group: GROUP_DEFINITION,
+	Card: CARD_DEFINITION,
+	Hero: HERO_DEFINITION,
+	Series: SERIES_DEFINITION,
+	Tale: definePageDefinition({
+		typeLabelKey: "page.type.tale",
+		properties: {}
+	}),
+	Episode: definePageDefinition({
+		typeLabelKey: "page.type.episode",
+		properties: {}
+	}),
+	Default: definePageDefinition({
+		typeLabelKey: "page.type.default",
+		properties: {}
+	})
+};
+function getPageDefinition(type) {
+	if (!type) return PAGE_MAP["Default"];
+	if (PAGE_MAP[type]) return PAGE_MAP[type];
+	const normalized = type.toLowerCase().replace(/[^a-z0-9]/g, "");
+	const ALIAS_MAP = {
+		blog: BLOG_POST_DEFINITION,
+		blogpost: BLOG_POST_DEFINITION,
+		article: BLOG_POST_DEFINITION,
+		doc: DOCUMENT_DEFINITION,
+		document: DOCUMENT_DEFINITION,
+		patchnote: PATCH_NOTE_DEFINITION,
+		location: LOCATION_DEFINITION,
+		species: SPECIES_DEFINITION,
+		character: CHARACTER_DEFINITION,
+		skill: SKILL_DEFINITION,
+		item: ITEM_DEFINITION,
+		object: OBJECT_DEFINITION,
+		group: GROUP_DEFINITION,
+		card: CARD_DEFINITION,
+		hero: HERO_DEFINITION,
+		series: SERIES_DEFINITION
+	};
+	if (ALIAS_MAP[normalized]) return ALIAS_MAP[normalized];
+	for (const [key, def] of Object.entries(PAGE_MAP)) if (key.toLowerCase() === normalized) return def;
+	return PAGE_MAP["Default"];
+}
+//#endregion
+//#region src/markdown/serializer.ts
+function inlinesToMarkdown(inlines) {
+	if (!inlines) return "";
+	if (typeof inlines === "string") return inlines;
+	if (!Array.isArray(inlines)) return inlines.en || "";
+	return inlines.map((node) => {
+		if (node.type === "text") {
+			let text = node.text || "";
+			const marks = node.marks || [];
+			if (marks.includes("code")) text = `\`${text}\``;
+			if (marks.includes("bold")) text = `**${text}**`;
+			if (marks.includes("italic")) text = `*${text}*`;
+			if (marks.includes("strikethrough")) text = `~~${text}~~`;
+			return text;
+		}
+		if (node.type === "link") {
+			const link = node;
+			return `[${(link.children || []).map((c) => c.text).join("") || link.url}](${link.url})`;
+		}
+		if (node.type === "page_mention") return `[${node.displayTitle || node.pageSlug || "Page"}](/${node.pageSlug || ""})`;
+		return "";
+	}).join("");
+}
+function blocksToMarkdown(blocks = [], options = {}) {
+	if (!Array.isArray(blocks) || blocks.length === 0) return "";
+	const baseLevel = options.sectionLevel ?? 2;
+	const lines = [];
+	for (const block of blocks) {
+		if (!block) continue;
+		const children = block.children || block.props?.["children"] || [];
+		switch (block.type) {
+			case "SectionBlock": {
+				const level = block.props?.["level"] || baseLevel;
+				const hashes = "#".repeat(Math.min(6, Math.max(1, level)));
+				const title = block.props?.["title"] || "";
+				if (title) lines.push(`${hashes} ${title}`);
+				if (block.props?.["description"]) lines.push(`_${block.props["description"]}_`);
+				if (children.length > 0) lines.push(blocksToMarkdown(children, { sectionLevel: Math.min(6, level + 1) }));
+				break;
+			}
+			case "ParagraphBlock": {
+				const text = inlinesToMarkdown(block.props?.["text"]);
+				if (text) lines.push(text);
+				break;
+			}
+			case "CalloutBlock": {
+				const variant = (block.props?.["variant"] || "info").toUpperCase();
+				const childMd = blocksToMarkdown(children, options);
+				const calloutHeader = `> [!${variant}]`;
+				if (childMd) {
+					const indented = childMd.split("\n").map((l) => l.trim() ? `> ${l}` : `>`).join("\n");
+					lines.push(`${calloutHeader}\n${indented}`);
+				} else lines.push(calloutHeader);
+				break;
+			}
+			case "CodeBlock": {
+				const lang = block.props?.["language"] || "";
+				const code = block.props?.["code"] || "";
+				const caption = block.props?.["caption"] ? `\n_${block.props["caption"]}_` : "";
+				lines.push(`\`\`\`${lang}\n${code}\n\`\`\`${caption}`);
+				break;
+			}
+			case "TableBlock": {
+				const columns = block.props?.["columns"] || [];
+				const rows = block.props?.["rows"] || [];
+				if (columns.length > 0) {
+					const tableMd = [
+						`| ${columns.map((c) => c.header || c.key).join(" | ")} |`,
+						`| ${columns.map((c) => {
+							if (c.align === "center") return ":---:";
+							if (c.align === "right") return "---:";
+							return "---";
+						}).join(" | ")} |`,
+						...rows.map((r) => `| ${columns.map((c) => r[c.key] || "").join(" | ")} |`)
+					].join("\n");
+					const caption = block.props?.["caption"] ? `\n_${block.props["caption"]}_` : "";
+					lines.push(`${tableMd}${caption}`);
+				}
+				break;
+			}
+			case "ImageBlock": {
+				const alt = block.props?.["alt"] || "";
+				const src = block.props?.["src"] || "";
+				const caption = block.props?.["caption"] ? `\n_${block.props["caption"]}_` : "";
+				lines.push(`![${alt}](${src})${caption}`);
+				break;
+			}
+			case "TabsBlock":
+				for (const tab of children) {
+					const tabLabel = tab.props?.label || "Tab";
+					const tabChildren = tab.children || tab.props?.children || [];
+					lines.push(`#### ${tabLabel}\n\n${blocksToMarkdown(tabChildren, options)}`);
+				}
+				break;
+			case "TabItemBlock": {
+				const label = block.props?.["label"] || "Tab";
+				lines.push(`#### ${label}\n\n${blocksToMarkdown(children, options)}`);
+				break;
+			}
+			case "StepsBlock": {
+				let stepIndex = 1;
+				for (const step of children) {
+					const title = step.props?.title || `Step ${stepIndex}`;
+					const desc = step.props?.description ? ` - ${step.props.description}` : "";
+					const stepChildren = step.children || step.props?.children || [];
+					lines.push(`${stepIndex}. **${title}**${desc}`);
+					if (stepChildren.length > 0) lines.push(blocksToMarkdown(stepChildren, options));
+					stepIndex++;
+				}
+				break;
+			}
+			case "StepItemBlock": {
+				const title = block.props?.["title"] || "Step";
+				const desc = block.props?.["description"] ? ` - ${block.props["description"]}` : "";
+				lines.push(`- **${title}**${desc}`);
+				if (children.length > 0) lines.push(blocksToMarkdown(children, options));
+				break;
+			}
+			case "CardsBlock":
+				for (const card of children) {
+					const title = card.props?.title || "";
+					const href = card.props?.href || "#";
+					const desc = card.props?.description ? `: ${card.props.description}` : "";
+					lines.push(`- [${title}](${href})${desc}`);
+				}
+				break;
+			case "CardBlock": {
+				const title = block.props?.["title"] || "";
+				const href = block.props?.["href"] || "#";
+				const desc = block.props?.["description"] ? `: ${block.props["description"]}` : "";
+				lines.push(`- [${title}](${href})${desc}`);
+				break;
+			}
+			case "FileTreeBlock": {
+				const renderTree = (nodes, prefix = "") => {
+					const treeLines = [];
+					for (const node of nodes) {
+						const icon = node.isDir ? "📁 " : "📄 ";
+						const comment = node.comment ? ` # ${node.comment}` : "";
+						treeLines.push(`${prefix}${icon}${node.name}${comment}`);
+						if (node.children && node.children.length > 0) treeLines.push(...renderTree(node.children, `${prefix}  `));
+					}
+					return treeLines;
+				};
+				const treeNodes = block.props?.["tree"] || [];
+				lines.push(`\`\`\`text\n${renderTree(treeNodes).join("\n")}\n\`\`\``);
+				break;
+			}
+			case "DialogueBlock":
+				lines.push(`**${block.props?.["character"]}:** "${block.props?.["line"] || ""}"`);
+				break;
+			default: if (block.props?.["text"]) lines.push(inlinesToMarkdown(block.props["text"]));
+		}
+	}
+	return lines.filter(Boolean).join("\n\n");
+}
+//#endregion
+//#region src/core/registry.ts
+const definitions = /* @__PURE__ */ new Map();
+const BlockRegistry = {
+	register(def) {
+		definitions.set(def.type, def);
+	},
+	get(type) {
+		return definitions.get(type);
+	},
+	getAll() {
+		return Array.from(definitions.values());
+	}
+};
+BlockRegistry.register({
+	type: "SectionBlock",
+	label: "Section",
+	description: "Container block for grouping nested content",
+	defaultProps: { title: "" },
+	allowChildren: true
+});
+BlockRegistry.register({
+	type: "ParagraphBlock",
+	label: "Paragraph",
+	description: "Rich text paragraph block",
+	defaultProps: { text: { en: "" } }
+});
+BlockRegistry.register({
+	type: "CalloutBlock",
+	label: "Callout",
+	description: "Highlighted callout box (info, warning, note)",
+	defaultProps: {
+		variant: "info",
+		text: { en: "" }
+	}
+});
+BlockRegistry.register({
+	type: "ImageBlock",
+	label: "Image",
+	description: "Image component with caption and alt text",
+	defaultProps: {
+		url: "",
+		alt: "",
+		caption: ""
+	}
+});
+BlockRegistry.register({
+	type: "CodeBlock",
+	label: "Code",
+	description: "Code block with syntax highlighting",
+	defaultProps: {
+		code: "",
+		language: "typescript"
+	}
+});
+//#endregion
+//#region src/core/validator.ts
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isValidUUID(uuid) {
+	return UUID_REGEX.test(uuid);
+}
+function validateBlockAST(blocks) {
+	const errors = [];
+	function checkBlocks(nodes) {
+		for (const b of nodes) {
+			if (!b.id || typeof b.id !== "string" || !isValidUUID(b.id)) errors.push(`Block of type '${b.type}' has invalid UUID identifier: '${b.id}'`);
+			if (!b.type || typeof b.type !== "string") errors.push(`Block missing valid 'type' field`);
+			if (b.children && Array.isArray(b.children)) checkBlocks(b.children);
+		}
+	}
+	checkBlocks(blocks);
+	return {
+		valid: errors.length === 0,
+		errors
+	};
+}
+//#endregion
+//#region src/auth/permissions.ts
+const cmsStatements = {
+	page: [
+		"create",
+		"read",
+		"update",
+		"delete",
+		"publish",
+		"approve"
+	],
+	template: [
+		"create",
+		"read",
+		"update",
+		"delete",
+		"instantiate"
+	],
+	draft: [
+		"checkout",
+		"edit",
+		"release",
+		"force_unlock"
+	],
+	version: [
+		"create",
+		"review",
+		"approve",
+		"publish"
+	]
+};
+const cmsAc = {
+	page: {
+		read: ["admin", "editor"],
+		update: ["admin", "editor"],
+		delete: ["admin"],
+		publish: ["admin"],
+		approve: ["admin"]
+	},
+	template: {
+		read: ["admin", "editor"],
+		update: ["admin"],
+		delete: ["admin"],
+		instantiate: ["admin", "editor"]
+	},
+	draft: {
+		checkout: ["admin", "editor"],
+		edit: ["admin", "editor"],
+		release: ["admin", "editor"],
+		force_unlock: ["admin"]
+	},
+	version: {
+		create: ["admin", "editor"],
+		review: ["admin", "editor"],
+		approve: ["admin"],
+		publish: ["admin"]
+	}
+};
+//#endregion
+//#region src/auth/filter-blocks.ts
+/**
+* Pure immutable function for Astro SSR Reader. Returns new array; never mutates input AST
+*/
+function filterBlocksForReader(blocks, session) {
+	const filtered = [];
+	for (const block of blocks) {
+		if (block.allowedRoles && block.allowedRoles.length > 0) {
+			if (!session || !session.roles.some((r) => block.allowedRoles.includes(r))) continue;
+		}
+		if (block.requiredPermission) {
+			if (!session || !session.permissions.includes(block.requiredPermission)) continue;
+		}
+		const filteredChildren = block.children?.length ? filterBlocksForReader(block.children, session) : block.children;
+		const newBlock = {
+			id: block.id,
+			type: block.type,
+			props: block.props
+		};
+		if (filteredChildren !== void 0) newBlock.children = filteredChildren;
+		if (block.isTemplated !== void 0) newBlock.isTemplated = block.isTemplated;
+		if (block.templatedProps !== void 0) newBlock.templatedProps = block.templatedProps;
+		if (block.allowedRoles !== void 0) newBlock.allowedRoles = block.allowedRoles;
+		if (block.requiredPermission !== void 0) newBlock.requiredPermission = block.requiredPermission;
+		filtered.push(newBlock);
+	}
+	return filtered;
+}
+//#endregion
+//#region src/auth/editor-guards.ts
+/**
+* Checks if a user has edit rights over a specific block
+*/
+function canUserEditBlock(block, session) {
+	if (block.allowedRoles && block.allowedRoles.length > 0) {
+		if (!session || !session.roles.some((r) => block.allowedRoles.includes(r))) return false;
+	}
+	if (block.requiredPermission) {
+		if (!session || !session.permissions.includes(block.requiredPermission)) return false;
+	}
+	return true;
+}
+/**
+* Recursively checks if a block or ANY of its descendants are locked or un-editable
+*/
+function hasLockedDescendants(block, session) {
+	if (!canUserEditBlock(block, session)) return true;
+	if (block.isTemplated) return true;
+	if (block.children?.length) return block.children.some((child) => hasLockedDescendants(child, session));
+	return false;
+}
+/**
+* Server-Side Guard: Validates that an incoming edited block tree obeys templated & authorization
+* invariants
+*/
+function validateServerBlockPayload(existingTree, incomingTree, session) {
+	const existingTemplated = extractTemplatedBlocks(existingTree);
+	const incomingTemplated = extractTemplatedBlocks(incomingTree);
+	if (existingTemplated.length !== incomingTemplated.length) return {
+		valid: false,
+		reason: "Forbidden: One or more templated blocks were removed."
+	};
+	for (let i = 0; i < existingTemplated.length; i++) {
+		const existing = existingTemplated[i];
+		const incoming = incomingTemplated[i];
+		if (!existing || !incoming || existing.id !== incoming.id || existing.type !== incoming.type) return {
+			valid: false,
+			reason: "Forbidden: Reordering of templated blocks is forbidden."
+		};
+	}
+	for (const existingBlock of existingTemplated) {
+		const incomingBlock = incomingTemplated.find((b) => b.type === existingBlock.type && b.id === existingBlock.id);
+		if (!incomingBlock) return {
+			valid: false,
+			reason: `Forbidden: Templated block ${existingBlock.type} (ID: ${existingBlock.id}) missing in payload.`
+		};
+		if (existingBlock.templatedProps === true) {
+			if (JSON.stringify(existingBlock.props) !== JSON.stringify(incomingBlock.props)) return {
+				valid: false,
+				reason: `Forbidden: Cannot modify locked properties on ${existingBlock.type}.`
+			};
+		} else if (Array.isArray(existingBlock.templatedProps)) {
+			for (const key of existingBlock.templatedProps) if (JSON.stringify(existingBlock.props[key]) !== JSON.stringify(incomingBlock.props[key])) return {
+				valid: false,
+				reason: `Forbidden: Cannot modify locked property '${key}' on ${existingBlock.type}.`
+			};
+		}
+	}
+	if (session) {
+		const existingProtected = extractProtectedBlocks(existingTree);
+		const incomingMap = new Map(flattenBlocks(incomingTree).map((b) => [b.id, b]));
+		for (const existingBlock of existingProtected) {
+			const incomingBlock = incomingMap.get(existingBlock.id);
+			if (!canUserEditBlock(existingBlock, session)) {
+				if (!incomingBlock) return {
+					valid: false,
+					reason: `Forbidden: Cannot delete protected block ${existingBlock.type} (ID: ${existingBlock.id}).`
+				};
+				if (JSON.stringify(existingBlock.props) !== JSON.stringify(incomingBlock.props)) return {
+					valid: false,
+					reason: `Forbidden: Cannot modify protected block ${existingBlock.type} (ID: ${existingBlock.id}).`
+				};
+			}
+		}
+	}
+	return { valid: true };
+}
+function getChildren(b) {
+	if (!b) return [];
+	if (Array.isArray(b.props?.["children"])) return b.props["children"];
+	if (Array.isArray(b.children)) return b.children;
+	return [];
+}
+function flattenBlocks(blocks) {
+	let result = [];
+	for (const b of blocks) {
+		if (!b) continue;
+		result.push(b);
+		const children = getChildren(b);
+		if (children.length) result = result.concat(flattenBlocks(children));
+	}
+	return result;
+}
+function extractTemplatedBlocks(blocks) {
+	let result = [];
+	for (const b of blocks) {
+		if (!b) continue;
+		if (b.isTemplated) result.push(b);
+		const children = getChildren(b);
+		if (children.length) result = result.concat(extractTemplatedBlocks(children));
+	}
+	return result;
+}
+function extractProtectedBlocks(blocks) {
+	return flattenBlocks(blocks).filter((b) => b.allowedRoles && b.allowedRoles.length > 0 || !!b.requiredPermission);
+}
+//#endregion
+//#region src/auth/filter-templates.ts
+function canUserCreateFromTemplate(template, session) {
+	const allowedCreate = template.rolePermissions?.whoCanCreate?.length ? template.rolePermissions.whoCanCreate : template.allowedRoles;
+	if (allowedCreate && allowedCreate.length > 0) {
+		if (!session || !session.roles.some((r) => allowedCreate.includes(r))) return false;
+	}
+	if (template.requiredPermission) {
+		if (!session || !session.permissions.includes(template.requiredPermission)) return false;
+	}
+	return true;
+}
+function canUserEditFromTemplate(template, session) {
+	const allowedEdit = template.rolePermissions?.whoCanEdit;
+	if (allowedEdit && allowedEdit.length > 0) {
+		if (!session || !session.roles.some((r) => allowedEdit.includes(r))) return false;
+	}
+	return true;
+}
+function canUserReviewFromTemplate(template, session) {
+	const allowedReview = template.rolePermissions?.whoCanReview?.length ? template.rolePermissions.whoCanReview : template.approvalRules?.requiredRolesForApproval;
+	if (allowedReview && allowedReview.length > 0) {
+		if (!session || !session.roles.some((r) => allowedReview.includes(r))) return false;
+	}
+	return true;
+}
+function canUserViewFromTemplate(template, session) {
+	const allowedView = template.rolePermissions?.whoCanView;
+	if (allowedView && allowedView.length > 0) {
+		if (!session || !session.roles.some((r) => allowedView.includes(r))) return false;
+	}
+	return true;
+}
+function canUserInstantiateTemplate(template, session) {
+	return canUserCreateFromTemplate(template, session);
+}
+function filterTemplatesForUser(templates, session) {
+	return templates.filter((t) => canUserInstantiateTemplate(t, session));
+}
+//#endregion
+//#region src/cache/purge.ts
+async function invalidatePageCache(options) {
+	const { slug, locales, domain = "rimelight.com", basePath = "", isEnterpriseCloudflare } = options;
+	const zoneId = process.env["CLOUDFLARE_ZONE_ID"];
+	const apiToken = process.env["CLOUDFLARE_API_TOKEN"];
+	if (!zoneId || !apiToken) return false;
+	const cleanPath = basePath ? `/${basePath.replace(/^\/+|\/+$/g, "")}` : "";
+	const body = isEnterpriseCloudflare ? { tags: [`page-${domain}-${slug}`] } : { files: locales.map((lang) => `https://${domain}/${lang}${cleanPath}/${slug}`) };
+	try {
+		return (await fetch(`https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${apiToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify(body)
+		})).ok;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/search/query.ts
+const POSTGRES_SEARCH_CONFIGS = {
+	en: "english",
+	es: "spanish",
+	de: "german",
+	fr: "french"
+};
+function getPostgresSearchConfig(locale) {
+	return POSTGRES_SEARCH_CONFIGS[locale] || "simple";
+}
+//#endregion
+//#region src/core/excerpt.ts
+function extractTextFromInlineNodes(nodes) {
+	if (!nodes || !Array.isArray(nodes)) return "";
+	return nodes.map((node) => {
+		if (node.type === "text") return node.text || "";
+		if (node.type === "page_mention") return node.displayTitle || node.pageSlug || "";
+		if (node.type === "link") return extractTextFromInlineNodes(node.children);
+		return "";
+	}).join("");
+}
+function extractTextFromProperty(prop, locale = "en") {
+	if (!prop) return "";
+	if (typeof prop === "string") return prop;
+	if (typeof prop === "object" && prop !== null) {
+		if (Array.isArray(prop)) return extractTextFromInlineNodes(prop);
+		const record = prop;
+		if (typeof record[locale] === "string") return record[locale];
+		if (typeof record["en"] === "string") return record["en"];
+		const firstVal = Object.values(record)[0];
+		if (typeof firstVal === "string") return firstVal;
+	}
+	return "";
+}
+/**
+* Recursively extracts plain text from an array of CMS blocks.
+*/
+function extractTextFromBlocks(blocks, locale = "en") {
+	if (!blocks || !Array.isArray(blocks)) return "";
+	const chunks = [];
+	for (const block of blocks) {
+		if (!block) continue;
+		const props = block.props || {};
+		switch (block.type) {
+			case "ParagraphBlock": {
+				const text = extractTextFromProperty(props["text"], locale);
+				if (text) chunks.push(text);
+				break;
+			}
+			case "SectionBlock":
+				if (props["title"]) chunks.push(String(props["title"]));
+				if (props["description"]) chunks.push(String(props["description"]));
+				if (Array.isArray(props["children"])) {
+					const childText = extractTextFromBlocks(props["children"], locale);
+					if (childText) chunks.push(childText);
+				}
+				break;
+			case "CardBlock":
+				if (props["title"]) chunks.push(String(props["title"]));
+				if (props["description"]) chunks.push(String(props["description"]));
+				break;
+			case "DialogueBlock":
+				if (props["character"] && props["line"]) chunks.push(`${props["character"]}: ${props["line"]}`);
+				else if (props["line"]) chunks.push(String(props["line"]));
+				break;
+			case "StepItemBlock":
+				if (props["title"]) chunks.push(String(props["title"]));
+				if (props["description"]) chunks.push(String(props["description"]));
+		}
+		if (Array.isArray(block.children) && block.children.length > 0) {
+			const childText = extractTextFromBlocks(block.children, locale);
+			if (childText) chunks.push(childText);
+		}
+	}
+	return chunks.join(" ").replace(/\s+/g, " ").trim();
+}
+/**
+* Generates an SEO / RSS safe plain text excerpt from a CMS page or block payload.
+*/
+function createPageExcerpt(page, options = {}) {
+	const { maxLength = 160, locale = "en", fallback = "" } = options;
+	if (!page) return fallback;
+	const explicitDesc = extractTextFromProperty(page.description, locale);
+	if (explicitDesc) return truncateExcerpt(explicitDesc, maxLength);
+	let contentObj = page.content;
+	if (typeof contentObj === "string") try {
+		contentObj = JSON.parse(contentObj);
+	} catch {
+		contentObj = null;
+	}
+	if (contentObj && typeof contentObj === "object") {
+		const props = contentObj.properties;
+		if (props && props["description"]) {
+			const descText = extractTextFromProperty(props["description"], locale);
+			if (descText) return truncateExcerpt(descText, maxLength);
+		}
+		const blocks = contentObj.blocks;
+		if (Array.isArray(blocks) && blocks.length > 0) {
+			const extracted = extractTextFromBlocks(blocks, locale);
+			if (extracted) return truncateExcerpt(extracted, maxLength);
+		}
+	}
+	return fallback;
+}
+function truncateExcerpt(text, maxLength) {
+	const clean = text.replace(/<[^>]*>/g, "").replace(/\s+/g, " ").trim();
+	if (clean.length <= maxLength) return clean;
+	return `${clean.slice(0, maxLength - 1).trimEnd()}…`;
+}
+//#endregion
+//#region src/services/site-settings.ts
+const DEFAULT_SITE_SETTINGS = {
+	id: "default",
+	name: "Rimelight",
+	description: "Built with Rimelight CMS",
+	url: "https://rimelight.com",
+	ogImage: "https://cdn.rimelight.com/Images/og-placeholder.webp",
+	author: "Rimelight",
+	email: "",
+	branding: {
+		logo: { alt: "Rimelight" },
+		favicon: { svg: "/favicon.svg" },
+		colors: {
+			themeColor: "#ffffff",
+			backgroundColor: "#ffffff"
+		}
+	},
+	seo: {
+		titleTemplate: "%s | Rimelight",
+		ogImageFallback: "https://cdn.rimelight.com/Images/og-placeholder.webp",
+		maxDescriptionLength: 160
+	}
+};
+/**
+* Retrieves the dynamic site settings from the database. If no settings are found, seeds the
+* default record and returns it.
+*/
+async function getSiteSettings(db, fallbackDefaults) {
+	if (!db) return {
+		...DEFAULT_SITE_SETTINGS,
+		...fallbackDefaults,
+		createdAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date()
+	};
+	try {
+		const records = await db.select().from(siteSettings).where(eq(siteSettings.id, "default")).limit(1);
+		if (records.length > 0) return records[0];
+		const initial = {
+			...DEFAULT_SITE_SETTINGS,
+			...fallbackDefaults,
+			id: "default"
+		};
+		return (await db.insert(siteSettings).values(initial).returning())[0];
+	} catch (error) {
+		console.warn("Failed to fetch site settings from DB, using fallback:", error);
+		return {
+			...DEFAULT_SITE_SETTINGS,
+			...fallbackDefaults,
+			createdAt: /* @__PURE__ */ new Date(),
+			updatedAt: /* @__PURE__ */ new Date()
+		};
+	}
+}
+/**
+* Updates dynamic site settings in the database.
+*/
+async function updateSiteSettings(db, updates, id = "default") {
+	const current = await getSiteSettings(db);
+	const updatedValues = {
+		...updates,
+		branding: updates.branding ? {
+			...current.branding,
+			...updates.branding
+		} : current.branding,
+		seo: updates.seo ? {
+			...current.seo,
+			...updates.seo
+		} : current.seo,
+		updatedAt: /* @__PURE__ */ new Date()
+	};
+	return (await db.update(siteSettings).set(updatedValues).where(eq(siteSettings.id, id)).returning())[0];
+}
+//#endregion
+//#region src/loader/live.ts
+function resolveLocalized$1(val, locale = "en") {
+	if (!val) return "";
+	if (typeof val === "string") return val;
+	if (typeof val === "object" && val !== null) {
+		const rec = val;
+		return rec[locale] || rec["en"] || Object.values(rec)[0] || "";
+	}
+	return typeof val === "number" ? String(val) : "";
+}
+function transformPageToEntry(rawPage, locale = "en") {
+	let contentObj = rawPage.content;
+	if (typeof contentObj === "string") try {
+		contentObj = JSON.parse(contentObj);
+	} catch {
+		contentObj = {
+			blocks: [],
+			properties: {}
+		};
+	}
+	else if (!contentObj || typeof contentObj !== "object") contentObj = {
+		blocks: [],
+		properties: {}
+	};
+	const blocks = Array.isArray(contentObj.blocks) ? contentObj.blocks : [];
+	const properties = contentObj.properties || {};
+	const resolvedTitle = resolveLocalized$1(rawPage.title, locale);
+	const resolvedDescription = resolveLocalized$1(rawPage.description, locale);
+	const excerpt = createPageExcerpt(rawPage, {
+		locale,
+		maxLength: 160
+	});
+	return {
+		id: rawPage.slug || rawPage.id,
+		data: {
+			id: rawPage.id,
+			slug: rawPage.slug,
+			type: rawPage.type,
+			title: rawPage.title,
+			resolvedTitle,
+			description: rawPage.description,
+			resolvedDescription,
+			excerpt,
+			tags: rawPage.tags || [],
+			authorIds: rawPage.authorIds || [],
+			blocks,
+			properties,
+			publishedVersionId: rawPage.publishedVersionId,
+			postedAt: rawPage.postedAt ? new Date(rawPage.postedAt) : null,
+			createdAt: new Date(rawPage.createdAt),
+			updatedAt: rawPage.updatedAt ? new Date(rawPage.updatedAt) : null
+		}
+	};
+}
+/**
+* Direct querying helper for CMS collections.
+*/
+async function getCmsCollection(db, options = {}) {
+	const { type, locale = "en", includeDrafts = false, includeScheduled = false, limit, offset, where: customWhere } = options;
+	if (!db) return {
+		entries: [],
+		cacheHint: { tags: ["cms"] }
+	};
+	const conditions = [isNull(pages.deletedAt)];
+	if (type) conditions.push(eq(pages.type, type));
+	if (!includeDrafts) conditions.push(isNotNull(pages.publishedVersionId));
+	if (!includeScheduled) conditions.push(lte(pages.postedAt, /* @__PURE__ */ new Date()));
+	if (customWhere) conditions.push(customWhere);
+	if (options.taxonomy) {
+		for (const [taxName, termSlug] of Object.entries(options.taxonomy)) if (termSlug) conditions.push(sql`${pages.id} IN (
+            SELECT ${pageTaxonomyTerms.pageId} FROM ${pageTaxonomyTerms}
+            INNER JOIN ${taxonomyTerms} ON ${taxonomyTerms.id} = ${pageTaxonomyTerms.termId}
+            WHERE ${taxonomyTerms.taxonomy} = ${taxName} AND ${taxonomyTerms.slug} = ${termSlug}
+          )`);
+	}
+	let query = db.select().from(pages).where(and(...conditions)).orderBy(desc(pages.postedAt));
+	if (typeof limit === "number") query = query.limit(limit);
+	if (typeof offset === "number") query = query.offset(offset);
+	const entries = (await query).map((r) => transformPageToEntry(r, locale));
+	let lastModified = /* @__PURE__ */ new Date(0);
+	for (const entry of entries) if (entry.data.updatedAt && entry.data.updatedAt > lastModified) lastModified = entry.data.updatedAt;
+	const tags = ["cms"];
+	if (type) tags.push(`cms:${type}`);
+	return {
+		entries,
+		cacheHint: {
+			tags,
+			lastModified: lastModified.getTime() > 0 ? lastModified : /* @__PURE__ */ new Date()
+		}
+	};
+}
+/**
+* Direct querying helper for a single CMS entry by slug or id.
+*/
+async function getCmsEntry(db, slugOrId, options = {}) {
+	const { entries, cacheHint } = await getCmsCollection(db, {
+		...options,
+		limit: 1,
+		where: eq(pages.slug, slugOrId)
+	});
+	const entry = entries[0] || null;
+	if (entry) cacheHint.tags?.push(`page:${entry.data.slug}`);
+	return {
+		entry,
+		cacheHint
+	};
+}
+/**
+* Astro Live Loader for CMS collections. Use inside src/live.config.ts with defineLiveCollection({
+* loader: rimelightCmsLoader({ type: 'blog' }) })
+*/
+function rimelightCmsLoader(loaderOptions = {}) {
+	return {
+		name: "rimelight-cms-loader",
+		loadCollection: async (context) => {
+			const db = loaderOptions.db || globalThis.db;
+			const limit = typeof context.filter?.limit === "number" ? context.filter.limit : void 0;
+			const offset = typeof context.filter?.offset === "number" ? context.filter.offset : void 0;
+			return getCmsCollection(db, {
+				...loaderOptions,
+				limit,
+				offset
+			});
+		},
+		loadEntry: async (context) => {
+			const { entry, cacheHint } = await getCmsEntry(loaderOptions.db || globalThis.db, context.filter.id, loaderOptions);
+			if (!entry) return void 0;
+			return {
+				id: entry.id,
+				data: entry.data,
+				cacheHint
+			};
+		}
+	};
+}
+//#endregion
+//#region src/cron/scheduled.ts
+/**
+* Handles the periodic Cloudflare Worker cron trigger (e.g. "* * * * *").
+*
+* - Cleans up expired page draft locks
+* - Checks for active scheduled pages
+*/
+async function handleCmsCron(_event, _env, _ctx, db) {
+	const result = {
+		expiredLocksCleaned: 0,
+		scheduledPagesActive: 0,
+		timestamp: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (!db) return result;
+	try {
+		const now = /* @__PURE__ */ new Date();
+		result.expiredLocksCleaned = (await db.delete(pageDraftLocks).where(lt(pageDraftLocks.expiresAt, now)).returning({ pageId: pageDraftLocks.pageId })).length;
+		result.scheduledPagesActive = (await db.select({
+			id: pages.id,
+			slug: pages.slug
+		}).from(pages).where(and(isNull(pages.deletedAt), isNotNull(pages.publishedVersionId), lte(pages.postedAt, now))).limit(10)).length;
+	} catch (error) {
+		console.error("[CmsCron] Error executing scheduled tasks:", error);
+	}
+	return result;
+}
+//#endregion
+//#region src/mcp/index.ts
+const CMS_MCP_TOOLS = [
+	{
+		name: "cms_list_pages",
+		description: "List CMS pages with optional filters for type, draft status, and pagination.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				type: {
+					type: "string",
+					description: "Filter by page type (e.g. 'blog', 'docs', 'landing')"
+				},
+				includeDrafts: {
+					type: "boolean",
+					description: "Whether to include unpublished drafts"
+				},
+				limit: {
+					type: "number",
+					description: "Maximum number of pages to return (default 20)"
+				}
+			}
+		}
+	},
+	{
+		name: "cms_get_page",
+		description: "Get full details, block tree, and properties for a specific CMS page by slug or id.",
+		inputSchema: {
+			type: "object",
+			properties: { slugOrId: {
+				type: "string",
+				description: "Page slug or UUID"
+			} },
+			required: ["slugOrId"]
+		}
+	},
+	{
+		name: "cms_create_draft",
+		description: "Create or update a draft version for a CMS page.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				pageId: {
+					type: "string",
+					description: "Page UUID"
+				},
+				userId: {
+					type: "string",
+					description: "User ID creating the draft"
+				},
+				blocks: {
+					type: "array",
+					description: "Array of structured CMS blocks"
+				},
+				properties: {
+					type: "object",
+					description: "Page properties object"
+				}
+			},
+			required: [
+				"pageId",
+				"userId",
+				"blocks"
+			]
+		}
+	},
+	{
+		name: "cms_get_site_settings",
+		description: "Retrieve current dynamic site settings including branding and SEO defaults.",
+		inputSchema: {
+			type: "object",
+			properties: {}
+		}
+	},
+	{
+		name: "cms_update_site_settings",
+		description: "Update dynamic site settings (name, description, branding, SEO).",
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				description: { type: "string" },
+				author: { type: "string" },
+				email: { type: "string" },
+				branding: { type: "object" },
+				seo: { type: "object" }
+			}
+		}
+	}
+];
+/**
+* Handles Model Context Protocol (MCP) JSON-RPC requests for CMS tools.
+*/
+async function handleCmsMcpRequest(body, db) {
+	const { id = 1, method, params = {} } = body;
+	if (method === "tools/list") return {
+		jsonrpc: "2.0",
+		id,
+		result: { tools: CMS_MCP_TOOLS }
+	};
+	if (method === "tools/call") {
+		const { name, arguments: args = {} } = params;
+		switch (name) {
+			case "cms_list_pages": {
+				const conditions = [isNull(pages.deletedAt)];
+				if (args.type) conditions.push(eq(pages.type, args.type));
+				if (!args.includeDrafts) conditions.push(isNotNull(pages.publishedVersionId));
+				const queryLimit = typeof args.limit === "number" ? args.limit : 20;
+				const rows = await db.select({
+					id: pages.id,
+					slug: pages.slug,
+					type: pages.type,
+					title: pages.title,
+					postedAt: pages.postedAt,
+					publishedVersionId: pages.publishedVersionId
+				}).from(pages).where(and(...conditions)).orderBy(desc(pages.postedAt)).limit(queryLimit);
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: { content: [{
+						type: "text",
+						text: JSON.stringify(rows, null, 2)
+					}] }
+				};
+			}
+			case "cms_get_page": {
+				const page = (await db.select().from(pages).where(and(isNull(pages.deletedAt), eq(pages.slug, args.slugOrId))).limit(1))[0] || null;
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: { content: [{
+						type: "text",
+						text: JSON.stringify(page, null, 2)
+					}] }
+				};
+			}
+			case "cms_create_draft": {
+				const contentPayload = {
+					blocks: args.blocks,
+					properties: args.properties || {}
+				};
+				const draft = await db.insert(pageDrafts).values({
+					pageId: args.pageId,
+					updatedBy: args.userId,
+					content: contentPayload
+				}).onConflictDoUpdate({
+					target: [pageDrafts.pageId],
+					set: {
+						content: contentPayload,
+						updatedBy: args.userId,
+						updatedAt: /* @__PURE__ */ new Date()
+					}
+				}).returning();
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: { content: [{
+						type: "text",
+						text: JSON.stringify(draft[0], null, 2)
+					}] }
+				};
+			}
+			case "cms_get_site_settings": {
+				const settings = await getSiteSettings(db);
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: { content: [{
+						type: "text",
+						text: JSON.stringify(settings, null, 2)
+					}] }
+				};
+			}
+			case "cms_update_site_settings": {
+				const updated = await updateSiteSettings(db, args);
+				return {
+					jsonrpc: "2.0",
+					id,
+					result: { content: [{
+						type: "text",
+						text: JSON.stringify(updated, null, 2)
+					}] }
+				};
+			}
+			default: return {
+				jsonrpc: "2.0",
+				id,
+				error: {
+					code: -32601,
+					message: `Method or tool '${name}' not found`
+				}
+			};
+		}
+	}
+	return {
+		jsonrpc: "2.0",
+		id,
+		error: {
+			code: -32601,
+			message: `Unknown method: ${method}`
+		}
+	};
+}
+//#endregion
+//#region src/services/bylines.ts
+/**
+* Returns all active (non-deleted) bylines.
+*/
+async function getBylines(db) {
+	if (!db) return [];
+	return db.select().from(bylines).where(isNull(bylines.deletedAt)).orderBy(bylines.name);
+}
+/**
+* Retrieves a single byline by ID or slug.
+*/
+async function getByline(db, idOrSlug) {
+	if (!db || !idOrSlug) return null;
+	return (await db.select().from(bylines).where(and(isNull(bylines.deletedAt), or(eq(bylines.id, idOrSlug), eq(bylines.slug, idOrSlug)))).limit(1))[0] || null;
+}
+/**
+* Creates a new byline.
+*/
+async function createByline(db, data) {
+	const [created] = await db.insert(bylines).values({
+		...data,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).returning();
+	return created;
+}
+/**
+* Updates an existing byline.
+*/
+async function updateByline(db, id, data) {
+	const [updated] = await db.update(bylines).set({
+		...data,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(and(eq(bylines.id, id), isNull(bylines.deletedAt))).returning();
+	return updated || null;
+}
+/**
+* Soft deletes a byline.
+*/
+async function deleteByline(db, id) {
+	const [deleted] = await db.update(bylines).set({
+		deletedAt: /* @__PURE__ */ new Date(),
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(and(eq(bylines.id, id), isNull(bylines.deletedAt))).returning();
+	return !!deleted;
+}
+//#endregion
+//#region src/core/preview.ts
+/**
+* Generates and verifies HMAC-signed stateless preview tokens for draft pages.
+*/
+async function getCryptoKey(secret) {
+	const enc = new TextEncoder();
+	return crypto.subtle.importKey("raw", enc.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign", "verify"]);
+}
+function hexEncode(buffer) {
+	const bytes = new Uint8Array(buffer);
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hexDecode(hex) {
+	const matches = hex.match(/.{1,2}/g) || [];
+	return new Uint8Array(matches.map((byte) => parseInt(byte, 16)));
+}
+/**
+* Generates a signed token for a page ID valid for ttlSeconds (default 24h).
+*/
+async function generatePreviewToken(pageId, secret, ttlSeconds = 86400) {
+	const expiresAt = Math.floor(Date.now() / 1e3) + ttlSeconds;
+	const payload = `${pageId}:${expiresAt}`;
+	const key = await getCryptoKey(secret);
+	const enc = new TextEncoder();
+	const signature = hexEncode(await crypto.subtle.sign("HMAC", key, enc.encode(payload)));
+	return {
+		token: `${btoa(payload)}.${signature}`,
+		expiresAt
+	};
+}
+/**
+* Verifies a signed preview token against a pageId and secret.
+*/
+async function verifyPreviewToken(pageId, token, secret) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 2) return false;
+		const [b64Payload, signatureHex] = parts;
+		if (!b64Payload || !signatureHex) return false;
+		const payload = atob(b64Payload);
+		const [tokenPageId, tokenExpStr] = payload.split(":");
+		if (!tokenPageId || !tokenExpStr) return false;
+		if (tokenPageId !== pageId) return false;
+		const expiresAt = parseInt(tokenExpStr, 10);
+		const now = Math.floor(Date.now() / 1e3);
+		if (isNaN(expiresAt) || now > expiresAt) return false;
+		const key = await getCryptoKey(secret);
+		const enc = new TextEncoder();
+		const signatureBytes = hexDecode(signatureHex);
+		return await crypto.subtle.verify("HMAC", key, signatureBytes, enc.encode(payload));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/core/diff.ts
+/**
+* Calculates a detailed diff between an old list of blocks and a new list of blocks.
+*/
+function diffBlocks(oldBlocks = [], newBlocks = []) {
+	const diffs = [];
+	const oldMap = /* @__PURE__ */ new Map();
+	const newMap = /* @__PURE__ */ new Map();
+	oldBlocks.forEach((block, index) => {
+		oldMap.set(block.id, {
+			block,
+			index
+		});
+	});
+	newBlocks.forEach((block, index) => {
+		newMap.set(block.id, {
+			block,
+			index
+		});
+	});
+	for (const newBlock of newBlocks) {
+		const oldEntry = oldMap.get(newBlock.id);
+		if (!oldEntry) diffs.push({
+			blockId: newBlock.id,
+			type: newBlock.type,
+			status: "added",
+			newBlock
+		});
+		else {
+			const oldBlock = oldEntry.block;
+			const fieldChanges = [];
+			const oldProps = oldBlock.props || oldBlock.properties || {};
+			const newProps = newBlock.props || newBlock.properties || {};
+			const allPropKeys = /* @__PURE__ */ new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+			for (const key of allPropKeys) {
+				const oldVal = oldProps[key];
+				const newVal = newProps[key];
+				if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) fieldChanges.push({
+					field: `props.${key}`,
+					oldValue: oldVal,
+					newValue: newVal
+				});
+			}
+			if (fieldChanges.length > 0) diffs.push({
+				blockId: newBlock.id,
+				type: newBlock.type,
+				status: "modified",
+				oldBlock,
+				newBlock,
+				fieldChanges
+			});
+			else diffs.push({
+				blockId: newBlock.id,
+				type: newBlock.type,
+				status: "unchanged",
+				oldBlock,
+				newBlock
+			});
+		}
+	}
+	for (const oldBlock of oldBlocks) if (!newMap.has(oldBlock.id)) diffs.push({
+		blockId: oldBlock.id,
+		type: oldBlock.type,
+		status: "removed",
+		oldBlock
+	});
+	return diffs;
+}
+/**
+* Compares two page snapshots (metadata + content blocks).
+*/
+function diffPageSnapshots(oldSnapshot, newSnapshot) {
+	const blockDiffs = diffBlocks(oldSnapshot?.content?.blocks || [], newSnapshot?.content?.blocks || []);
+	const metaFields = [
+		"title",
+		"slug",
+		"description",
+		"tags",
+		"type",
+		"authorIds",
+		"bylines"
+	];
+	const metaChanges = [];
+	for (const field of metaFields) {
+		const oldVal = oldSnapshot?.[field];
+		const newVal = newSnapshot?.[field];
+		if (JSON.stringify(oldVal) !== JSON.stringify(newVal)) metaChanges.push({
+			field,
+			oldValue: oldVal,
+			newValue: newVal
+		});
+	}
+	return {
+		blocks: blockDiffs,
+		metaChanges,
+		summary: {
+			addedCount: blockDiffs.filter((d) => d.status === "added").length,
+			removedCount: blockDiffs.filter((d) => d.status === "removed").length,
+			modifiedCount: blockDiffs.filter((d) => d.status === "modified").length,
+			unchangedCount: blockDiffs.filter((d) => d.status === "unchanged").length
+		}
+	};
+}
+//#endregion
+//#region src/services/search-indexer.ts
+async function indexPageForSearch(db, page, locales = ["en", "pt"]) {
+	if (!db) return;
+	const parseJson = (val) => typeof val === "string" ? JSON.parse(val) : val;
+	const titleObj = parseJson(page.title) || {};
+	const blocks = (parseJson(page.content) || {}).blocks || [];
+	for (const locale of locales) {
+		const titleText = typeof titleObj === "object" && titleObj !== null ? titleObj[locale] || titleObj.en || Object.values(titleObj)[0] || "" : String(titleObj || "");
+		const contentText = extractTextFromBlocks(blocks, locale);
+		if (!titleText && !contentText) continue;
+		try {
+			const existing = await db.select().from(contentSearchIndex).where(and(eq(contentSearchIndex.pageId, page.id), eq(contentSearchIndex.locale, locale))).limit(1);
+			if (existing.length > 0) await db.update(contentSearchIndex).set({
+				titleText,
+				contentText,
+				searchVector: sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
+			}).where(eq(contentSearchIndex.id, existing[0].id));
+			else await db.insert(contentSearchIndex).values({
+				pageId: page.id,
+				locale,
+				titleText,
+				contentText,
+				searchVector: sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
+			});
+		} catch (err) {
+			console.error(`[Search Indexer] Failed to index page ${page.id} for locale ${locale}:`, err);
+		}
+	}
+}
+//#endregion
+//#region src/services/taxonomies.ts
+/**
+* Retrieves all terms for a given taxonomy. If hierarchical, returns a tree structure with
+* `children: TaxonomyTerm[]`.
+*/
+async function getTaxonomyTerms(db, taxonomy, options = {}) {
+	if (!db) return [];
+	const includeCounts = options.includeCounts ?? true;
+	const rawTerms = await db.select().from(taxonomyTerms).where(eq(taxonomyTerms.taxonomy, taxonomy)).orderBy(asc(taxonomyTerms.displayOrder), asc(taxonomyTerms.createdAt));
+	if (!rawTerms || rawTerms.length === 0) return [];
+	const countsMap = /* @__PURE__ */ new Map();
+	if (includeCounts) try {
+		const counts = await db.select({
+			termId: pageTaxonomyTerms.termId,
+			count: sql`count(${pageTaxonomyTerms.pageId})::int`
+		}).from(pageTaxonomyTerms).innerJoin(pages, eq(pages.id, pageTaxonomyTerms.pageId)).where(isNull(pages.deletedAt)).groupBy(pageTaxonomyTerms.termId);
+		for (const row of counts) countsMap.set(row.termId, Number(row.count));
+	} catch {}
+	const termsWithCounts = rawTerms.map((t) => ({
+		id: t.id,
+		taxonomy: t.taxonomy,
+		slug: t.slug,
+		label: t.label,
+		description: t.description,
+		parentId: t.parentId,
+		displayOrder: t.displayOrder,
+		count: countsMap.get(t.id) ?? 0,
+		children: [],
+		createdAt: t.createdAt,
+		updatedAt: t.updatedAt
+	}));
+	if (!termsWithCounts.some((t) => !!t.parentId)) return termsWithCounts;
+	const idMap = /* @__PURE__ */ new Map();
+	const rootTerms = [];
+	termsWithCounts.forEach((term) => {
+		idMap.set(term.id, term);
+	});
+	termsWithCounts.forEach((term) => {
+		if (term.parentId && idMap.has(term.parentId)) {
+			const parent = idMap.get(term.parentId);
+			parent.children = parent.children || [];
+			parent.children.push(term);
+		} else rootTerms.push(term);
+	});
+	return rootTerms;
+}
+/**
+* Retrieves a single term by taxonomy and slug.
+*/
+async function getTerm(db, taxonomy, slug) {
+	if (!db) return null;
+	const results = await db.select().from(taxonomyTerms).where(and(eq(taxonomyTerms.taxonomy, taxonomy), eq(taxonomyTerms.slug, slug))).limit(1);
+	if (!results[0]) return null;
+	let count = 0;
+	try {
+		const countResult = await db.select({ count: sql`count(${pageTaxonomyTerms.pageId})::int` }).from(pageTaxonomyTerms).innerJoin(pages, eq(pages.id, pageTaxonomyTerms.pageId)).where(and(eq(pageTaxonomyTerms.termId, results[0].id), isNull(pages.deletedAt)));
+		count = Number(countResult[0]?.count ?? 0);
+	} catch {
+		count = 0;
+	}
+	return {
+		...results[0],
+		count,
+		children: []
+	};
+}
+/**
+* Retrieves all terms assigned to a specific page entry.
+*/
+async function getEntryTerms(db, pageId, taxonomy) {
+	if (!db || !pageId) return [];
+	const conditions = [eq(pageTaxonomyTerms.pageId, pageId)];
+	if (taxonomy) conditions.push(eq(taxonomyTerms.taxonomy, taxonomy));
+	return await db.select({
+		id: taxonomyTerms.id,
+		taxonomy: taxonomyTerms.taxonomy,
+		slug: taxonomyTerms.slug,
+		label: taxonomyTerms.label,
+		description: taxonomyTerms.description,
+		parentId: taxonomyTerms.parentId,
+		displayOrder: taxonomyTerms.displayOrder
+	}).from(pageTaxonomyTerms).innerJoin(taxonomyTerms, eq(taxonomyTerms.id, pageTaxonomyTerms.termId)).where(and(...conditions)).orderBy(asc(taxonomyTerms.displayOrder));
+}
+/**
+* Retrieves pages tagged with a given taxonomy term.
+*/
+async function getEntriesByTerm(db, taxonomy, slug, options = {}) {
+	if (!db) return {
+		entries: [],
+		total: 0
+	};
+	const term = await getTerm(db, taxonomy, slug);
+	if (!term) return {
+		entries: [],
+		total: 0
+	};
+	const conditions = [eq(pageTaxonomyTerms.termId, term.id), isNull(pages.deletedAt)];
+	if (options.type) conditions.push(eq(pages.type, options.type));
+	let query = db.select({ page: pages }).from(pageTaxonomyTerms).innerJoin(pages, eq(pages.id, pageTaxonomyTerms.pageId)).where(and(...conditions)).orderBy(asc(pages.createdAt));
+	if (options.limit) query = query.limit(options.limit);
+	if (options.offset) query = query.offset(options.offset);
+	const entries = (await query).map((r) => r.page);
+	return {
+		entries,
+		total: term.count ?? entries.length,
+		term
+	};
+}
+/**
+* Sets/syncs the assigned terms for a page within a specific taxonomy.
+*/
+async function assignEntryTerms(db, pageId, taxonomy, termIds) {
+	if (!db || !pageId) return;
+	const currentAssigned = await getEntryTerms(db, pageId, taxonomy);
+	const currentTermIds = new Set(currentAssigned.map((t) => t.id));
+	const newTermIds = new Set(termIds);
+	for (const term of currentAssigned) if (!newTermIds.has(term.id)) await db.delete(pageTaxonomyTerms).where(and(eq(pageTaxonomyTerms.pageId, pageId), eq(pageTaxonomyTerms.termId, term.id)));
+	for (const termId of termIds) if (!currentTermIds.has(termId)) await db.insert(pageTaxonomyTerms).values({
+		pageId,
+		termId
+	}).onConflictDoNothing();
+}
+/**
+* Creates a new taxonomy term.
+*/
+async function createTerm(db, data) {
+	return (await db.insert(taxonomyTerms).values(data).returning())[0];
+}
+/**
+* Updates an existing taxonomy term.
+*/
+async function updateTerm(db, id, updates) {
+	return (await db.update(taxonomyTerms).set({
+		...updates,
+		updatedAt: /* @__PURE__ */ new Date()
+	}).where(eq(taxonomyTerms.id, id)).returning())[0];
+}
+/**
+* Deletes a taxonomy term.
+*/
+async function deleteTerm(db, id) {
+	await db.delete(taxonomyTerms).where(eq(taxonomyTerms.id, id));
+	return { success: true };
+}
+//#endregion
+//#region src/docs/config.ts
+const defineDocsConfig = (config) => config;
+//#endregion
+//#region src/docs/sidebar.ts
+function formatDocsUrl$1(href, locale, activeVersion, includeVersionInUrl) {
+	let url = href.replace("{locale}", locale);
+	if (activeVersion && includeVersionInUrl) {
+		if (url.includes(`/${activeVersion}/`) || url.endsWith(`/${activeVersion}`)) return url;
+		const docsPattern = new RegExp(`(/${locale}/docs)(/|$)`);
+		const companyDocsPattern = new RegExp(`(/${locale}/company/docs)(/|$)`);
+		if (companyDocsPattern.test(url)) url = url.replace(companyDocsPattern, `$1/${activeVersion}$2`);
+		else if (docsPattern.test(url)) url = url.replace(docsPattern, `$1/${activeVersion}$2`);
+		url = url.replace(/\/{2,}/g, "/");
+	}
+	return url;
+}
+function findFirstHref(items, locale, activeVersion, includeVersionInUrl) {
+	for (const item of items) {
+		if (item.href) return formatDocsUrl$1(item.href, locale, activeVersion, includeVersionInUrl);
+		const childItems = item.children || item.items;
+		if (childItems) {
+			const found = findFirstHref(childItems, locale, activeVersion, includeVersionInUrl);
+			if (found) return found;
+		}
+	}
+}
+function getScopePrefix(items, locale, activeVersion, includeVersionInUrl) {
+	const allHrefs = [];
+	function collect(item) {
+		if (item.href) allHrefs.push(formatDocsUrl$1(item.href, locale, activeVersion, includeVersionInUrl));
+		const childItems = item.children || item.items;
+		if (childItems) childItems.forEach(collect);
+	}
+	items.forEach(collect);
+	if (allHrefs.length === 0) return "";
+	const parts = allHrefs.map((h) => h.split("/").filter(Boolean));
+	let commonLen = 0;
+	const firstPart = parts[0];
+	if (!firstPart) return "";
+	for (let i = 0; i < firstPart.length; i++) if (parts.every((p) => p[i] === firstPart[i])) commonLen++;
+	else break;
+	return "/" + firstPart.slice(0, commonLen).join("/") + "/";
+}
+function hasPath(items, locale, normPath, activeVersion, includeVersionInUrl) {
+	for (const item of items) {
+		if (item.href && formatDocsUrl$1(item.href, locale, activeVersion, includeVersionInUrl).replace(/\/$/, "").toLowerCase() === normPath) return true;
+		const childItems = item.children || item.items;
+		if (childItems && hasPath(childItems, locale, normPath, activeVersion, includeVersionInUrl)) return true;
+	}
+	return false;
+}
+async function getDocsSidebar(config, locale, currentPath, activeVersion, includeVersionInUrl) {
+	const normPath = currentPath.replace(/\/$/, "").toLowerCase();
+	const sidebarScopes = Array.isArray(config.sidebar) ? config.sidebar.filter((item) => "id" in item || "scopes" in item) : config.sidebar.scopes || [];
+	const scopes = sidebarScopes.map((scope) => {
+		const id = scope.id || scope.label;
+		let href = scope.href || "";
+		if (!href && scope.items && scope.items.length > 0) href = findFirstHref(scope.items, locale, activeVersion, includeVersionInUrl) || "";
+		return {
+			id,
+			label: scope.label,
+			href: formatDocsUrl$1(href, locale, activeVersion, includeVersionInUrl),
+			icon: scope.icon
+		};
+	});
+	const scopePrefixes = sidebarScopes.map((scope) => scope.items ? getScopePrefix(scope.items, locale, activeVersion, includeVersionInUrl) : "");
+	let activeScope = scopes.find((s) => normPath === s.href.replace(/\/$/, "").toLowerCase());
+	if (!activeScope) for (let i = 0; i < sidebarScopes.length; i++) {
+		const scope = sidebarScopes[i];
+		if (scope && scope.items && hasPath(scope.items, locale, normPath, activeVersion, includeVersionInUrl)) {
+			activeScope = scopes[i];
+			break;
+		}
+	}
+	if (!activeScope) {
+		const sorted = [...scopePrefixes.entries()].filter(([, p]) => p).toSorted(([, a], [, b]) => b.length - a.length);
+		for (const [i] of sorted) {
+			const prefix = scopePrefixes[i];
+			if (prefix && normPath.startsWith(prefix.toLowerCase())) {
+				activeScope = scopes[i];
+				break;
+			}
+		}
+	}
+	if (!activeScope && scopes.length > 0) activeScope = scopes[0];
+	if (activeScope) activeScope.active = true;
+	const items = sidebarScopes.find((item) => activeScope && (item.id === activeScope.id || item.label === activeScope.id))?.items || [];
+	async function resolveItem(item) {
+		const resolved = {
+			label: item.label || "",
+			href: item.href ? formatDocsUrl$1(item.href, locale, activeVersion, includeVersionInUrl) : void 0,
+			icon: item.icon,
+			badge: item.badge,
+			collapsed: item.collapsed
+		};
+		if (resolved.href) resolved.active = normPath === resolved.href.replace(/\/$/, "").toLowerCase();
+		const childItems = item.children || item.items;
+		if (childItems) {
+			const children = [];
+			const resolvedChildren = await Promise.all(childItems.map((child) => resolveItem(child)));
+			for (const res of resolvedChildren) children.push(...res);
+			resolved.children = children;
+			if (!resolved.active) resolved.active = children.some((c) => c.active);
+		}
+		return [resolved];
+	}
+	const resolvedItems = [];
+	const resolvedAllItems = await Promise.all(items.map((item) => resolveItem(item)));
+	for (const res of resolvedAllItems) resolvedItems.push(...res);
+	return {
+		items: resolvedItems,
+		scopes,
+		activeScope
+	};
+}
+function getSurroundItems(sidebar, currentPath) {
+	const flatItems = [];
+	function flatten(items) {
+		for (const item of items) {
+			if (item.href) flatItems.push({
+				label: item.label,
+				href: item.href
+			});
+			if (item.children) flatten(item.children);
+		}
+	}
+	flatten(sidebar);
+	const normPath = currentPath.replace(/\/$/, "").toLowerCase();
+	const currentIndex = flatItems.findIndex((item) => item.href.replace(/\/$/, "").toLowerCase() === normPath);
+	return {
+		prev: currentIndex > 0 ? flatItems[currentIndex - 1] : null,
+		next: currentIndex >= 0 && currentIndex < flatItems.length - 1 ? flatItems[currentIndex + 1] : null
+	};
+}
+//#endregion
+//#region src/docs/routing.ts
+function getDocsVersions(entries, locale) {
+	const versions = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (typeof entry === "string") {
+			const parts = entry.replace(/\\/g, "/").split("/");
+			if (parts[0]?.startsWith("v")) versions.add(parts[0]);
+			continue;
+		}
+		if (entry.version && entry.version.startsWith("v")) {
+			versions.add(entry.version);
+			continue;
+		}
+		if (entry.properties?.["version"] && String(entry.properties["version"]).startsWith("v")) {
+			versions.add(String(entry.properties["version"]));
+			continue;
+		}
+		const parts = (entry.slug || entry.id || "").replace(/\\/g, "/").split("/");
+		if (locale && parts[1] === locale && parts[0]?.startsWith("v")) versions.add(parts[0]);
+		else if (parts[0]?.startsWith("v")) versions.add(parts[0]);
+	}
+	return Array.from(versions).toSorted((a, b) => {
+		return b.localeCompare(a, void 0, {
+			numeric: true,
+			sensitivity: "base"
+		});
+	});
+}
+function parseDocsSlug(slug, versions) {
+	if (versions.length === 0) return {
+		activeVersion: "",
+		contentPath: slug || "index",
+		includeVersionInUrl: false
+	};
+	const defaultVersion = versions[0];
+	const isMultiVersion = versions.length > 1;
+	if (!slug) return {
+		activeVersion: defaultVersion,
+		contentPath: "index",
+		includeVersionInUrl: isMultiVersion
+	};
+	const parts = slug.split("/");
+	const firstPart = parts[0];
+	if (firstPart && versions.includes(firstPart)) return {
+		activeVersion: firstPart,
+		contentPath: parts.slice(1).join("/") || "index",
+		includeVersionInUrl: isMultiVersion
+	};
+	return {
+		activeVersion: defaultVersion,
+		contentPath: slug || "index",
+		includeVersionInUrl: isMultiVersion
+	};
+}
+function formatDocsUrl(href, locale, activeVersion, includeVersionInUrl) {
+	let url = href.replace("{locale}", locale);
+	if (activeVersion && includeVersionInUrl) {
+		if (url.includes(`/${activeVersion}/`) || url.endsWith(`/${activeVersion}`)) return url;
+		const docsPattern = new RegExp(`(/${locale}/docs)(/|$)`);
+		const companyDocsPattern = new RegExp(`(/${locale}/company/docs)(/|$)`);
+		if (companyDocsPattern.test(url)) url = url.replace(companyDocsPattern, `$1/${activeVersion}$2`);
+		else if (docsPattern.test(url)) url = url.replace(docsPattern, `$1/${activeVersion}$2`);
+		url = url.replace(/\/{2,}/g, "/");
+	}
+	return url;
+}
+//#endregion
+//#region src/docs/toc.ts
+function slugifyHeading(text) {
+	return text.toString().toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\s+/g, "-").replace(/[^\w-]+/g, "").replace(/-{2,}/g, "-").replace(/^-+/, "").replace(/-+$/, "");
+}
+function extractHeadingsFromBlocks(blocks = [], currentDepth = 2) {
+	if (!Array.isArray(blocks)) return [];
+	const headings = [];
+	for (const block of blocks) {
+		if (!block) continue;
+		if (block.type === "SectionBlock") {
+			const title = block.props?.title || "";
+			const level = Number(block.props?.level) || currentDepth;
+			if (title) headings.push({
+				depth: level,
+				slug: slugifyHeading(title),
+				text: title
+			});
+			const children = block.children || block.props?.children || [];
+			if (Array.isArray(children) && children.length > 0) headings.push(...extractHeadingsFromBlocks(children, Math.min(6, level + 1)));
+		}
+	}
+	return headings;
+}
+//#endregion
+//#region src/docs/agent.ts
+function resolveLocalized(val, locale = "en") {
+	if (!val) return "";
+	if (typeof val === "string") return val;
+	if (typeof val === "object" && val !== null) {
+		const rec = val;
+		return rec[locale] || rec["en"] || Object.values(rec)[0] || "";
+	}
+	return typeof val === "number" ? String(val) : "";
+}
+/**
+* Renders a CMS page record into clean, agent-ready Markdown with YAML frontmatter.
+*/
+function renderPageAsMarkdown(page, locale = "en", options = {}) {
+	const { siteUrl = "https://rimelight.com", llmsUrl = "/llms.txt", sourceUrl } = options;
+	let contentObj = page.content;
+	if (typeof contentObj === "string") try {
+		contentObj = JSON.parse(contentObj);
+	} catch {
+		contentObj = {
+			blocks: [],
+			properties: {}
+		};
+	}
+	else if (!contentObj || typeof contentObj !== "object") contentObj = {
+		blocks: [],
+		properties: {}
+	};
+	const blocks = Array.isArray(contentObj.blocks) ? contentObj.blocks : [];
+	const properties = contentObj.properties || {};
+	const title = resolveLocalized(page.title, locale) || properties.title || "Untitled";
+	const description = resolveLocalized(page.description, locale) || properties.description || "";
+	const version = properties.version || page.templateVersion;
+	const markdownBody = blocksToMarkdown(blocks);
+	const frontmatter = [
+		"---",
+		`title: ${JSON.stringify(title)}`,
+		...description ? [`description: ${JSON.stringify(description)}`] : [],
+		...version ? [`version: ${JSON.stringify(version)}`] : [],
+		...page.type ? [`type: ${JSON.stringify(page.type)}`] : [],
+		"---",
+		"",
+		"> Documentation Index",
+		`> Fetch the complete documentation index at: ${new URL(llmsUrl, siteUrl).href}`,
+		"> Use this file to discover all available pages and sections.",
+		"",
+		`# ${title}`,
+		"",
+		markdownBody,
+		""
+	];
+	if (sourceUrl) frontmatter.push(`Source: ${new URL(sourceUrl, siteUrl).href}`, "");
+	return frontmatter.join("\n");
+}
+/**
+* Collate all published pages of a given type into a single corpus markdown document.
+*/
+async function renderCorpusMarkdown(db, options = {}) {
+	const { type = "doc", locale = "en", siteUrl = "https://rimelight.com", title = "Rimelight Documentation Corpus", description = "Complete single-corpus documentation for AI agents." } = options;
+	if (!db) return `# ${title}\n\n${description}`;
+	const conditions = [isNull(pages.deletedAt), isNotNull(pages.publishedVersionId)];
+	if (type) conditions.push(eq(pages.type, type));
+	const rows = await db.select().from(pages).where(and(...conditions));
+	const parts = [
+		`# ${title}`,
+		"",
+		description,
+		"",
+		`Generated for site: ${siteUrl}`,
+		"",
+		"---",
+		""
+	];
+	for (const page of rows) {
+		const pageMd = renderPageAsMarkdown(page, locale, { siteUrl });
+		parts.push(pageMd, "", "---", "");
+	}
+	return parts.join("\n");
+}
+//#endregion
+export { ALLOWED_CHILDREN_MAP, BLOG_POST_DEFINITION, BlockRegistry, CARD_DEFINITION, CHARACTER_DEFINITION, CMS_MCP_TOOLS, DEFAULT_SITE_SETTINGS, DOCUMENT_DEFINITION, GROUP_DEFINITION, HERO_DEFINITION, ITEM_DEFINITION, LOCATION_DEFINITION, MAX_SECTION_DEPTH, MAX_SECTION_HEADING_LEVEL, MIN_SECTION_HEADING_LEVEL, OBJECT_DEFINITION, PAGE_MAP, PATCH_NOTE_DEFINITION, POSTGRES_SEARCH_CONFIGS, SERIES_DEFINITION, SKILL_DEFINITION, SPECIES_DEFINITION, addToast, assignEntryTerms, auth0Auth, blocksToMarkdown, bylines, calculateHeadingLevel, canUserCreateFromTemplate, canUserEditBlock, canUserEditFromTemplate, canUserInstantiateTemplate, canUserReviewFromTemplate, canUserViewFromTemplate, cfAccessAuth, clearToasts, cmsAc, cmsStatements, contentSearchIndex, createByline, createPageExcerpt, createTerm, defineDocsConfig, definePageDefinition, deleteByline, deleteR2File, deleteTerm, diffBlocks, diffPageSnapshots, evaluateAccess, extractHeadingsFromBlocks, extractTextFromBlocks, filterBlocksForReader, filterTemplatesForUser, formatDocsUrl, generatePreviewToken, getByline, getBylines, getCmsCollection, getCmsEntry, getDocsSidebar, getDocsVersions, getEntriesByTerm, getEntryTerms, getPageDefinition, getPostgresSearchConfig, getR2Bucket, getSiteSettings, getSurroundItems, getTaxonomyTerms, getTerm, handleCmsCron, handleCmsMcpRequest, hasLockedDescendants, hasPermission, hasRole, indexPageForSearch, inlinesToMarkdown, invalidatePageCache, isValidUUID, listR2Files, mockAuth, pageDraftLocks, pageDrafts, pageTaxonomyTerms, pageTemplates, pageVersionApprovals, pageVersionComments, pageVersions, pages, parseDocsSlug, r2, removeToast, renderCorpusMarkdown, renderPageAsMarkdown, rimelightCms, rimelightCmsLoader, showErrorToast, showSuccessToast, siteSettings, slugifyHeading, taxonomyTerms, toast, toasts, updateByline, updateSiteSettings, updateTerm, uploadR2File, validateBlockAST, validateServerBlockPayload, verifyPreviewToken };