wuppycms 0.0.0-stage → 0.2.0

package/dist/render-DzH7Wil3.mjs

@@ -0,0 +1,116 @@
+import { S as stripComponentImports, b as findDisallowed, n as loadConfig, x as loadSatteri } from "./config-CM8_-x_W.mjs";
+import { n as themeComponentNames } from "./components-BrGAEPly.mjs";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Fragment, jsx } from "astro/jsx-runtime";
+import { Renderer } from "astro/runtime/server/index.js";
+
+//#region src/markdown/render.ts
+const DEFAULTS = { shared: { syntaxHighlight: {
+	type: "shiki",
+	excludeLangs: ["math"]
+} } };
+const MDX_DEFAULTS = { shared: { syntaxHighlight: {
+	type: "shiki",
+	excludeLangs: ["math"]
+} } };
+const renderers = /* @__PURE__ */ new Map();
+/**
+* Astro's own Markdown renderer (heading ids, code highlighting, GFM), loaded from Astro's dependency at runtime: it
+* has a native binding, which cannot be bundled.
+*/
+function markdownRenderer(root = process.cwd(), settings = DEFAULTS) {
+	const key = JSON.stringify([root, settings]);
+	let renderer = renderers.get(key);
+	if (!renderer) {
+		renderer = (async () => {
+			const { satteri } = await import(pathToFileURL(createRequire(createRequire(join(root, "package.json")).resolve("astro/package.json")).resolve("@astrojs/markdown-satteri")).href);
+			return satteri({ features: settings.features }).createRenderer(settings.shared ?? {});
+		})();
+		renderers.set(key, renderer);
+	}
+	return renderer;
+}
+/**
+* Markdown stored outside content collections (a section body, a custom widget) as HTML, the way Astro renders an
+* `.md` entry: `const { html } = await markdownContent(section.body)` then `<Fragment set:html={html} />`. The text is
+* checked first with the same rules as the admin, so a body changed outside the admin cannot inject scripts either.
+*/
+async function markdownContent(source, options = {}) {
+	const found = await findDisallowed(source, [], "md");
+	if (found.length > 0) throw new Error(`[wuppy] Markdown not allowed: ${found.join(", ")}`);
+	const result = await (await markdownRenderer(options.root, options.markdown)).render(source, { frontmatter: {} });
+	return {
+		html: result.code,
+		headings: result.metadata.headings ?? []
+	};
+}
+let plugins;
+const highlighters = /* @__PURE__ */ new Map();
+/** Astro's own Markdown plugins (heading ids, code highlighting), loaded like satteri: from Astro's dependency. */
+function astroPlugins(root) {
+	plugins ??= (async () => {
+		return await import(pathToFileURL(createRequire(createRequire(join(root, "package.json")).resolve("astro/package.json")).resolve("@astrojs/markdown-satteri")).href);
+	})();
+	return plugins;
+}
+/**
+* MDX text stored at runtime (a section body, an entry edited since the last build) compiled to what Astro's `render()`
+* gives: `const { Content, headings } = await mdxContent(section.body)` then `<Content components={{ Callout }} />`.
+* The text is checked first with the same rules as the admin (no imports, exports or expressions; only the `components`
+* listed in wuppy.config), so a body changed outside the admin cannot run code either. Headings get Astro's ids and
+* code blocks its highlighting. Needs `@astrojs/mdx` in the site, which renders the result.
+*/
+async function mdxContent(source, options = {}) {
+	const root = options.root ?? process.cwd();
+	const site = process.env.WUPPY_BASE_ROOT || root;
+	const themeMode = process.env.WUPPY_BASE_ROOT && resolve(site) !== resolve(root);
+	source = stripComponentImports(source);
+	const allowed = options.allowed ?? [...new Set([...(await loadConfig(site)).components, ...themeMode ? await themeComponentNames(root) : []])];
+	const found = await findDisallowed(source, allowed, "mdx");
+	if (found.length > 0) throw new Error(`[wuppy] MDX not allowed: ${found.join(", ")}`);
+	const [satteri, astro] = await Promise.all([loadSatteri(root), astroPlugins(root)]);
+	const { features = {}, shared = {} } = options.markdown ?? MDX_DEFAULTS;
+	const hastPlugins = [];
+	if (shared.syntaxHighlight) {
+		const key = JSON.stringify([shared.syntaxHighlight, shared.shikiConfig]);
+		if (!highlighters.has(key)) highlighters.set(key, astro.satteriCreateHighlightFn(shared.syntaxHighlight, shared.shikiConfig ?? {}));
+		const exclude = shared.syntaxHighlight.excludeLangs;
+		hastPlugins.push(astro.satteriHighlightPlugin(await highlighters.get(key), exclude));
+	}
+	hastPlugins.push(astro.satteriHeadingIdsPlugin());
+	const data = { astro: {
+		frontmatter: {},
+		headings: []
+	} };
+	const MDXContent = (await satteri.evaluate(source, {
+		Fragment,
+		jsx,
+		jsxs: jsx,
+		elementAttributeNameCase: "html",
+		hastPlugins,
+		data,
+		features: {
+			...features,
+			gfm: shared.gfm !== false,
+			smartPunctuation: shared.smartypants !== false
+		}
+	})).default;
+	const Content = (props = {}) => MDXContent({
+		...props,
+		components: {
+			Fragment,
+			...props.components
+		}
+	});
+	Object.defineProperty(Content, Symbol.for("mdx-component"), { value: true });
+	Object.defineProperty(Content, Renderer, { value: "astro:jsx" });
+	return {
+		Content,
+		headings: data.astro.headings
+	};
+}
+
+//#endregion
+export { markdownRenderer as n, mdxContent as r, markdownContent as t };

package/dist/routes/admin.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/admin.d.ts
+declare const prerender = false;
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/routes/admin.mjs

@@ -0,0 +1,10 @@
+import { n as serveAdmin, t as adminDist } from "../admin-fo4l4lu2.mjs";
+import { createRequire } from "node:module";
+
+//#region src/astro/routes/admin.ts
+const prerender = false;
+const dist = adminDist(createRequire(import.meta.url).resolve);
+const GET = ({ params }) => serveAdmin(dist, params.path ?? "");
+
+//#endregion
+export { GET, prerender };

package/dist/routes/api.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/api.d.ts
+declare const prerender = false;
+declare const ALL: APIRoute;
+//#endregion
+export { ALL, prerender };

package/dist/routes/api.mjs

@@ -0,0 +1,97 @@
+import "../config-CM8_-x_W.mjs";
+import "../frontmatter-DGaz9--t.mjs";
+import "../service-CgcvCG7l.mjs";
+import { t as createServer } from "../server-D92ryW2y.mjs";
+import "../generate-iX4B_2U2.mjs";
+import "../theme-pages-CRsBm1EX.mjs";
+import { l as themeRoot, s as siteRoot } from "../site-dF-xVPqe.mjs";
+import "../schemas-dHRJ1HeG.mjs";
+import "../render-DzH7Wil3.mjs";
+import "../media-DGfJXgBA.mjs";
+import { BlockList, isIP } from "node:net";
+
+//#region src/config/ip.ts
+const familyOf = (ip) => {
+	const version = isIP(ip);
+	return version === 4 ? "ipv4" : version === 6 ? "ipv6" : null;
+};
+/** Builds a matcher for exact proxy IPs and CIDR ranges; malformed entries are ignored. */
+function proxyList(entries) {
+	const list = new BlockList();
+	let added = 0;
+	for (const entry of entries) {
+		const trimmed = entry.trim();
+		if (!trimmed) continue;
+		const slash = trimmed.lastIndexOf("/");
+		const address = slash === -1 ? trimmed : trimmed.slice(0, slash);
+		const family = familyOf(address);
+		if (!family) continue;
+		if (slash === -1) {
+			list.addAddress(address, family);
+			added++;
+			continue;
+		}
+		const prefix = Number(trimmed.slice(slash + 1));
+		const max = family === "ipv4" ? 32 : 128;
+		if (!Number.isInteger(prefix) || prefix < 0 || prefix > max) continue;
+		list.addSubnet(address, prefix, family);
+		added++;
+	}
+	return added > 0 ? list : null;
+}
+/**
+* Resolves the client IP without trusting a client-supplied forwarded header.
+* The immediate peer is used unless it is a configured proxy; only then is the
+* forwarded chain walked right-to-left to the first untrusted hop.
+*/
+function resolveClientIP({ peer, forwarded, trustedProxies = [] }) {
+	if (!peer) return null;
+	const peerFamily = familyOf(peer);
+	if (!peerFamily) return null;
+	const proxies = proxyList(trustedProxies);
+	if (!proxies || !proxies.check(peer, peerFamily)) return peer;
+	const chain = (forwarded ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+	for (let i = chain.length - 1; i >= 0; i--) {
+		const candidate = chain[i];
+		if (!candidate) continue;
+		const family = familyOf(candidate);
+		if (!family) return peer;
+		if (proxies.check(candidate, family)) continue;
+		return candidate;
+	}
+	return peer;
+}
+/** Comma-separated `WUPPY_TRUSTED_PROXIES` (exact IPs or CIDR ranges). */
+function trustedProxiesFromEnv(env = process.env) {
+	return (env.WUPPY_TRUSTED_PROXIES ?? "").split(",").map((value) => value.trim()).filter(Boolean);
+}
+
+//#endregion
+//#region src/astro/routes/api.ts
+const prerender = false;
+let server;
+const trustedProxies = trustedProxiesFromEnv();
+const ALL = async ({ request, clientAddress }) => {
+	const headers = new Headers(request.headers);
+	const clientIP = resolveClientIP({
+		peer: clientAddress,
+		forwarded: request.headers.get("x-forwarded-for"),
+		trustedProxies
+	});
+	if (clientIP) headers.set("x-wuppy-client-ip", clientIP);
+	else headers.delete("x-wuppy-client-ip");
+	const forwardedRequest = new Request(request, {
+		headers,
+		duplex: "half"
+	});
+	server ??= createServer({
+		root: siteRoot(),
+		theme: themeRoot(),
+		secret: process.env.WUPPY_SECRET ?? import.meta.env.WUPPY_SECRET ?? "",
+		baseURL: process.env.WUPPY_URL ?? import.meta.env.WUPPY_URL ?? new URL(request.url).origin
+	});
+	return (await server).fetch(forwardedRequest);
+};
+
+//#endregion
+export { ALL, prerender };

package/dist/routes/icons.d.mts

@@ -0,0 +1,12 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/icons.d.ts
+declare const prerender = false;
+/**
+ * Production SVG sprite generated by `zero-icons` in the admin package. The
+ * URL is stable while builds change its symbols, so it must revalidate; an
+ * immutable cache here hides newly added icons from returning browsers.
+ */
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/routes/icons.mjs

@@ -0,0 +1,36 @@
+import { t as adminDist } from "../admin-fo4l4lu2.mjs";
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+
+//#region src/astro/routes/icons.ts
+const prerender = false;
+const dist = adminDist(createRequire(import.meta.url).resolve);
+/**
+* Production SVG sprite generated by `zero-icons` in the admin package. The
+* URL is stable while builds change its symbols, so it must revalidate; an
+* immutable cache here hides newly added icons from returning browsers.
+*/
+const GET = async ({ request }) => {
+	try {
+		const body = await readFile(join(dist, "icons.svg"));
+		const etag = `"${createHash("sha256").update(body).digest("base64url").slice(0, 16)}"`;
+		const headers = {
+			"content-type": "image/svg+xml",
+			"x-content-type-options": "nosniff",
+			"cache-control": "no-cache",
+			etag
+		};
+		if (request.headers.get("if-none-match") === etag) return new Response(null, {
+			status: 304,
+			headers
+		});
+		return new Response(body, { headers });
+	} catch {
+		return new Response("Not found", { status: 404 });
+	}
+};
+
+//#endregion
+export { GET, prerender };

package/dist/routes/robots.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/robots.d.ts
+declare const prerender = false;
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/routes/robots.mjs

@@ -0,0 +1,15 @@
+import { n as loadConfig } from "../config-CM8_-x_W.mjs";
+import "../frontmatter-DGaz9--t.mjs";
+import { s as siteRoot } from "../site-dF-xVPqe.mjs";
+import { buildRobots } from "../seo.mjs";
+
+//#region src/astro/routes/robots.ts
+const prerender = false;
+const GET = async () => {
+	const { site } = await loadConfig(siteRoot());
+	if (!site) return new Response("Set `site` in wuppy.config to enable robots.txt", { status: 404 });
+	return new Response(buildRobots(site.url), { headers: { "content-type": "text/plain; charset=utf-8" } });
+};
+
+//#endregion
+export { GET, prerender };

package/dist/routes/rss.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/rss.d.ts
+declare const prerender = false;
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/routes/rss.mjs

@@ -0,0 +1,20 @@
+import "../config-CM8_-x_W.mjs";
+import "../frontmatter-DGaz9--t.mjs";
+import { n as ContentService } from "../service-CgcvCG7l.mjs";
+import { i as loadSiteConfig, l as themeRoot, s as siteRoot } from "../site-dF-xVPqe.mjs";
+import { buildRss } from "../seo.mjs";
+import { t as contentFeed } from "../sitemap-Ba0vil6a.mjs";
+import { NoopGit } from "@wuppycms/git";
+
+//#region src/astro/routes/rss.ts
+const prerender = false;
+const GET = async () => {
+	const root = siteRoot();
+	const config = await loadSiteConfig(root, themeRoot());
+	if (!config.site) return new Response("Set `site` in wuppy.config to enable the RSS feed", { status: 404 });
+	const items = await contentFeed(new ContentService(root, config.collections, new NoopGit()), config.site.url);
+	return new Response(buildRss(config.site, items), { headers: { "content-type": "application/rss+xml; charset=utf-8" } });
+};
+
+//#endregion
+export { GET, prerender };

package/dist/routes/sitemap.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/sitemap.d.ts
+declare const prerender = false;
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/routes/sitemap.mjs

@@ -0,0 +1,23 @@
+import "../config-CM8_-x_W.mjs";
+import "../frontmatter-DGaz9--t.mjs";
+import { n as ContentService } from "../service-CgcvCG7l.mjs";
+import { i as loadSiteConfig, l as themeRoot, s as siteRoot } from "../site-dF-xVPqe.mjs";
+import { i as settingsSchema } from "../schemas-dHRJ1HeG.mjs";
+import { buildSitemap } from "../seo.mjs";
+import { t as readData } from "../read-Bh4-a3Ap.mjs";
+import { n as contentUrls } from "../sitemap-Ba0vil6a.mjs";
+import { NoopGit } from "@wuppycms/git";
+
+//#region src/astro/routes/sitemap.ts
+const prerender = false;
+const GET = async () => {
+	const root = siteRoot();
+	const config = await loadSiteConfig(root, themeRoot());
+	if (!config.site) return new Response("Set `site` in wuppy.config to enable the sitemap", { status: 404 });
+	const { seo } = settingsSchema.parse(await readData("settings", {}, root) ?? {});
+	const urls = await contentUrls(new ContentService(root, config.collections, new NoopGit()), config.site.url, seo.sitemap);
+	return new Response(buildSitemap([{ loc: new URL("/", config.site.url).href }, ...urls]), { headers: { "content-type": "application/xml; charset=utf-8" } });
+};
+
+//#endregion
+export { GET, prerender };

package/dist/routes/uploads.d.mts

@@ -0,0 +1,7 @@
+import { APIRoute } from "astro";
+
+//#region src/astro/routes/uploads.d.ts
+declare const prerender = false;
+declare const GET: APIRoute;
+//#endregion
+export { GET, prerender };

package/dist/routes/uploads.mjs

@@ -0,0 +1,11 @@
+import "../config-CM8_-x_W.mjs";
+import "../frontmatter-DGaz9--t.mjs";
+import { s as siteRoot } from "../site-dF-xVPqe.mjs";
+import { o as serveUpload } from "../media-DGfJXgBA.mjs";
+
+//#region src/astro/routes/uploads.ts
+const prerender = false;
+const GET = ({ params, url }) => serveUpload(siteRoot(), params.path ?? "", url.searchParams);
+
+//#endregion
+export { GET, prerender };

package/dist/schemas-dHRJ1HeG.mjs

@@ -0,0 +1,275 @@
+import { C as collectionSchema, p as webhooksSchema } from "./config-CM8_-x_W.mjs";
+import { z } from "zod";
+import { defaultVisualData, visualDataSchema } from "@wuppycms/visual-editor";
+
+//#region src/data/schemas.ts
+const id = z.string().regex(/^[a-z0-9][a-z0-9-]*$/);
+const href = z.string().min(1).refine((v) => v.startsWith("/") && !v.startsWith("//") || /^https?:\/\//i.test(v), "Expected a path or http(s) URL");
+const menuSchema = z.object({
+	name: id,
+	label: z.string().min(1),
+	location: z.string().default("header"),
+	locale: z.string().optional(),
+	items: z.array(z.object({
+		label: z.string().min(1),
+		href,
+		kind: z.string().max(40).optional(),
+		children: z.array(z.object({
+			label: z.string().min(1),
+			href,
+			kind: z.string().max(40).optional()
+		})).default([])
+	})).default([])
+});
+const widgetSchema = z.object({
+	id: z.string(),
+	type: z.enum([
+		"text",
+		"html",
+		"menu",
+		"recent",
+		"taxonomy",
+		"custom"
+	]),
+	title: z.string().default(""),
+	body: z.string().default(""),
+	menu: z.string().optional(),
+	taxonomy: z.string().optional(),
+	locales: z.array(z.string()).default([]),
+	collections: z.array(z.string()).default([]),
+	paths: z.array(z.string()).default([])
+});
+const widgetAreaSchema = z.object({
+	name: id,
+	label: z.string().min(1),
+	description: z.string().default(""),
+	widgets: z.array(widgetSchema).default([])
+});
+const sectionSchema = z.object({
+	slug: id,
+	title: z.string().min(1),
+	body: z.string().default(""),
+	draft: z.boolean().default(false),
+	locale: z.string().optional()
+});
+const taxonomyTermSchema = z.object({
+	slug: id,
+	name: z.string().min(1),
+	description: z.string().default(""),
+	parent: z.string().optional(),
+	order: z.number().int().default(0),
+	translations: z.record(z.string(), z.object({
+		name: z.string().min(1),
+		description: z.string().default("")
+	})).default({})
+});
+const taxonomySchema = z.object({
+	name: id,
+	label: z.string().min(1),
+	hierarchical: z.boolean().default(false),
+	collections: z.array(z.string()).default([]),
+	terms: z.array(taxonomyTermSchema).default([])
+}).superRefine((t, ctx) => {
+	const slugs = /* @__PURE__ */ new Set();
+	for (const term of t.terms) {
+		if (slugs.has(term.slug)) ctx.addIssue({
+			code: "custom",
+			message: `Duplicate term: ${term.slug}`
+		});
+		slugs.add(term.slug);
+	}
+	for (const term of t.terms) {
+		if (!term.parent) continue;
+		if (!t.hierarchical) ctx.addIssue({
+			code: "custom",
+			message: `${term.slug}: this taxonomy is not hierarchical`
+		});
+		else if (!slugs.has(term.parent)) ctx.addIssue({
+			code: "custom",
+			message: `${term.slug}: unknown parent ${term.parent}`
+		});
+	}
+	const parentOf = new Map(t.terms.map((x) => [x.slug, x.parent]));
+	for (const term of t.terms) {
+		const seen = new Set([term.slug]);
+		for (let at = term.parent; at; at = parentOf.get(at)) {
+			if (seen.has(at)) {
+				ctx.addIssue({
+					code: "custom",
+					message: `Parent loop through ${term.slug}`
+				});
+				break;
+			}
+			seen.add(at);
+		}
+	}
+});
+const bylineSchema = z.object({
+	slug: id,
+	name: z.string().min(1),
+	bio: z.string().default(""),
+	avatar: z.string().default(""),
+	email: z.string().email().optional().or(z.literal("")),
+	website: z.string().url().optional().or(z.literal("")),
+	credits: z.array(z.string()).default([]),
+	extra: z.record(z.string(), z.string()).default({}),
+	translations: z.record(z.string(), z.object({
+		name: z.string().optional(),
+		bio: z.string().optional()
+	})).default({})
+});
+const bylineFieldSchema = z.object({
+	name: id,
+	label: z.string().min(1),
+	type: z.enum([
+		"string",
+		"text",
+		"image",
+		"url"
+	]).default("string"),
+	required: z.boolean().default(false),
+	order: z.number().int().default(0)
+});
+const settingsSchema = z.object({
+	siteName: z.string().default("Wuppy"),
+	siteUrl: z.string().default(""),
+	description: z.string().default(""),
+	logo: z.string().default(""),
+	locale: z.string().default("en"),
+	timezone: z.string().default("UTC"),
+	seo: z.object({
+		title: z.string().default(""),
+		description: z.string().default(""),
+		image: z.string().default(""),
+		noindex: z.boolean().default(false),
+		titleTemplate: z.string().default("{title} | {site}"),
+		sitemap: z.object({
+			exclude: z.array(z.string()).default([]),
+			priority: z.record(z.string(), z.number().min(0).max(1)).default({})
+		}).default({
+			exclude: [],
+			priority: {}
+		})
+	}).default({
+		title: "",
+		description: "",
+		image: "",
+		noindex: false,
+		titleTemplate: "{title} | {site}",
+		sitemap: {
+			exclude: [],
+			priority: {}
+		}
+	}),
+	social: z.record(z.string(), z.string()).default({}),
+	email: z.object({
+		from: z.string().default(""),
+		provider: z.enum([
+			"console",
+			"smtp",
+			"resend"
+		]).default("console"),
+		host: z.string().default(""),
+		port: z.number().default(587),
+		user: z.string().default(""),
+		templates: z.partialRecord(z.enum([
+			"invite",
+			"reset",
+			"magic"
+		]), z.object({
+			subject: z.string().min(1).max(200),
+			text: z.string().min(1).max(5e3)
+		}).partial()).default({})
+	}).default({
+		from: "",
+		provider: "console",
+		host: "",
+		port: 587,
+		user: "",
+		templates: {}
+	}),
+	media: z.object({
+		maxBytes: z.number().default(5 * 1024 * 1024),
+		allowed: z.array(z.string()).default([
+			"image/png",
+			"image/jpeg",
+			"image/gif",
+			"image/webp"
+		])
+	}).default({
+		maxBytes: 5 * 1024 * 1024,
+		allowed: [
+			"image/png",
+			"image/jpeg",
+			"image/gif",
+			"image/webp"
+		]
+	}),
+	comments: z.object({
+		enabled: z.boolean().default(true),
+		moderated: z.boolean().default(true),
+		notifyEmail: z.union([z.email(), z.literal("")]).default("")
+	}).default({
+		enabled: true,
+		moderated: true,
+		notifyEmail: ""
+	}),
+	security: z.object({ allowedDomains: z.array(z.string().regex(/^[a-z0-9.-]+\.[a-z]{2,}$/i)).default([]) }).default({ allowedDomains: [] }),
+	backup: z.object({
+		enabled: z.boolean().default(false),
+		intervalHours: z.number().int().min(1).max(720).default(24),
+		keep: z.number().int().min(1).max(365).default(14)
+	}).default({
+		enabled: false,
+		intervalHours: 24,
+		keep: 14
+	})
+});
+const themeSchema = z.object({
+	id,
+	name: z.string().min(1),
+	version: z.string().default("0.0.0"),
+	active: z.boolean().default(false)
+});
+const dataSchemas = {
+	settings: settingsSchema,
+	menus: z.array(menuSchema),
+	widgets: z.array(widgetAreaSchema),
+	sections: z.array(sectionSchema),
+	taxonomies: z.array(taxonomySchema),
+	bylines: z.array(bylineSchema),
+	"byline-schema": z.array(bylineFieldSchema),
+	themes: z.array(themeSchema),
+	"content-types": z.array(collectionSchema),
+	webhooks: webhooksSchema,
+	visual: visualDataSchema
+};
+const dataNames = Object.keys(dataSchemas);
+const dataDefaults = {
+	settings: settingsSchema.parse({}),
+	menus: [],
+	widgets: [],
+	sections: [],
+	taxonomies: [{
+		name: "categories",
+		label: "Categories",
+		hierarchical: true,
+		collections: [],
+		terms: []
+	}, {
+		name: "tags",
+		label: "Tags",
+		hierarchical: false,
+		collections: [],
+		terms: []
+	}],
+	bylines: [],
+	"byline-schema": [],
+	themes: [],
+	"content-types": [],
+	webhooks: [],
+	visual: defaultVisualData()
+};
+
+//#endregion
+export { taxonomyTermSchema as a, settingsSchema as i, dataNames as n, dataSchemas as r, dataDefaults as t };