wuppycms 0.0.0-stage → 0.2.0

package/dist/service-CgcvCG7l.mjs

@@ -0,0 +1,353 @@
+import { S as stripComponentImports, b as findDisallowed, w as dataSchema, y as componentTags } from "./config-CM8_-x_W.mjs";
+import { n as serializeDocument, t as parseDocument } from "./frontmatter-DGaz9--t.mjs";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+//#region src/content/validation/path.ts
+var UnsafePathError = class extends Error {};
+const SEGMENT = /^[a-z0-9][a-z0-9._-]*$/i;
+/** Throws unless `slug` is a safe relative slug path (e.g. "blog/hello"). Returns it normalized. */
+function assertSafeSlug(slug) {
+	if (!slug || slug.includes("\0") || slug.includes("\\")) throw new UnsafePathError(`Unsafe slug: ${JSON.stringify(slug)}`);
+	const parts = slug.split("/");
+	if (!parts.every((p) => SEGMENT.test(p))) throw new UnsafePathError(`Unsafe slug: ${JSON.stringify(slug)}`);
+	return parts.join("/");
+}
+
+//#endregion
+//#region src/content/adapters/filesystem.ts
+var FilesystemContent = class {
+	constructor(root, collection) {
+		this.root = root;
+		this.collection = collection;
+	}
+	/**
+	* A collection holds `.md` and `.mdx` files side by side: an existing entry keeps its own extension,
+	* a new one gets the collection's format.
+	*/
+	formatOf(slug) {
+		const other = this.collection.format === "md" ? "mdx" : "md";
+		const at = (ext) => join(this.root, `${this.collection.dir}/${assertSafeSlug(slug)}.${ext}`);
+		return !existsSync(at(this.collection.format)) && existsSync(at(other)) ? other : this.collection.format;
+	}
+	/** Repo-relative path (forward slashes), for Git. */
+	relPath(slug, format = this.formatOf(slug)) {
+		return `${this.collection.dir}/${assertSafeSlug(slug)}.${format}`;
+	}
+	/** Absolute path, for metadata reads. */
+	absolutePath(slug) {
+		return join(this.root, this.relPath(slug));
+	}
+	file(slug, format = this.formatOf(slug)) {
+		return join(this.root, this.relPath(slug, format));
+	}
+	async get(slug) {
+		try {
+			return {
+				slug,
+				...parseDocument(await readFile(this.file(slug), "utf8"))
+			};
+		} catch (e) {
+			if (e.code === "ENOENT") return null;
+			throw e;
+		}
+	}
+	async put(slug, doc, format = this.formatOf(slug)) {
+		const path = this.file(slug, format);
+		await mkdir(dirname(path), { recursive: true });
+		await writeFile(path, serializeDocument(doc));
+	}
+	async delete(slug, format = this.formatOf(slug)) {
+		await rm(this.file(slug, format), { force: true });
+	}
+	async list() {
+		const base = join(this.root, this.collection.dir);
+		try {
+			const slugs = (await readdir(base, { recursive: true })).filter((n) => /\.mdx?$/.test(n)).map((n) => n.replace(/\.mdx?$/, "").split("\\").join("/"));
+			return [...new Set(slugs)].toSorted();
+		} catch (e) {
+			if (e.code === "ENOENT") return [];
+			throw e;
+		}
+	}
+};
+
+//#endregion
+//#region src/content/service.ts
+var UnknownCollectionError = class extends Error {};
+var ContentExistsError = class extends Error {
+	constructor(collection, slug) {
+		super(`An entry already exists at ${collection}/${slug}`);
+		this.collection = collection;
+		this.slug = slug;
+	}
+};
+var DisallowedContentError = class extends Error {
+	constructor(found) {
+		super(`Disallowed content: ${found.join(", ")}`);
+		this.found = found;
+	}
+};
+/** File-backed content where every mutation becomes a Git commit. */
+var ContentService = class {
+	stores = /* @__PURE__ */ new Map();
+	schemas = /* @__PURE__ */ new Map();
+	tail = Promise.resolve();
+	/** Bumped on every successful mutation; indexes compare it to know when to rebuild. */
+	version = 0;
+	/** Parsed entries per collection, reused until a mutation (version) or the TTL; see `listEntries`. */
+	listed = /* @__PURE__ */ new Map();
+	/** Git allows one writer per repo (index.lock), so mutations run one at a time. */
+	serial(fn) {
+		const run = this.tail.then(fn, fn);
+		this.tail = run.catch(() => void 0);
+		return run;
+	}
+	constructor(root, collections, git, options = {}) {
+		this.root = root;
+		this.collections = collections;
+		this.git = git;
+		this.options = options;
+		for (const c of collections) {
+			this.stores.set(c.name, new FilesystemContent(root, c));
+			this.schemas.set(c.name, dataSchema(c));
+		}
+	}
+	/** MDX components an entry body may use (empty means none). */
+	get allowedComponents() {
+		return this.options.components ?? [];
+	}
+	emit(type, extra) {
+		this.version++;
+		this.options.emit?.({
+			type,
+			...extra,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	}
+	store(name) {
+		const s = this.stores.get(name);
+		if (!s) throw new UnknownCollectionError(`Unknown collection: ${name}`);
+		return s;
+	}
+	async list(collection) {
+		return this.store(collection).list();
+	}
+	/**
+	* Metadata for dashboard/search/list views; reads each entry once. A big collection is expensive to read (10k files
+	* take about half a second), so the result is reused until Wuppy itself writes or `listCacheMs` passes.
+	*/
+	async listEntries(collection) {
+		const ttl = this.options.listCacheMs ?? 2e3;
+		const hit = this.listed.get(collection);
+		if (hit && hit.version === this.version && Date.now() - hit.at < ttl) return hit.rows.slice();
+		const version = this.version;
+		const rows = await this.readEntries(collection);
+		this.listed.set(collection, {
+			at: Date.now(),
+			version,
+			rows
+		});
+		return rows.slice();
+	}
+	async readEntries(collection) {
+		const store = this.store(collection);
+		const slugs = await store.list();
+		const { stat } = await import("node:fs/promises");
+		return (await Promise.all(slugs.map(async (slug) => {
+			const entry = await store.get(slug);
+			if (!entry) return null;
+			let modified = (/* @__PURE__ */ new Date(0)).toISOString();
+			try {
+				modified = (await stat(store.absolutePath(slug))).mtime.toISOString();
+			} catch {}
+			return {
+				...entry,
+				modified
+			};
+		}))).filter((e) => e !== null);
+	}
+	async get(collection, slug) {
+		return this.store(collection).get(slug);
+	}
+	/**
+	* Plugins' before-hooks first, then the MDX rules: whatever a plugin changes is checked like anything an editor
+	* writes. A plugin cannot publish or unpublish: `draft` stays what the editor (and their permission) said.
+	*/
+	async checked(collection, slug, doc, isNew) {
+		const s = this.store(collection);
+		if (this.options.beforeSave) {
+			const out = await this.options.beforeSave({
+				collection,
+				slug,
+				isNew,
+				data: doc.data,
+				body: doc.body
+			});
+			const data = { ...out.data };
+			if ("draft" in doc.data) data.draft = doc.data.draft;
+			else delete data.draft;
+			doc = {
+				data,
+				body: out.body
+			};
+		}
+		const current = s.formatOf(slug);
+		const tags = await componentTags(doc.body);
+		const format = current === "mdx" || s.collection.format === "mdx" && tags.length > 0 ? "mdx" : "md";
+		if (format === "mdx") doc = {
+			...doc,
+			body: stripComponentImports(doc.body)
+		};
+		const found = await findDisallowed(doc.body, this.options.components ?? [], format);
+		if (found.length > 0) throw new DisallowedContentError(found);
+		return doc;
+	}
+	async create(collection, slug, doc, message) {
+		const s = this.store(collection);
+		doc = await this.checked(collection, slug, doc, true);
+		doc = {
+			...doc,
+			data: this.schemas.get(collection).parse(doc.data)
+		};
+		await this.serial(async () => {
+			if (await s.get(slug)) throw new ContentExistsError(collection, slug);
+			await s.put(slug, doc);
+			await this.git.commit([s.relPath(slug)], message ?? `content: create ${collection}/${slug}`).catch((e) => {
+				if (!/nothing to commit/i.test(e.message)) throw e;
+			});
+		});
+		this.emit("content.updated", {
+			collection,
+			slug
+		});
+	}
+	async put(collection, slug, doc, message) {
+		const s = this.store(collection);
+		const isNew = this.options.beforeSave ? !await s.get(slug) : false;
+		doc = await this.checked(collection, slug, doc, isNew);
+		doc = {
+			...doc,
+			data: this.schemas.get(collection).parse(doc.data)
+		};
+		const before = s.formatOf(slug);
+		const format = s.collection.format === "mdx" && (await componentTags(doc.body)).length ? "mdx" : before;
+		await this.serial(async () => {
+			await s.put(slug, doc, format);
+			if (format !== before) await s.delete(slug, before);
+			await this.git.commit([...new Set([s.relPath(slug, before), s.relPath(slug, format)])], message ?? `content: update ${collection}/${slug}`).catch((e) => {
+				if (!/nothing to commit/i.test(e.message)) throw e;
+			});
+		});
+		this.emit("content.updated", {
+			collection,
+			slug
+		});
+	}
+	async delete(collection, slug) {
+		await this.trash(collection, slug);
+	}
+	/** Move an entry to `.wuppy/trash`; Git keeps the old file too. */
+	async trash(collection, slug) {
+		const s = this.store(collection);
+		const entry = await s.get(slug);
+		if (!entry) return;
+		await this.options.beforeDelete?.({
+			collection,
+			slug
+		});
+		const rel = this.trashRel(collection, slug);
+		const path = join(this.root, rel);
+		await this.serial(async () => {
+			await mkdir(dirname(path), { recursive: true });
+			await writeFile(path, JSON.stringify({
+				...entry,
+				collection,
+				deletedAt: (/* @__PURE__ */ new Date()).toISOString()
+			}, null, 2));
+			const file = s.relPath(slug);
+			await s.delete(slug);
+			await this.git.commit([file, rel], `content: trash ${collection}/${slug}`);
+		});
+		this.emit("content.deleted", {
+			collection,
+			slug
+		});
+	}
+	async listTrash() {
+		const base = join(this.root, ".wuppy", "trash");
+		const names = await readdir(base, { recursive: true }).catch(() => []);
+		return (await Promise.all(names.filter((name) => name.endsWith(".json")).map(async (name) => {
+			try {
+				const parsed = JSON.parse(await readFile(join(base, name), "utf8"));
+				return {
+					collection: parsed.collection,
+					slug: parsed.slug,
+					title: typeof parsed.data?.title === "string" ? parsed.data.title : parsed.slug,
+					deletedAt: parsed.deletedAt
+				};
+			} catch {
+				return null;
+			}
+		}))).filter((row) => row !== null).toSorted((a, b) => b.deletedAt.localeCompare(a.deletedAt));
+	}
+	async restore(collection, slug) {
+		const s = this.store(collection);
+		const rel = this.trashRel(collection, slug);
+		const path = join(this.root, rel);
+		try {
+			const parsed = JSON.parse(await readFile(path, "utf8"));
+			const doc = await this.checked(collection, slug, {
+				data: parsed.data,
+				body: parsed.body
+			}, true);
+			await this.serial(async () => {
+				await s.put(slug, doc);
+				await rm(path, { force: true });
+				await this.git.commit([s.relPath(slug), rel], `content: restore ${collection}/${slug}`);
+			});
+			this.emit("content.updated", {
+				collection,
+				slug
+			});
+			return true;
+		} catch (e) {
+			if (e.code === "ENOENT") return false;
+			throw e;
+		}
+	}
+	async deleteTrash(collection, slug) {
+		this.store(collection);
+		const rel = this.trashRel(collection, slug);
+		try {
+			await rm(join(this.root, rel));
+			await this.git.commit([rel], `content: delete trash ${collection}/${slug}`).catch(() => void 0);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	trashRel(collection, slug) {
+		return `.wuppy/trash/${collection}/${encodeURIComponent(slug)}.json`;
+	}
+	async history(collection, slug) {
+		return this.git.history(this.store(collection).relPath(slug));
+	}
+	/** The entry as it was in commit `sha`, or null if it did not exist then. */
+	async revision(collection, slug, sha) {
+		const text = await this.git.show(sha, this.store(collection).relPath(slug));
+		return text === null ? null : parseDocument(text);
+	}
+	diff(sha) {
+		return this.git.diff(sha);
+	}
+	async revert(sha) {
+		const created = await this.serial(() => this.git.revert(sha));
+		this.emit("content.reverted", { sha: created });
+		return created;
+	}
+};
+
+//#endregion
+export { FilesystemContent as a, UnknownCollectionError as i, ContentService as n, UnsafePathError as o, DisallowedContentError as r, assertSafeSlug as s, ContentExistsError as t };

package/dist/site-dF-xVPqe.mjs

@@ -0,0 +1,148 @@
+import { S as stripComponentImports, n as loadConfig } from "./config-CM8_-x_W.mjs";
+import { n as serializeDocument, t as parseDocument } from "./frontmatter-DGaz9--t.mjs";
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+
+//#region src/themes/site.ts
+/**
+* A GitHub theme is design only; content belongs to the site. A theme's collections are stored in the site:
+* one with `kind: "posts"`/`"pages"` (its `blog`, `about`) in the site's Posts/Pages collection, any other one in
+* `content/<name>`. `map` renames the theme's fields to the site's (`pubDate` -> `date`).
+*/
+/** The site's folder (content, media, data, accounts); a theme runs from its own folder with this set. */
+const siteRoot = () => process.env.WUPPY_BASE_ROOT || process.cwd();
+/** The running theme's folder, or undefined when the site runs itself. */
+const themeRoot = () => resolve(process.cwd()) === resolve(siteRoot()) ? void 0 : process.cwd();
+const kindOf = (c) => c.kind ?? (c.name === "posts" || c.name === "pages" ? c.name : void 0);
+/** The site's collections with the theme's routes and extra fields added, and where each theme collection reads. */
+function linkTheme(site, theme) {
+	const collections = site.map((c) => ({
+		...c,
+		fields: { ...c.fields }
+	}));
+	const links = [];
+	for (const t of theme) {
+		const kind = kindOf(t);
+		const found = collections.find((c) => kind ? kindOf(c) === kind : c.name === t.name);
+		const name = kind ?? t.name;
+		const target = found ?? {
+			name,
+			dir: `content/${name}`,
+			format: t.format,
+			fields: {}
+		};
+		if (!found) collections.push(target);
+		const map = t.map ?? {};
+		for (const [field, type] of Object.entries(t.fields)) target.fields[map[field] ?? field] ??= type;
+		if (t.route) target.route = t.route;
+		links.push({
+			name: t.name,
+			dir: target.dir,
+			rename: Object.fromEntries(Object.entries(map).map(([from, to]) => [to, from]))
+		});
+	}
+	return {
+		collections,
+		links
+	};
+}
+/** The site's config; with a theme, its collections linked in (`links` says where the theme reads). */
+async function loadSiteConfig(site, theme) {
+	const config = await loadConfig(site);
+	if (!theme) return {
+		...config,
+		links: []
+	};
+	const linked = linkTheme(config.collections, (await loadConfig(theme)).collections);
+	return {
+		...config,
+		collections: linked.collections,
+		links: linked.links
+	};
+}
+/** Theme frontmatter as the site stores it, or the reverse with an inverted map. */
+function renameFields(data, rename) {
+	const out = {};
+	for (const [key, value] of Object.entries(data)) out[rename[key] ?? key] = value;
+	return out;
+}
+/**
+* Copies a theme's sample entries into the site once, when it is installed: like a WordPress theme's demo import.
+* Existing site entries are never overwritten; `.md` and `.mdx` files keep their extension.
+*/
+async function importDemo(site, theme) {
+	const siteConfig = await loadConfig(site);
+	const themeConfig = await loadConfig(theme);
+	const { links } = linkTheme(siteConfig.collections, themeConfig.collections);
+	const copied = [];
+	for (const [i, t] of themeConfig.collections.entries()) {
+		const link = links[i];
+		const from = join(theme, t.dir);
+		const names = await readdir(from, { recursive: true }).catch(() => []);
+		for (const name of names.filter((n) => /\.mdx?$/.test(n)).toSorted()) {
+			const target = join(site, link.dir, name);
+			if (await access(target).then(() => true, () => false)) continue;
+			const doc = parseDocument(await readFile(join(from, name), "utf8"));
+			await mkdir(dirname(target), { recursive: true });
+			await writeFile(target, serializeDocument({
+				data: renameFields(doc.data, t.map ?? {}),
+				body: name.endsWith(".mdx") ? stripComponentImports(doc.body) : doc.body
+			}));
+			copied.push(join(link.dir, name));
+		}
+	}
+	return copied;
+}
+/** The site's Pages collection folder (`kind: "pages"`, or the collection named `pages`), if it has one. */
+const pagesDir = (collections) => collections.find((c) => kindOf(c) === "pages")?.dir;
+/** A theme's static pages (`src/pages/about.md`, `index.astro`): no `[param]` routes, `_partials` or endpoints. */
+async function themePageFiles(theme) {
+	return (await readdir(join(theme, "src/pages"), { recursive: true }).catch(() => [])).map((n) => n.split("\\").join("/")).filter((n) => /\.(mdx?|astro)$/.test(n) && !n.includes("[") && !n.split("/").some((part) => part.startsWith("_"))).toSorted();
+}
+/** A page's title from its path: `index` is Home, `tags/index` is Tags, `about-me` is About me. */
+const pageTitle = (rel) => {
+	const name = rel.replace(/(^|\/)index$/, "").split("/").at(-1) ?? "";
+	return name ? name.charAt(0).toUpperCase() + name.slice(1).replaceAll("-", " ") : "Home";
+};
+/** The URL a theme page file serves: `src/pages/tags/index.astro` → `/tags`. */
+const templateUrl = (template) => "/" + template.replace(/^src\/pages\//, "").replace(/\.astro$/, "").replace(/(^|\/)index$/, "");
+/**
+* A theme's pages become entries of the site's Pages collection, so they are listed and edited in the admin like any
+* page. Markdown pages bring their text; the theme keeps serving them at their URL with its own layout (see
+* theme-pages.ts), and the theme-specific `layout` stays in the theme file. An `.astro` page keeps its text in code: its
+* entry only names it (`template`), so the admin opens that file and edits the page's SEO fields. Existing site pages
+* are never overwritten.
+*/
+async function importPages(site, theme) {
+	const pages = (await loadSiteConfig(site, theme)).collections.find((c) => kindOf(c) === "pages");
+	if (!pages) return [];
+	const { dir } = pages;
+	const required = Object.entries(pages.fields).flatMap(([k, f]) => typeof f === "object" && f.required && (f.type === "string" || f.type === "text") ? [k] : []);
+	const copied = [];
+	for (const name of await themePageFiles(theme)) {
+		const rel = name.replace(/\.(mdx?|astro)$/, "");
+		const base = join(site, dir, rel);
+		if (await Promise.any([".md", ".mdx"].map((ext) => access(base + ext))).then(() => true, () => false)) continue;
+		const astro = name.endsWith(".astro");
+		const file = astro ? `${rel}.md` : name;
+		const doc = astro ? {
+			data: {
+				title: pageTitle(rel),
+				template: `src/pages/${name}`
+			},
+			body: ""
+		} : parseDocument(await readFile(join(theme, "src/pages", name), "utf8"));
+		const { layout: _layout, ...rest } = doc.data;
+		for (const k of required) rest[k] ??= "";
+		await mkdir(dirname(base), { recursive: true });
+		await writeFile(join(site, dir, file), serializeDocument({
+			data: rest,
+			body: doc.body
+		}));
+		copied.push(join(dir, file));
+	}
+	return copied;
+}
+
+//#endregion
+export { pagesDir as a, templateUrl as c, loadSiteConfig as i, themeRoot as l, importPages as n, renameFields as o, linkTheme as r, siteRoot as s, importDemo as t };

package/dist/site.d.mts

@@ -0,0 +1,28 @@
+import { a as resolveLocale, i as localeSwitcher, o as splitLocale, r as hreflangAlternates, t as LocaleLink } from "./index-B6AHmgP9.mjs";
+
+//#region src/site/index.d.ts
+/** Small helpers for public templates. Pure functions: no I/O, safe to import in any Astro page. */
+/** Whole minutes to read `text` at `wpm` words per minute, at least 1. */
+declare function readingTime(text: string, wpm?: number): number;
+interface Page<T> {
+  items: T[];
+  page: number;
+  pages: number;
+  prev: number | null;
+  next: number | null;
+}
+/** 1-based pagination; out-of-range or non-numeric pages clamp to the nearest valid one. */
+declare function paginate<T>(all: readonly T[], page: number | string | null | undefined, size?: number): Page<T>;
+/** Entries sharing the most values of `key` (tags, categories) with `current`, best first; `current` itself is excluded. */
+declare function related<T extends {
+  id: string;
+  data: Record<string, unknown>;
+}>(current: T, all: readonly T[], key: string, limit?: number): T[];
+/** `srcset` for an uploaded image: one allowlisted width per entry, in `format` (default WebP). */
+declare function imageSrcset(url: string, widths?: readonly number[], format?: "webp" | "avif" | "jpeg" | "png", crop?: {
+  ratio: string;
+  focalX?: number;
+  focalY?: number;
+}): string;
+//#endregion
+export { type LocaleLink, Page, hreflangAlternates, imageSrcset, localeSwitcher, paginate, readingTime, related, resolveLocale, splitLocale };

package/dist/site.mjs

@@ -0,0 +1,44 @@
+import { i as splitLocale, n as localeSwitcher, r as resolveLocale, t as hreflangAlternates } from "./i18n-CgLAHd9Q.mjs";
+
+//#region src/site/index.ts
+/** Small helpers for public templates. Pure functions: no I/O, safe to import in any Astro page. */
+/** Whole minutes to read `text` at `wpm` words per minute, at least 1. */
+function readingTime(text, wpm = 200) {
+	const words = text.match(/[\p{L}\p{N}']+/gu)?.length ?? 0;
+	return Math.max(1, Math.ceil(words / wpm));
+}
+/** 1-based pagination; out-of-range or non-numeric pages clamp to the nearest valid one. */
+function paginate(all, page, size = 10) {
+	const pages = Math.max(1, Math.ceil(all.length / size));
+	const requested = Math.floor(Number(page));
+	const current = Number.isFinite(requested) ? Math.min(Math.max(requested, 1), pages) : 1;
+	return {
+		items: all.slice((current - 1) * size, current * size),
+		page: current,
+		pages,
+		prev: current > 1 ? current - 1 : null,
+		next: current < pages ? current + 1 : null
+	};
+}
+/** Entries sharing the most values of `key` (tags, categories) with `current`, best first; `current` itself is excluded. */
+function related(current, all, key, limit = 3) {
+	const values = (e) => Array.isArray(e.data[key]) ? e.data[key].map(String) : [];
+	const mine = new Set(values(current));
+	return all.filter((e) => e.id !== current.id).map((e) => ({
+		e,
+		score: values(e).filter((v) => mine.has(v)).length
+	})).filter((x) => x.score > 0).toSorted((a, b) => b.score - a.score || a.e.id.localeCompare(b.e.id)).slice(0, limit).map((x) => x.e);
+}
+/** `srcset` for an uploaded image: one allowlisted width per entry, in `format` (default WebP). */
+function imageSrcset(url, widths = [
+	480,
+	768,
+	1024,
+	1600
+], format = "webp", crop) {
+	const extra = crop ? `&ar=${crop.ratio}${crop.focalX === void 0 ? "" : `&fx=${crop.focalX}`}${crop.focalY === void 0 ? "" : `&fy=${crop.focalY}`}` : "";
+	return widths.map((w) => `${url}?w=${w}&format=${format}${extra} ${w}w`).join(", ");
+}
+
+//#endregion
+export { hreflangAlternates, imageSrcset, localeSwitcher, paginate, readingTime, related, resolveLocale, splitLocale };

package/dist/sitemap-Ba0vil6a.mjs

@@ -0,0 +1,46 @@
+import { isPublished } from "./publishing.mjs";
+
+//#region src/seo/sitemap.ts
+async function publishedEntries(service, siteUrl, exclude = []) {
+	const out = [];
+	for (const c of service.collections) {
+		if (exclude.includes(c.name)) continue;
+		const route = c.route ?? `/${c.name}/{slug}`;
+		for (const slug of await service.list(c.name)) {
+			const entry = await service.get(c.name, slug);
+			if (!entry || !isPublished(entry.data)) continue;
+			out.push({
+				url: new URL(route.replace("{slug}", slug), siteUrl).href,
+				collection: c.name,
+				data: entry.data
+			});
+		}
+	}
+	return out;
+}
+/** Published, indexable entries (`draft` and `noindex` are skipped). `date` becomes lastmod when it is an ISO date. */
+async function contentUrls(service, siteUrl, { exclude, priority = {} } = {}) {
+	return (await publishedEntries(service, siteUrl, exclude)).filter(({ data }) => data.noindex !== true).map(({ url, collection, data }) => ({
+		loc: url,
+		...typeof data.date === "string" ? { lastmod: data.date } : {},
+		...priority[collection] === void 0 ? {} : { priority: priority[collection] }
+	}));
+}
+/** Dated, published entries, newest first. Undated entries are left out: a feed needs a pubDate. */
+async function contentFeed(service, siteUrl, limit = 50) {
+	const items = [];
+	for (const { url, data } of await publishedEntries(service, siteUrl)) {
+		const date = typeof data.date === "string" || data.date instanceof Date ? new Date(data.date) : null;
+		if (!date || Number.isNaN(date.getTime())) continue;
+		items.push({
+			link: url,
+			title: typeof data.title === "string" ? data.title : url,
+			date,
+			...typeof data.description === "string" ? { description: data.description } : {}
+		});
+	}
+	return items.toSorted((a, b) => b.date.getTime() - a.date.getTime()).slice(0, limit);
+}
+
+//#endregion
+export { contentUrls as n, contentFeed as t };