@phtngyn/cms 0.2.0-beta.7 → 0.3.0

package/src/Module.js

@@ -1,170 +1,1047 @@
-import { d as STUDIO_APP_PATH, f as STUDIO_BASE_PATH, m as STUDIO_HEALTH_PATH, p as STUDIO_COLLABORATION_PATH, t as CMS_AUTHENTICATION_PATH, u as STUDIO_API_PATH } from "./HttpPaths-c9nLZ9H2.js";
-import { registerStudioApp } from "./internal/studio-app.js";
-import { cmsAuthoringPlugin } from "./internal/authoring-compiler.js";
-import { registerAuthoringCatalog } from "./internal/authoring-catalog.js";
-import { loadCmsConfiguration } from "./internal/cms-config.js";
-import { cmsRuntimeConfigurationDefaults, compileCmsConfiguration } from "./internal/configuration.js";
-import { generateCmsApplicationTypes } from "./internal/application-types.js";
-import { Effect, Layer } from "effect";
-import { NodeCrypto, NodeFileSystem, NodePath } from "@effect/platform-node-shared";
-import { addComponent, addImports, addPlugin, addServerHandler, addServerPlugin, addServerTemplate, addTemplate, addTypeTemplate, addVitePlugin, createResolver, defineNuxtModule, extendPages } from "@nuxt/kit";
-
-//#region src/Module.ts
-const CMS_SITEMAP_SOURCE_PATH = `${STUDIO_BASE_PATH}/sitemap`;
-const resolver = createResolver(import.meta.url);
-const nodeLayer = Layer.merge(NodeCrypto.layer, Layer.merge(NodeFileSystem.layer, NodePath.layer));
-const cmsNuxtModule = defineNuxtModule({
-	moduleDependencies: {
-		"@nuxtjs/robots": {},
-		"@nuxtjs/sitemap": {},
-		"@comark/nuxt": {},
-		"nuxt-schema-org": {},
-		"nuxt-site-config": {},
-		"nuxt-seo-utils": {}
-	},
-	meta: {
-		compatibility: { nuxt: ">=4.5.0 <5.0.0" },
-		name: "@phtngyn/cms"
-	},
-	setup(_options, nuxt) {
-		return Effect.runPromise(setupModule(nuxt).pipe(Effect.provide(nodeLayer)));
+import { r as defineLocales } from "./Locales-Ch7a5xuA.js";
+import { r as validateBlockConfiguration } from "./validation-3pggwcnm.js";
+import { n as FieldDefinition, t as CollectionDefinition } from "./Fields-ioGaMEh9.js";
+import { r as BlockSlot, t as BlockDefinition } from "./Blocks-BrxSemnd.js";
+import { c as defineStudioModules } from "./People-DvNZauWw.js";
+import { t as load } from "./Configuration-Dk2k3OIc.js";
+import { t as blockComponentName } from "./rendering-D9LVeEKX.js";
+import { Effect, Schema } from "effect";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { addComponent, addDevServerHandler, addImports, addNitroPlugin, addPluginTemplate, addServerHandler, addServerTemplate, addTypeTemplate, addVitePlugin, createResolver, defineNuxtModule, extendPages, extendRouteRules } from "@nuxt/kit";
+import { MagicString, parse } from "@vue/compiler-sfc";
+import ts from "typescript";
+//#region src/internal/authoringProgram.ts
+const options = {
+	strict: true,
+	noEmit: true,
+	skipLibCheck: true,
+	target: ts.ScriptTarget.ESNext,
+	module: ts.ModuleKind.ESNext,
+	moduleResolution: ts.ModuleResolutionKind.Bundler
+};
+/** One installation shares parsed dependencies and a checker across its block catalog. */
+function createAuthoringProgram() {
+	const scripts = /* @__PURE__ */ new Map();
+	const files = /* @__PURE__ */ new Map();
+	let dependencyStamps = /* @__PURE__ */ new Map();
+	const host = ts.createCompilerHost(options);
+	const getSourceFile = host.getSourceFile.bind(host);
+	const fileExists = host.fileExists.bind(host);
+	const readFile = host.readFile.bind(host);
+	let program;
+	let dirty = true;
+	host.getSourceFile = (filename, languageVersion, onError, shouldCreateNewSourceFile) => {
+		const cached = files.get(filename);
+		if (cached) return cached;
+		const source = scripts.get(filename);
+		const file = source === void 0 ? getSourceFile(filename, languageVersion, onError, shouldCreateNewSourceFile) : ts.createSourceFile(filename, source, languageVersion, true, ts.ScriptKind.TS);
+		if (file) files.set(filename, file);
+		return file;
+	};
+	host.fileExists = (filename) => scripts.has(filename) || fileExists(filename);
+	host.readFile = (filename) => scripts.get(filename) ?? readFile(filename);
+	function register(filename, source) {
+		if (scripts.get(filename) === source) return;
+		scripts.set(filename, source);
+		files.delete(filename);
+		dirty = true;
 	}
-});
-const setupModule = Effect.fn("CmsNuxtModule.setup")(function* (nuxt) {
-	addVitePlugin(cmsAuthoringPlugin());
-	const authored = yield* loadCmsConfiguration(nuxt.options.rootDir);
-	const compiled = compileCmsConfiguration(authored.configuration);
-	const i18n = compiled.i18n;
-	Object.assign(nuxt.options.runtimeConfig, { cms: cmsRuntimeConfigurationDefaults(authored.configuration, nuxt.options.runtimeConfig.cms) });
-	configureSitemap(nuxt.options);
-	const i18nTemplate = addTemplate({
-		filename: "cms/i18n.mjs",
-		write: true,
-		getContents: () => `export default JSON.parse(${JSON.stringify(JSON.stringify(i18n))})`
-	});
-	nuxt.options.alias["#cms/i18n"] = i18nTemplate.dst;
-	let blockNames = [];
-	const applicationTypes = addTypeTemplate({
-		filename: "types/cms-application.d.ts",
-		getContents: () => generateCmsApplicationTypes({
-			blockNames,
-			configurationPath: authored.path,
-			i18n
-		})
-	});
-	nuxt.options.alias["#cms/types"] = applicationTypes.dst;
-	nuxt.options.watch.push(authored.path);
-	const authoring = yield* registerAuthoringCatalog(nuxt, compiled.documents, Object.fromEntries(Object.entries(authored.configuration.forms ?? {}).map(([name, form]) => [name, form.definition])), (names) => {
-		blockNames = names;
-	}, [applicationTypes.dst]);
-	const installationPluginId = resolver.resolve("./runtime/plugin.virtual.mjs");
-	const installationPluginTemplate = addServerTemplate({
-		filename: installationPluginId,
-		getContents: () => [
-			`import { createInstallationPlugin } from ${JSON.stringify(resolver.resolve("./runtime/plugin"))}`,
-			`import cmsConfiguration from ${JSON.stringify(authored.path)}`,
-			`import authoring from ${JSON.stringify(authoring.dst)}`,
-			`export default createInstallationPlugin(cmsConfiguration, authoring)`
-		].join("\n")
-	});
-	addServerHandler({
-		handler: resolver.resolve("./runtime/api"),
-		route: `${STUDIO_HEALTH_PATH}/**:path`
-	});
-	addServerHandler({
-		handler: resolver.resolve("./runtime/sitemap"),
-		route: CMS_SITEMAP_SOURCE_PATH
-	});
-	registerDeliveryUi(nuxt);
-	yield* registerStudioApp(nuxt, resolver);
-	configureNitro(nuxt);
-	addServerPlugin(installationPluginTemplate.filename);
-	addServerHandler({
-		handler: resolver.resolve("./runtime/api"),
-		route: `${CMS_AUTHENTICATION_PATH}/**:path`
-	});
-	addServerHandler({
-		handler: resolver.resolve("./runtime/collaboration"),
-		route: STUDIO_COLLABORATION_PATH
-	});
-	addServerHandler({
-		handler: resolver.resolve("./runtime/api"),
-		route: `${STUDIO_API_PATH}/**:path`
-	});
-});
-function configureSitemap(options) {
-	if (options.sitemap === false) return;
-	const sitemap = options.sitemap ?? {};
-	const sources = sitemap.sources ?? [];
-	if (!sources.includes(CMS_SITEMAP_SOURCE_PATH)) sitemap.sources = [...sources, CMS_SITEMAP_SOURCE_PATH];
-	options.sitemap = sitemap;
-}
-function registerDeliveryUi(nuxt) {
-	addPlugin(resolver.resolve("./runtime/blocks"));
-	nuxt.options.css.push(resolver.resolve("./runtime/preview/preview.css"));
-	addComponent({
-		name: "DocumentField",
-		filePath: resolver.resolve("./runtime/delivery/DocumentField")
-	});
-	addComponent({
-		name: "DocumentRenderer",
-		filePath: resolver.resolve("./runtime/delivery/DocumentRenderer")
-	});
-	addComponent({
-		name: "DocumentScope",
-		filePath: resolver.resolve("./runtime/delivery/DocumentScope")
+	function check(filename, source) {
+		register(filename, source);
+		if (dirty || !program) {
+			program = ts.createProgram([...scripts.keys()], options, host, program);
+			dirty = false;
+			dependencyStamps = new Map(program.getSourceFiles().flatMap((file) => !scripts.has(file.fileName) && !file.fileName.includes("/node_modules/") ? [[file.fileName, fileStamp(file.fileName)]] : []));
+		}
+		const file = program.getSourceFile(filename);
+		if (!file) throw new Error(`${filename}: Vue type information is unavailable.`);
+		return {
+			file,
+			checker: program.getTypeChecker()
+		};
+	}
+	function dependencies() {
+		return [...dependencyStamps.keys()];
+	}
+	function refreshDependencies() {
+		let changed = false;
+		for (const [filename, stamp] of dependencyStamps) {
+			if (fileStamp(filename) === stamp) continue;
+			invalidate(filename);
+			changed = true;
+		}
+		return changed;
+	}
+	function invalidate(filename) {
+		files.delete(filename);
+		files.delete(`${filename}.ts`);
+		dependencyStamps.delete(filename);
+		program = void 0;
+		dirty = true;
+	}
+	return {
+		register,
+		check,
+		dependencies,
+		refreshDependencies,
+		invalidate
+	};
+}
+function fileStamp(filename) {
+	const stat = statSync(filename, {
+		bigint: true,
+		throwIfNoEntry: false
 	});
-	addPlugin(resolver.resolve("./runtime/delivery/plugin"));
-	addPlugin(resolver.resolve("./runtime/preview/plugin.client"));
-	addImports([
-		{
-			name: "useCmsI18n",
-			from: resolver.resolve("./runtime/i18n/useCmsI18n")
-		},
-		{
-			name: "useCmsForm",
-			from: resolver.resolve("./runtime/forms/useCmsForm")
-		},
-		{
-			name: "useCmsDocumentSeo",
-			from: resolver.resolve("./runtime/delivery/useCmsDocumentSeo")
-		},
-		{
-			name: "useDocument",
-			from: resolver.resolve("./runtime/delivery/useDocument")
-		},
-		{
-			name: "useDocumentQuery",
-			from: resolver.resolve("./runtime/delivery/useDocumentQuery")
+	return stat ? `${stat.mtimeNs}:${stat.size}` : "missing";
+}
+//#endregion
+//#region src/internal/authoring/metadata.ts
+/** Static declarations are read from syntax; site code is never evaluated. */
+function vueDefaults(calls, editable, fail) {
+	const values = {};
+	const has = /* @__PURE__ */ new Set();
+	const call = calls.find((candidate) => candidate.arguments[0] && ts.isCallExpression(candidate.arguments[0]) && ts.isIdentifier(candidate.arguments[0].expression) && candidate.arguments[0].expression.text === "defineProps");
+	if (!call) return {
+		values,
+		has
+	};
+	const value = call.arguments[1];
+	if (!value || !ts.isObjectLiteralExpression(value)) fail(call, "withDefaults needs a static object for CMS props.");
+	for (const property of value.properties) {
+		if (!ts.isPropertyAssignment(property) || !staticName(property.name)) fail(property, "withDefaults needs literal prop names for CMS blocks.");
+		const name = staticName(property.name);
+		if (!name) fail(property, "withDefaults needs literal prop names for CMS blocks.");
+		has.add(name);
+		if (editable.has(name)) values[name] = jsonValue(property.initializer, fail);
+	}
+	return {
+		values,
+		has
+	};
+}
+function objectValue(node, fail) {
+	const value = {};
+	for (const property of node.properties) {
+		if (!ts.isPropertyAssignment(property) || !property.name || !staticName(property.name)) fail(property, "CMS metadata needs literal named properties; spreads and methods are unsupported.");
+		const name = staticName(property.name);
+		if (!name) fail(property, "CMS metadata needs literal property names.");
+		if (Object.hasOwn(value, name)) fail(property, `Duplicate CMS property "${name}".`);
+		value[name] = jsonValue(property.initializer, fail);
+	}
+	return Schema.decodeSync(Schema.JsonObject)(value);
+}
+function jsonValue(node, fail) {
+	if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isParenthesizedExpression(node)) return jsonValue(node.expression, fail);
+	if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) return jsonValue(node.body, fail);
+	if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (ts.isNumericLiteral(node)) return Number(node.text);
+	if (node.kind === ts.SyntaxKind.TrueKeyword) return true;
+	if (node.kind === ts.SyntaxKind.FalseKeyword) return false;
+	if (node.kind === ts.SyntaxKind.NullKeyword) return null;
+	if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(node.operand)) return -Number(node.operand.text);
+	if (ts.isArrayLiteralExpression(node)) return node.elements.map((element) => jsonValue(element, fail));
+	if (ts.isObjectLiteralExpression(node)) return objectValue(node, fail);
+	return fail(node, "CMS metadata must contain static JSON values.");
+}
+function staticName(node) {
+	return ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) ? node.text : void 0;
+}
+function record(value, node, fail, label) {
+	if (!Schema.is(Schema.JsonObject)(value)) fail(node, `${label} must be an object.`);
+	return value;
+}
+function string(value, node, fail, label) {
+	if (!Schema.is(Schema.NonEmptyString)(value)) fail(node, `${label} must be a nonempty string.`);
+	return value;
+}
+function strings(value, node, fail) {
+	if (!Schema.is(Schema.Array(Schema.String))(value)) fail(node, "Expected a string array.");
+	return value;
+}
+function keys(value, allowed, node, fail) {
+	for (const key of Object.keys(value)) if (!allowed.includes(key)) fail(node, `Unknown CMS metadata key "${key}".`);
+}
+//#endregion
+//#region src/internal/authoring/fields.ts
+/** Editable fields must agree with the component's checked Vue prop types. */
+function fieldFromType(name, metadata, rawType, required, defaultValue, checker, node, fail) {
+	keys(metadata, [
+		"label",
+		"description",
+		"input",
+		"optionLabels",
+		"mediaKind",
+		"collections",
+		"fields"
+	], node, fail);
+	const label = string(metadata.label, node, fail, `${name}.label`);
+	const description = metadata.description === void 0 ? void 0 : string(metadata.description, node, fail, "description");
+	const common = {
+		name,
+		label,
+		required
+	};
+	if (description !== void 0) Object.assign(common, { description });
+	const type = checker.getNonNullableType(rawType);
+	const members = type.isUnion() ? type.types : [type];
+	const choices = literalChoices(type);
+	const input = metadata.input === void 0 ? inferInput(type, checker) : string(metadata.input, node, fail, "input");
+	if (input === "select" || input === "multi-select") {
+		if (input === "select" && !stringType(type)) fail(node, `${name} needs a string Vue prop for select.`);
+		const item = input === "multi-select" ? checker.getIndexTypeOfType(type, ts.IndexKind.Number) : void 0;
+		if (input === "multi-select" && (!item || !stringType(item))) fail(node, `${name} needs a string array Vue prop for multi-select.`);
+		const labels = record(metadata.optionLabels ?? {}, node, fail, "optionLabels");
+		const inferredChoices = input === "multi-select" && item ? literalChoices(item) : choices;
+		const values = inferredChoices.length ? inferredChoices : Object.keys(labels);
+		if (input === "select" && !values.length) fail(node, `${name} needs literal string choices or optionLabels.`);
+		for (const key of Object.keys(labels)) if (!values.includes(key)) fail(node, `${name} has unknown choice "${key}".`);
+		const options = values.map((value) => ({
+			value,
+			label: labels[value] === void 0 ? humanize(value) : string(labels[value], node, fail, "option label")
+		}));
+		const field = {
+			...common,
+			kind: input,
+			options
+		};
+		if (defaultValue !== void 0) Object.assign(field, { defaultValue });
+		return decodeField(field, node, fail);
+	}
+	if (input === "object" || input === "list") {
+		const nested = record(metadata.fields, node, fail, `${name}.fields`);
+		const item = input === "list" ? checker.getIndexTypeOfType(type, ts.IndexKind.Number) : type;
+		if (!item || !(item.flags & ts.TypeFlags.Object)) fail(node, `${name} needs an object${input === "list" ? " list" : ""} Vue type.`);
+		if (input === "list") {
+			const id = item.getProperty("id");
+			const idType = id && checker.getTypeOfSymbolAtLocation(id, id.valueDeclaration ?? node);
+			if (!id || id.flags & ts.SymbolFlags.Optional || !idType || !stringType(idType)) fail(node, `${name} list items need a required string id.`);
+			if (Object.hasOwn(nested, "id")) fail(node, `${name}.id is managed by Studio.`);
 		}
-	]);
-	extendPages((pages) => {
-		pages.push({
-			file: resolver.resolve("./runtime/delivery/document"),
-			name: "cms-document-page",
-			path: "/:contentPath(.*)*",
-			meta: { cmsDocument: true }
+		const fields = Object.entries(nested).map(([key, raw]) => {
+			const property = item.getProperty(key);
+			if (!property) fail(node, `${name}.${key} does not exist in the Vue type.`);
+			const member = checker.getTypeOfSymbolAtLocation(property, property.valueDeclaration ?? node);
+			return fieldFromType(key, record(raw, node, fail, `${name}.${key}`), member, !(property.flags & ts.SymbolFlags.Optional), void 0, checker, node, fail);
 		});
-	});
+		for (const property of item.getProperties()) if (property.name !== "id" && !(property.flags & ts.SymbolFlags.Optional) && !Object.hasOwn(nested, property.name)) fail(node, `${name}.${property.name} is required by Vue and needs an authoring declaration.`);
+		return decodeField({
+			...common,
+			kind: input,
+			fields
+		}, node, fail);
+	}
+	if (input === "image") {
+		if (!(type.flags & ts.TypeFlags.Object)) fail(node, `${name} needs an image object Vue prop.`);
+		return decodeField({
+			...common,
+			kind: "image"
+		}, node, fail);
+	}
+	if (input === "link") {
+		if (!stringType(type)) fail(node, `${name} needs a string Vue prop for resolved links.`);
+		if (defaultValue !== void 0 && !Schema.is(Schema.String)(defaultValue)) fail(node, `${name} needs a string Vue default.`);
+		const field = {
+			...common,
+			kind: "link"
+		};
+		if (defaultValue !== void 0) Object.assign(field, { defaultValue: {
+			kind: "url",
+			href: defaultValue
+		} });
+		return decodeField(field, node, fail);
+	}
+	if (input === "media") {
+		if (!stringType(type)) fail(node, `${name} needs a string Vue prop for resolved media.`);
+		const mediaKind = string(metadata.mediaKind, node, fail, `${name}.mediaKind`);
+		return decodeField({
+			...common,
+			kind: "media",
+			mediaKind
+		}, node, fail);
+	}
+	if (input === "document") {
+		if (!stringType(type)) fail(node, `${name} needs a string Vue prop for document IDs.`);
+		const field = {
+			...common,
+			kind: "document"
+		};
+		if (metadata.collections !== void 0) Object.assign(field, { collections: strings(metadata.collections, node, fail) });
+		return decodeField(field, node, fail);
+	}
+	if (![
+		"text",
+		"textarea",
+		"date",
+		"icon",
+		"number",
+		"boolean"
+	].includes(input)) fail(node, `${name} has unsupported input "${input}".`);
+	if (!(input === "number" && members.every((item) => item.flags & ts.TypeFlags.NumberLike) || input === "boolean" && members.every((item) => item.flags & ts.TypeFlags.BooleanLike) || [
+		"text",
+		"textarea",
+		"date",
+		"icon"
+	].includes(input) && stringType(type))) fail(node, `${name} uses ${input}, which does not match its Vue prop type.`);
+	const field = {
+		...common,
+		kind: input
+	};
+	if (defaultValue !== void 0) Object.assign(field, { defaultValue });
+	return decodeField(field, node, fail);
+}
+function decodeField(field, node, fail) {
+	try {
+		return Schema.decodeUnknownSync(FieldDefinition)(field);
+	} catch (cause) {
+		return fail(node, `Invalid prop "${field.name}": ${String(cause)}`);
+	}
+}
+function inferInput(type, checker) {
+	if (literalChoices(type).length) return "select";
+	const members = type.isUnion() ? type.types : [type];
+	if (stringType(type)) return "text";
+	if (members.every((item) => item.flags & ts.TypeFlags.NumberLike)) return "number";
+	if (members.every((item) => item.flags & ts.TypeFlags.BooleanLike)) return "boolean";
+	const item = checker.getIndexTypeOfType(type, ts.IndexKind.Number);
+	if (item && stringType(item)) return "multi-select";
+	return "";
 }
-function configureNitro(nuxt) {
-	nuxt.hook("nitro:config", (config) => {
-		config.experimental ||= {};
-		config.experimental.websocket = true;
-		config.routeRules ||= {};
-		const studioRules = {
-			ssr: false,
-			headers: { "cache-control": "no-store" }
+function stringType(type) {
+	return (type.isUnion() ? type.types : [type]).every((member) => Boolean(member.flags & ts.TypeFlags.StringLike));
+}
+function literalChoices(type) {
+	const members = type.isUnion() ? type.types : [type];
+	return members.every((member) => member.isStringLiteral()) ? members.flatMap((member) => member.isStringLiteral() ? [member.value] : []) : [];
+}
+function humanize(value) {
+	return value.replaceAll("-", " ").replace(/\b\w/gu, (letter) => letter.toUpperCase());
+}
+//#endregion
+//#region src/internal/authoringCompiler.ts
+const authoringImport = "@phtngyn/cms/Authoring";
+function parseBlock(source, filename) {
+	const parsed = parse(source, { filename });
+	if (parsed.errors.length) throw new Error(`${filename}: ${parsed.errors.join("\n")}`);
+	const setup = parsed.descriptor.scriptSetup;
+	if (!setup || setup.lang !== "ts") throw new Error(`${filename}: CMS blocks need <script setup lang="ts">.`);
+	return {
+		parsed,
+		setup
+	};
+}
+function createAuthoringCompiler() {
+	const program = createAuthoringProgram();
+	const results = /* @__PURE__ */ new Map();
+	function invalidate(filename) {
+		program.invalidate(filename);
+		results.clear();
+	}
+	function compile(source, filename) {
+		if (program.refreshDependencies()) results.clear();
+		const cached = results.get(filename);
+		if (cached?.source === source) return cached.compiled;
+		const compiled = compileBlock(source, filename, program);
+		results.set(filename, {
+			source,
+			compiled
+		});
+		return compiled;
+	}
+	function compileMany(entries) {
+		for (const entry of entries) program.register(`${entry.filename}.ts`, parseBlock(entry.source, entry.filename).setup.content);
+		return entries.map((entry) => compile(entry.source, entry.filename));
+	}
+	function trackDependencies(filename, source) {
+		program.check(filename, source);
+	}
+	return {
+		compile,
+		compileMany,
+		invalidate,
+		trackDependencies,
+		dependencies: program.dependencies
+	};
+}
+function compileBlock(source, filename, program) {
+	const { parsed, setup } = parseBlock(source, filename);
+	const { file, checker } = program.check(`${filename}.ts`, setup.content);
+	const fail = (node, message) => {
+		const offset = setup.loc.start.offset + node.getStart(file);
+		const before = source.slice(0, offset);
+		const line = before.split("\n").length;
+		const column = offset - before.lastIndexOf("\n");
+		throw new Error(`${filename}:${line}:${column}: ${message}`);
+	};
+	const imports = file.statements.filter((node) => ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier) && node.moduleSpecifier.text === authoringImport);
+	const importNode = imports[0];
+	if (imports.length !== 1 || !importNode?.importClause?.namedBindings || !ts.isNamedImports(importNode.importClause.namedBindings) || importNode.importClause.namedBindings.elements.length !== 1 || importNode.importClause.namedBindings.elements[0]?.name.text !== "defineCmsBlock" || importNode.importClause.namedBindings.elements[0]?.propertyName) return fail(file, "Import only { defineCmsBlock } from @phtngyn/cms/Authoring.");
+	const statements = file.statements.filter((node) => ts.isExpressionStatement(node) && ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "defineCmsBlock");
+	const statement = statements[0];
+	if (statements.length !== 1 || !statement || !ts.isCallExpression(statement.expression)) return fail(file, "Call defineCmsBlock exactly once as a top-level statement.");
+	const call = statement.expression;
+	const argument = call.arguments[0];
+	if (call.arguments.length !== 1 || !argument || !ts.isObjectLiteralExpression(argument)) return fail(call, "defineCmsBlock needs one static object literal.");
+	if (call.typeArguments?.length !== 1 && call.typeArguments?.length !== 2) return fail(call, "Share named Props and optional Slots types with defineProps and defineSlots.");
+	const propsTypeNode = call.typeArguments[0];
+	const slotsTypeNode = call.typeArguments[1];
+	if (!propsTypeNode || !ts.isTypeReferenceNode(propsTypeNode) || slotsTypeNode && !ts.isTypeReferenceNode(slotsTypeNode)) return fail(call, "defineCmsBlock type arguments must be named types.");
+	const vueCalls = /* @__PURE__ */ new Map();
+	const walk = (node) => {
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+			const calls = vueCalls.get(node.expression.text) ?? [];
+			calls.push(node);
+			vueCalls.set(node.expression.text, calls);
+		}
+		ts.forEachChild(node, walk);
+	};
+	walk(file);
+	const authoringCalls = vueCalls.get("defineCmsBlock") ?? [];
+	if (authoringCalls.length !== 1 || authoringCalls[0] !== call) fail(call, "defineCmsBlock may only be used in its top-level declaration.");
+	const vueProps = vueCalls.get("defineProps") ?? [];
+	const vueSlots = vueCalls.get("defineSlots") ?? [];
+	if (vueProps.length !== 1 || vueProps[0]?.typeArguments?.[0]?.getText(file) !== propsTypeNode.getText(file)) fail(call, "defineProps must use the same Props type as defineCmsBlock.");
+	if (slotsTypeNode && (vueSlots.length !== 1 || vueSlots[0]?.typeArguments?.[0]?.getText(file) !== slotsTypeNode.getText(file))) fail(call, "defineSlots must use the same Slots type as defineCmsBlock.");
+	if (!slotsTypeNode && vueSlots.length) fail(call, "Pass the defineSlots type to defineCmsBlock.");
+	const declaration = objectValue(argument, fail);
+	keys(declaration, [
+		"name",
+		"label",
+		"description",
+		"group",
+		"icon",
+		"props",
+		"slots",
+		"form",
+		"handler"
+	], call, fail);
+	const name = string(declaration.name, call, fail, "name");
+	const label = string(declaration.label, call, fail, "label");
+	const propMetadata = record(declaration.props ?? {}, call, fail, "props");
+	const slotMetadata = record(declaration.slots ?? {}, call, fail, "slots");
+	const defaults = vueDefaults(vueCalls.get("withDefaults") ?? [], new Set(Object.keys(propMetadata)), fail);
+	const propsType = checker.getTypeFromTypeNode(propsTypeNode);
+	const slotsType = slotsTypeNode ? checker.getTypeFromTypeNode(slotsTypeNode) : void 0;
+	const fields = [];
+	const slots = [];
+	for (const [key, raw] of Object.entries(propMetadata)) {
+		const property = propsType.getProperty(key);
+		if (!property) return fail(call, `Editable prop "${key}" does not exist in Props.`);
+		const metadata = record(raw, call, fail, `props.${key}`);
+		const type = checker.getTypeOfSymbolAtLocation(property, property.valueDeclaration ?? propsTypeNode);
+		const required = !(property.flags & ts.SymbolFlags.Optional);
+		fields.push(fieldFromType(key, metadata, type, required, defaults.values[key], checker, call, fail));
+	}
+	for (const property of propsType.getProperties()) if (!(property.flags & ts.SymbolFlags.Optional) && !defaults.has.has(property.name) && !Object.hasOwn(propMetadata, property.name) && !(declaration.form && property.name === "cmsForm")) fail(call, `Required prop "${property.name}" needs an authoring declaration or a Vue default.`);
+	for (const [key, raw] of Object.entries(slotMetadata)) {
+		const property = slotsType?.getProperty(key);
+		if (!property) return fail(call, `Editable slot "${key}" does not exist in Slots.`);
+		const slotType = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(property, property.valueDeclaration ?? slotsTypeNode ?? call));
+		const signatures = checker.getSignaturesOfType(slotType, ts.SignatureKind.Call);
+		if (signatures.length !== 1 || signatures[0]?.parameters.length) fail(call, `Editable slot "${key}" must be an unscoped Vue slot.`);
+		const metadata = record(raw, call, fail, `slots.${key}`);
+		keys(metadata, [
+			"label",
+			"input",
+			"features",
+			"blocks",
+			"groups",
+			"initial"
+		], call, fail);
+		const initial = metadata.initial;
+		const slot = {
+			name: key,
+			label: string(metadata.label, call, fail, `slots.${key}.label`),
+			kind: string(metadata.input, call, fail, `slots.${key}.input`),
+			required: !(property.flags & ts.SymbolFlags.Optional)
 		};
-		config.routeRules[`${STUDIO_APP_PATH}/**`] = studioRules;
-		config.routeRules[STUDIO_APP_PATH] = studioRules;
-		config.routeRules[STUDIO_BASE_PATH] = { redirect: {
-			statusCode: 302,
-			to: STUDIO_APP_PATH
-		} };
-	});
+		if (metadata.features !== void 0) Object.assign(slot, { features: strings(metadata.features, call, fail) });
+		if (metadata.blocks !== void 0) Object.assign(slot, { blocks: strings(metadata.blocks, call, fail) });
+		if (metadata.groups !== void 0) Object.assign(slot, { groups: strings(metadata.groups, call, fail) });
+		if (initial !== void 0) Object.assign(slot, { initial: slotInitial(initial, call, fail) });
+		try {
+			slots.push(Schema.decodeUnknownSync(BlockSlot)(slot));
+		} catch (cause) {
+			fail(call, `Invalid slot "${key}": ${String(cause)}`);
+		}
+	}
+	for (const property of slotsType?.getProperties() ?? []) if (!(property.flags & ts.SymbolFlags.Optional) && !Object.hasOwn(slotMetadata, property.name)) fail(call, `Required slot "${property.name}" needs an authoring declaration.`);
+	validateSlotOutlets(parsed.descriptor.template?.ast, new Set(slots.map((slot) => slot.name)), filename);
+	const block = {
+		name,
+		label,
+		fields,
+		slots
+	};
+	if (declaration.description !== void 0) Object.assign(block, { description: string(declaration.description, call, fail, "description") });
+	if (declaration.group !== void 0) Object.assign(block, { group: string(declaration.group, call, fail, "group") });
+	if (declaration.icon !== void 0) Object.assign(block, { icon: string(declaration.icon, call, fail, "icon") });
+	if (declaration.form !== void 0) Object.assign(block, { form: declaration.form });
+	const definition = (() => {
+		try {
+			return Schema.decodeSync(BlockDefinition)(block);
+		} catch (cause) {
+			return fail(call, `Invalid block declaration: ${String(cause)}`);
+		}
+	})();
+	const handler = declaration.handler === void 0 ? void 0 : string(declaration.handler, call, fail, "handler");
+	if (handler && !declaration.form) fail(call, "A handler requires a form declaration.");
+	const code = new MagicString(source);
+	code.remove(setup.loc.start.offset + importNode.getStart(file), setup.loc.start.offset + importNode.end);
+	code.remove(setup.loc.start.offset + statement.getStart(file), setup.loc.start.offset + statement.end);
+	return {
+		filename,
+		definition,
+		handler,
+		code: code.toString(),
+		map: code.generateMap({
+			source: filename,
+			hires: true
+		})
+	};
+}
+function slotInitial(value, node, fail) {
+	if (Schema.is(Schema.String)(value)) return [{
+		type: "paragraph",
+		content: [{
+			type: "text",
+			text: value
+		}]
+	}];
+	if (!Schema.is(Schema.Array(Schema.JsonObject))(value)) fail(node, "Slot initial content must be text or an array of ProseMirror nodes.");
+	return value;
+}
+function validateSlotOutlets(template, names, filename) {
+	if (!names.size) return;
+	const found = /* @__PURE__ */ new Set();
+	function visit(node) {
+		const element = node.type === 1 ? node : void 0;
+		if (element?.tag === "slot") {
+			if (element.props.some((property) => property.type === 7 && property.name === "bind" && property.arg?.type === 4 && property.arg.isStatic && property.arg.content === "name")) throw new Error(`${filename}: authored slot outlets need a static name.`);
+			const attribute = element.props.find((property) => property.type === 6 && property.name === "name");
+			found.add(attribute?.value?.content ?? "default");
+		}
+		if (node.type === 0 || node.type === 1) for (const child of node.children) visit(child);
+	}
+	if (template) visit(template);
+	for (const name of names) if (!found.has(name)) throw new Error(`${filename}: authored slot "${name}" needs a <slot name="${name}"> outlet.`);
+}
+//#endregion
+//#region src/internal/blockCatalog.ts
+/** app/cms/blocks is the sole site-level block registry. */
+async function discoverBlocks(rootDir, compiler = createAuthoringCompiler()) {
+	const directory = resolve(rootDir, "app/cms/blocks");
+	const blocks = [];
+	const names = /* @__PURE__ */ new Map();
+	const files = [];
+	if (!existsSync(directory)) return blocks;
+	async function visit(path) {
+		for (const entry of await readdir(path, { withFileTypes: true })) {
+			const filename = join(path, entry.name);
+			if (entry.isDirectory()) {
+				await visit(filename);
+				continue;
+			}
+			if (!entry.isFile() || !entry.name.endsWith(".vue")) continue;
+			files.push(filename);
+		}
+	}
+	await visit(directory);
+	const entries = await Promise.all(files.map(async (filename) => ({
+		filename,
+		source: await readFile(filename, "utf8")
+	})));
+	const compiledBlocks = compiler.compileMany(entries);
+	for (const compiled of compiledBlocks) {
+		const { filename } = compiled;
+		const previous = names.get(compiled.definition.name);
+		if (previous) throw new Error(`CMS block "${compiled.definition.name}" is declared in both ${previous} and ${filename}.`);
+		names.set(compiled.definition.name, filename);
+		if (compiled.handler && !existsSync(resolve(rootDir, compiled.handler))) throw new Error(`${filename}: form handler does not exist: ${compiled.handler}`);
+		const block = Object.assign({ component: `./${relative(rootDir, filename)}` }, compiled.definition);
+		if (compiled.handler !== void 0) Object.assign(block, { handler: compiled.handler });
+		blocks.push(block);
+	}
+	blocks.sort((first, second) => first.name.localeCompare(second.name));
+	return blocks;
 }
-
 //#endregion
-export { cmsNuxtModule as default };
-//# sourceMappingURL=Module.js.map
+//#region src/internal/previewCompiler.ts
+/** Add preview-only provenance bindings without changing the site's authored values or markup layout. */
+function compilePreviewTemplate(source, filename, runtime) {
+	const { descriptor, errors } = parse(source, { filename });
+	if (errors.length || !descriptor.template?.ast || descriptor.script && !descriptor.scriptSetup) return null;
+	const setup = descriptor.scriptSetup;
+	const file = ts.createSourceFile(filename, setup?.content ?? "", ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS);
+	const propAliases = /* @__PURE__ */ new Set();
+	const propNames = /* @__PURE__ */ new Map();
+	function findProps(node) {
+		if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineProps") {
+			let parent = node.parent;
+			if (ts.isCallExpression(parent)) parent = parent.parent;
+			if (ts.isVariableDeclaration(parent)) {
+				if (ts.isIdentifier(parent.name)) propAliases.add(parent.name.text);
+				else if (ts.isObjectBindingPattern(parent.name)) {
+					for (const element of parent.name.elements) if (ts.isIdentifier(element.name)) propNames.set(element.name.text, element.propertyName?.getText(file) ?? element.name.text);
+				}
+			}
+			const type = node.typeArguments?.[0];
+			const members = type && ts.isTypeLiteralNode(type) ? type.members : type && ts.isTypeReferenceNode(type) ? file.statements.flatMap((statement) => ts.isInterfaceDeclaration(statement) && statement.name.text === type.typeName.getText(file) ? [...statement.members] : ts.isTypeAliasDeclaration(statement) && statement.name.text === type.typeName.getText(file) && ts.isTypeLiteralNode(statement.type) ? [...statement.type.members] : []) : [];
+			for (const member of members) if (ts.isPropertySignature(member) && member.name && (ts.isIdentifier(member.name) || ts.isStringLiteral(member.name))) propNames.set(member.name.text, member.name.text);
+		}
+		ts.forEachChild(node, findProps);
+	}
+	findProps(file);
+	function expressionSources(expression) {
+		const expressionFile = ts.createSourceFile("expression.ts", `(${expression})`, ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS);
+		const found = /* @__PURE__ */ new Set();
+		function access(node) {
+			return ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) && access(node.expression) || ts.isElementAccessExpression(node) && access(node.expression) && !!node.argumentExpression && (ts.isIdentifier(node.argumentExpression) || ts.isStringLiteral(node.argumentExpression) || ts.isNumericLiteral(node.argumentExpression));
+		}
+		function read(node) {
+			if (ts.isPropertyAccessExpression(node)) return `${read(node.expression)}?.${node.name.text}`;
+			if (ts.isElementAccessExpression(node) && node.argumentExpression) return `${read(node.expression)}?.[${node.argumentExpression.getText(expressionFile)}]`;
+			return node.getText(expressionFile);
+		}
+		function visit(node) {
+			if (ts.isBinaryExpression(node) && access(node.left) && [
+				ts.SyntaxKind.QuestionQuestionToken,
+				ts.SyntaxKind.BarBarToken,
+				ts.SyntaxKind.AmpersandAmpersandToken
+			].includes(node.operatorToken.kind)) {
+				const left = expressionSources(node.left.getText(expressionFile)).join(", ");
+				const right = expressionSources(node.right.getText(expressionFile)).join(", ");
+				const condition = node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ? `${read(node.left)} != null` : read(node.left);
+				const first = node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ? right : left;
+				const second = node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ? left : right;
+				if (left || right) found.add(`cmsPreviewSource.combine(${condition} ? [${first}] : [${second}])`);
+				return;
+			}
+			if (ts.isCallExpression(node)) {
+				if (ts.isPropertyAccessExpression(node.expression)) visit(node.expression.expression);
+				for (const argument of node.arguments) visit(argument);
+				return;
+			}
+			if (ts.isPropertyAccessExpression(node)) {
+				const base = node.expression;
+				if (!access(base)) {
+					visit(base);
+					return;
+				}
+				if (ts.isIdentifier(base) && propAliases.has(base.text)) found.add(`cmsPreviewSource.prop(${JSON.stringify(node.name.text)})`);
+				else found.add(`cmsPreviewSource.property(${read(base)}, ${JSON.stringify(node.name.text)})`);
+				return;
+			}
+			if (ts.isElementAccessExpression(node) && node.argumentExpression && ts.isStringLiteral(node.argumentExpression)) {
+				if (access(node.expression)) found.add(`cmsPreviewSource.property(${read(node.expression)}, ${JSON.stringify(node.argumentExpression.text)})`);
+				return;
+			}
+			if (ts.isIdentifier(node) && propNames.has(node.text)) found.add(`cmsPreviewSource.prop(${JSON.stringify(propNames.get(node.text))})`);
+			else ts.forEachChild(node, visit);
+		}
+		visit(expressionFile);
+		return [...found];
+	}
+	const code = new MagicString(source);
+	let changed = false;
+	function visit(node) {
+		if (node.type !== 0 && node.type !== 1) return;
+		if (node.type === 1 && ![
+			"template",
+			"slot",
+			"Teleport",
+			"Suspense",
+			"KeepAlive",
+			"Transition",
+			"TransitionGroup"
+		].includes(node.tag)) {
+			const sources = /* @__PURE__ */ new Set();
+			const properties = [];
+			const loop = node.props.find((property) => property.type === 7 && property.name === "for");
+			const alias = loop?.type === 7 && loop.exp?.type === 4 ? /^\s*\(?\s*([A-Za-z_$][\w$]*)\s*(?:[,)]|\s+(?:in|of)\b)/u.exec(loop.exp.content)?.[1] : null;
+			if (alias) sources.add(`cmsPreviewSource.object(${alias})`);
+			for (const property of node.props) {
+				if (property.type !== 7 || property.name !== "bind" || property.exp?.type !== 4 || property.arg?.type !== 4 || !property.arg.isStatic || property.arg.content === "key") continue;
+				const candidates = expressionSources(property.exp.content);
+				for (const candidate of candidates) sources.add(candidate);
+				if (candidates.length) properties.push(`${JSON.stringify(property.arg.content.replace(/-([a-z])/gu, (_match, letter) => letter.toUpperCase()))}: cmsPreviewSource.combine([${candidates.join(", ")}])`);
+			}
+			for (const child of node.children) {
+				if (child.type !== 5 || child.content.type !== 4) continue;
+				if (node.props.some((property) => property.type === 7 && property.name === "slot" && property.exp)) continue;
+				for (const candidate of expressionSources(child.content.content)) sources.add(candidate);
+			}
+			if (sources.size) {
+				changed = true;
+				const candidates = [...sources].join(", ");
+				if (node.tagType === 1) wrapComponent(node, candidates, properties);
+				else code.appendLeft(node.loc.start.offset + 1 + node.tag.length, ` :data-cms-source="cmsPreviewSource.encode([${escapeAttribute(candidates)}])"`);
+			}
+		}
+		for (const child of node.children) visit(child);
+	}
+	function wrapComponent(node, candidates, properties) {
+		const controls = node.props.filter((property) => property.type === 7 && ([
+			"if",
+			"else-if",
+			"else",
+			"for"
+		].includes(property.name) || property.name === "bind" && property.arg?.type === 4 && property.arg.content === "key"));
+		for (const control of controls) code.remove(control.loc.start.offset, control.loc.end.offset);
+		const directives = controls.map((control) => control.loc.source).join(" ");
+		code.appendLeft(node.loc.start.offset, `<CmsPreviewSourceRegion ${directives} :source="cmsPreviewSource.combine([${escapeAttribute(candidates)}])" :properties="{${escapeAttribute(properties.join(", "))}}">`);
+		code.appendRight(node.loc.end.offset, "</CmsPreviewSourceRegion>");
+	}
+	visit(descriptor.template.ast);
+	if (!changed) return null;
+	const helper = `\nimport { CmsPreviewRegion as CmsPreviewSourceRegion, useCmsPreviewSource as useCmsPreviewSourceGenerated } from ${JSON.stringify(runtime)}\nconst cmsPreviewSource = useCmsPreviewSourceGenerated()\n`;
+	if (setup) code.appendLeft(setup.loc.start.offset, helper);
+	else code.appendLeft(0, `<script setup lang="ts">${helper}<\/script>\n`);
+	return {
+		code: code.toString(),
+		map: code.generateMap({
+			source: filename,
+			hires: true
+		})
+	};
+}
+function escapeAttribute(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;");
+}
+//#endregion
+//#region src/internal/siteTypes.ts
+/** Types come from the authored fields; retained saved content may need readable recovery. */
+function generateSiteTypes(collections, blocks, collectionsFile) {
+	const blockNames = union(blocks.map((block) => block.name));
+	const collectionNames = union(collections.map((collection) => collection.collection));
+	const fields = collections.map((collection) => `  readonly ${JSON.stringify(collection.collection)}: import('@phtngyn/cms/Collections').CmsCollectionFields<Extract<SiteCollections[number], { readonly collection: ${JSON.stringify(collection.collection)} }>>`).join("\n");
+	return [
+		"/* Generated by @phtngyn/cms from the site catalog. */",
+		`type SiteCollections = typeof import(${JSON.stringify(collectionsFile)})['default']`,
+		`export type CmsBlockName = ${blockNames}`,
+		`export type CmsCollectionName = ${collectionNames}`,
+		"export interface CmsPublishedFieldsByCollection {",
+		fields,
+		"}",
+		"export type CmsPublishedFields<Collection extends CmsCollectionName> = CmsPublishedFieldsByCollection[Collection]",
+		"export type CmsDraftFields<Collection extends CmsCollectionName> = { readonly [Key in keyof CmsPublishedFields<Collection>]?: unknown }",
+		""
+	].join("\n");
+}
+function union(values, fallback = "never") {
+	return values.length ? [...new Set(values)].map((value) => JSON.stringify(value)).join(" | ") : fallback;
+}
+//#endregion
+//#region src/internal/collectionCatalog.ts
+/** Collection authoring owns the catalog; Nuxt only decodes the serializable installation input. */
+function collectionCatalog(collections) {
+	return collections.map((collection) => Schema.decodeSync(CollectionDefinition)(collection));
+}
+//#endregion
+//#region src/internal/studioAssets.ts
+/** Nitro's dev static server recompresses each request; Studio already ships compressed files. */
+function createStudioAssetHandler(directory) {
+	const root = resolve(directory);
+	const baseURL = "/_cms/assets/";
+	const contentTypes = /* @__PURE__ */ new Map([
+		["js", "text/javascript; charset=utf-8"],
+		["css", "text/css; charset=utf-8"],
+		["png", "image/png"],
+		["jpg", "image/jpeg"],
+		["jpeg", "image/jpeg"],
+		["webp", "image/webp"],
+		["gif", "image/gif"],
+		["svg", "image/svg+xml"]
+	]);
+	return async (request) => {
+		if (request.method !== "GET" && request.method !== "HEAD") return new Response(null, { status: 405 });
+		let path;
+		try {
+			const pathname = new URL(request.url).pathname;
+			if (!pathname.startsWith(baseURL)) return new Response(null, { status: 404 });
+			path = resolve(root, decodeURIComponent(pathname.slice(13)));
+		} catch {
+			return new Response(null, { status: 400 });
+		}
+		const contentType = contentTypes.get(path.split(".").at(-1) ?? "");
+		if (!path.startsWith(`${root}${sep}`) || !contentType) return new Response(null, { status: 404 });
+		const candidates = [...(request.headers.get("accept-encoding") ?? "").split(",").map((entry) => {
+			const [encoding, ...parameters] = entry.trim().split(";");
+			const quality = parameters.find((value) => value.trim().startsWith("q="))?.trim().slice(2);
+			return {
+				encoding,
+				quality: quality === void 0 ? 1 : Number(quality)
+			};
+		}).filter(({ encoding, quality }) => (encoding === "br" || encoding === "gzip") && quality > 0).sort((left, right) => right.quality - left.quality || (left.encoding === "br" ? -1 : 1)).map(({ encoding }) => ({
+			encoding,
+			path: `${path}.${encoding === "br" ? "br" : "gz"}`
+		})), {
+			encoding: "",
+			path
+		}];
+		for (const candidate of candidates) {
+			const file = await stat(candidate.path).catch(() => null);
+			if (!file?.isFile()) continue;
+			const headers = new Headers({
+				"content-type": contentType,
+				"content-length": String(file.size),
+				"cache-control": "no-cache",
+				vary: "Accept-Encoding",
+				etag: `"${file.size}-${file.mtimeMs}"`
+			});
+			if (candidate.encoding) headers.set("content-encoding", candidate.encoding);
+			if (request.headers.get("if-none-match") === headers.get("etag")) {
+				headers.delete("content-length");
+				return new Response(null, {
+					status: 304,
+					headers
+				});
+			}
+			return new Response(request.method === "HEAD" ? null : await readFile(candidate.path), { headers });
+		}
+		return new Response(null, { status: 404 });
+	};
+}
+//#endregion
+//#region src/Module.ts
+const resolver = createResolver(import.meta.url);
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const packagedStudio = resolve(packageRoot, "studio");
+const studioDirectory = existsSync(packagedStudio) ? packagedStudio : resolve(packageRoot, "../studio/dist");
+const packagedMigrations = resolve(packageRoot, "drizzle");
+const migrationsFolder = existsSync(packagedMigrations) ? packagedMigrations : resolve(packageRoot, "../server/drizzle");
+var Module_default = defineNuxtModule({
+	meta: {
+		name: "@phtngyn/cms",
+		compatibility: { nuxt: ">=5.0.0-0 <6" }
+	},
+	async setup(_options, nuxt) {
+		const { configuration: options } = await Effect.runPromise(load(nuxt.options.rootDir, nuxt.options.envName, false));
+		const locales = options.locales === void 0 ? void 0 : defineLocales(options.locales);
+		const collectionsFile = resolve(nuxt.options.rootDir, "app/cms/collections.ts");
+		if (!existsSync(collectionsFile)) throw new Error("CMS needs app/cms/collections.ts.");
+		const loaded = (await import(`${pathToFileURL(collectionsFile).href}?modified=${statSync(collectionsFile).mtimeMs}`)).default;
+		if (!Array.isArray(loaded)) throw new Error("app/cms/collections.ts must export a collection array.");
+		const collections = collectionCatalog(loaded);
+		if (collections.length === 0) throw new Error("CMS needs at least one collection route.");
+		const compiler = createAuthoringCompiler();
+		const blocks = await discoverBlocks(nuxt.options.rootDir, compiler);
+		const blockFiles = new Set(blocks.map((block) => resolve(nuxt.options.rootDir, block.component)));
+		const blockIssues = validateBlockConfiguration(blocks, collections);
+		if (blockIssues.length) throw new Error(`CMS block configuration is invalid:\n${blockIssues.join("\n")}`);
+		const siteTypes = addTypeTemplate({
+			filename: "types/cms-site.d.ts",
+			getContents: () => generateSiteTypes(collections, blocks, collectionsFile)
+		});
+		nuxt.options.alias["#cms/types"] = siteTypes.dst;
+		if (nuxt.options.dev) {
+			const configurationFile = resolve(nuxt.options.rootDir, "cms.config.ts");
+			const blocksDirectory = resolve(nuxt.options.rootDir, "app/cms/blocks");
+			compiler.trackDependencies(configurationFile, readFileSync(configurationFile, "utf8"));
+			const watchedPaths = /* @__PURE__ */ new Set([
+				configurationFile,
+				collectionsFile,
+				blocksDirectory,
+				...compiler.dependencies()
+			]);
+			nuxt.options.watch.push(...watchedPaths);
+			nuxt.hook("builder:watch", async (_event, filename) => {
+				const changed = resolve(nuxt.options.srcDir, filename);
+				if (watchedPaths.has(changed) || changed.startsWith(`${blocksDirectory}/`)) await nuxt.callHook("restart", { hard: true });
+			});
+		}
+		addVitePlugin({
+			name: "cms:authoring",
+			enforce: "pre",
+			watchChange(id) {
+				compiler.invalidate(id);
+			},
+			transform(source, id) {
+				if (!id.endsWith(".vue") || !id.startsWith(`${resolve(nuxt.options.srcDir)}/`)) return void 0;
+				const compiled = blockFiles.has(id) ? compiler.compile(source, id) : null;
+				return compilePreviewTemplate(compiled?.code ?? source, id, resolver.resolve("./runtime/previewSource")) ?? (compiled ? {
+					code: compiled.code,
+					map: compiled.map
+				} : void 0);
+			}
+		});
+		const studioModules = defineStudioModules(options.studio.modules);
+		if (!["host.js", "host.css"].every((asset) => existsSync(resolve(studioDirectory, asset)))) throw new Error("Build CMS Studio before starting Nuxt.");
+		nuxt.options.runtimeConfig.cms = {
+			...options.runtime,
+			s3: { ...options.runtime.s3 }
+		};
+		if (locales) nuxt.options.runtimeConfig.public.cmsLocales = {
+			defaultLocale: locales.defaultLocale,
+			supported: locales.supported.map((definition) => ({ ...definition })),
+			prefixDefault: locales.prefixDefault
+		};
+		else Reflect.deleteProperty(nuxt.options.runtimeConfig.public, "cmsLocales");
+		const handlers = blocks.flatMap((block) => block.form && block.handler ? [{
+			name: block.name,
+			file: resolve(nuxt.options.rootDir, block.handler)
+		}] : []);
+		const plugin = addServerTemplate({
+			filename: resolver.resolve("./runtime/plugin.virtual.mjs"),
+			getContents: () => [
+				`import { createCmsPlugin } from ${JSON.stringify(resolver.resolve("./runtime/plugin"))}`,
+				`import cmsCollections from ${JSON.stringify(collectionsFile)}`,
+				...handlers.map((handler, index) => `import formHandler${index} from ${JSON.stringify(handler.file)}`),
+				`export default createCmsPlugin(${JSON.stringify({
+					collections,
+					blocks,
+					seo: options.seo,
+					studioModules,
+					rootDir: nuxt.options.rootDir,
+					migrationsFolder
+				})}, { ${handlers.map((handler, index) => `${JSON.stringify(handler.name)}: formHandler${index}`).join(", ")} }, Object.fromEntries(cmsCollections.flatMap(({ collection, schema }) => schema ? [[collection, schema]] : [])))`
+			].join("\n")
+		});
+		addNitroPlugin(plugin.filename);
+		nuxt.options.css.push(resolver.resolve("./runtime/preview.css"));
+		addPluginTemplate({
+			filename: "cms-preview.mjs",
+			getContents: () => `import { createCmsPreviewPlugin } from ${JSON.stringify(resolver.resolve("./runtime/preview"))}\nexport default createCmsPreviewPlugin(${JSON.stringify(collections)}, ${JSON.stringify(blocks)})`
+		});
+		for (const asset of ["host.js", "host.css"]) extendRouteRules(`/_cms/assets/${asset}`, { headers: { "cache-control": "public, max-age=0, must-revalidate" } }, { override: true });
+		addServerHandler({
+			handler: resolver.resolve("./runtime/studio"),
+			route: "/_cms/app"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/studio"),
+			route: "/_cms/app/**:path"
+		});
+		if (nuxt.options.dev) {
+			const serve = createStudioAssetHandler(studioDirectory);
+			addDevServerHandler({
+				route: "/_cms/assets/**",
+				middleware: true,
+				handler: (event) => serve(event.req)
+			});
+		}
+		nuxt.hook("nitro:config", (configuration) => {
+			const assets = "publicAssets" in configuration && Array.isArray(configuration.publicAssets) ? configuration.publicAssets : [];
+			Object.assign(configuration, { publicAssets: [
+				...assets,
+				{
+					dir: studioDirectory,
+					baseURL: "/_cms/assets",
+					maxAge: 0,
+					ignore: ["chunks/**"]
+				},
+				{
+					dir: resolve(studioDirectory, "chunks"),
+					baseURL: "/_cms/assets/chunks",
+					maxAge: 31536e3
+				}
+			] });
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/studioIcons"),
+			route: "/_cms/icons/lucide"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/revisionPrivacy"),
+			middleware: true
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/health/ready"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/delivery"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/query"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/revision-preview/delivery"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/revision-preview/query"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/seo/published"
+		});
+		if (options.robots) addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/robots.txt"
+		});
+		if (options.sitemap) addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/sitemap.xml"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/media/**:path"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/image/**:path"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/auth/**:path"
+		});
+		addServerHandler({
+			handler: resolver.resolve("./runtime/api"),
+			route: "/_cms/api/**:path"
+		});
+		addComponent({
+			name: "CmsDocumentRenderer",
+			filePath: resolver.resolve("./runtime/DocumentRenderer")
+		});
+		addComponent({
+			name: "CmsImage",
+			filePath: resolver.resolve("./runtime/CmsImage")
+		});
+		addImports([
+			{
+				name: "useCmsDocument",
+				from: resolver.resolve("./runtime/delivery/useCmsDocument")
+			},
+			{
+				name: "useCmsDocumentQuery",
+				from: resolver.resolve("./runtime/delivery/useCmsDocumentQuery")
+			},
+			{
+				name: "useCmsDocumentSeo",
+				from: resolver.resolve("./runtime/delivery/useCmsDocumentSeo")
+			},
+			{
+				name: "useCmsLocale",
+				from: resolver.resolve("./runtime/delivery/useCmsLocale")
+			}
+		]);
+		for (const block of blocks) {
+			const filePath = resolve(nuxt.options.rootDir, block.component);
+			addComponent({
+				name: blockComponentName(block.name),
+				filePath,
+				global: true
+			});
+		}
+		extendPages((pages) => {
+			pages.push({
+				file: resolver.resolve("./runtime/DocumentPage.vue"),
+				name: "cms-revision-preview",
+				path: "/_cms/revision-preview"
+			});
+			pages.push({
+				file: resolver.resolve("./runtime/DocumentPage.vue"),
+				name: "cms-document",
+				path: "/:contentPath(.*)*"
+			});
+		});
+	}
+});
+//#endregion
+export { Module_default as default };