cosmolo 0.3.0

package/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "cosmolo",
+	"version": "0.3.0",
+	"type": "module",
+	"bin": {
+		"cosmolo": "./src/cli/index.ts"
+	},
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"default": "./src/index.ts"
+		},
+		"./plugin": {
+			"types": "./src/plugin.ts",
+			"default": "./src/plugin.ts"
+		}
+	},
+	"files": ["src", "templates", "!src/**/*.test.ts"],
+	"dependencies": {
+		"gray-matter": "^4.0.3",
+		"marked": "^15.0.0",
+		"zod": "^3.0.0"
+	},
+	"peerDependencies": {
+		"vite": ">=5.0.0",
+		"@sveltejs/kit": ">=2.0.0"
+	}
+}

package/src/articles.ts

@@ -0,0 +1,124 @@
+import { z } from 'zod';
+import matter from 'gray-matter';
+import { renderMarkdown, generateToc } from './markdown.js';
+import { isKnownCategory } from './categories.js';
+import type { Article, ResolvedCosmoloConfig } from './types.js';
+import { rawMdFiles, svxModules } from 'cosmolo:content';
+
+export const articleFrontmatterSchema = z.object({
+	title: z.string(),
+	category: z.string(),
+	excerpt: z.string(),
+	sort: z.number().default(0),
+	date: z.preprocess(
+		(val) => (val instanceof Date ? val.toISOString().split('T')[0] : val),
+		z.string().default('')
+	),
+	tags: z.array(z.string()).default([]),
+	series: z.string().optional(),
+	seriesOrder: z.number().optional(),
+	draft: z.boolean().default(false),
+	related: z.array(z.string()).default([]),
+});
+
+function slugFromPath(filePath: string, dir: string): string {
+	const prefix = dir.replace(/^\//, '');
+	return filePath
+		.replace(new RegExp(`^/?${prefix}/`), '')
+		.replace(/\.(md|svx)$/, '');
+}
+
+/** Returns all non-draft articles sorted by `sort` descending. */
+export function getArticles(config: ResolvedCosmoloConfig): Article[] {
+	const articles: Article[] = [];
+
+	for (const [filePath, raw] of Object.entries(rawMdFiles)) {
+		const slug = slugFromPath(filePath, config.articlesDir);
+		const { data } = matter(raw);
+		const frontmatter = articleFrontmatterSchema.parse(data);
+		if (frontmatter.draft) continue;
+		articles.push({ ...frontmatter, slug, html: '', markdown: '', toc: [] });
+	}
+
+	for (const [filePath, mod] of Object.entries(svxModules)) {
+		const slug = slugFromPath(filePath, config.articlesDir);
+		const frontmatter = articleFrontmatterSchema.parse(
+			(mod as { metadata: Record<string, unknown> }).metadata
+		);
+		if (frontmatter.draft) continue;
+		articles.push({ ...frontmatter, slug, html: '', markdown: '', toc: [] });
+	}
+
+	return articles.sort((a, b) => b.sort - a.sort);
+}
+
+/** Returns all non-draft article slugs. */
+export function getSlugs(config: ResolvedCosmoloConfig): string[] {
+	return getArticles(config).map((a) => a.slug);
+}
+
+/** Returns a single article with rendered HTML and TOC. Draft articles are included. */
+export async function getArticle(config: ResolvedCosmoloConfig, slug: string): Promise<Article> {
+	const dir = config.articlesDir.replace(/^\//, '');
+	const mdPath = `/${dir}/${slug}.md`;
+	const svxPath = `/${dir}/${slug}.svx`;
+
+	if (rawMdFiles[mdPath] !== undefined) {
+		const raw = rawMdFiles[mdPath];
+		const { data, content } = matter(raw);
+		const frontmatter = articleFrontmatterSchema.parse(data);
+		const html = await renderMarkdown(content);
+		const toc = generateToc(content);
+		return { ...frontmatter, slug, html, markdown: content, toc };
+	}
+
+	if (svxModules[svxPath] !== undefined) {
+		const frontmatter = articleFrontmatterSchema.parse(
+			(svxModules[svxPath] as { metadata: Record<string, unknown> }).metadata
+		);
+		return { ...frontmatter, slug, html: '', markdown: '', toc: [] };
+	}
+
+	throw new Error(`Article not found: ${slug}`);
+}
+
+export function getArticlesByCategory(
+	config: ResolvedCosmoloConfig,
+	categorySlug: string,
+	excludeSlug?: string
+): Article[] {
+	const all = getArticles(config);
+	const filtered =
+		categorySlug === 'other'
+			? all.filter((a) => !isKnownCategory(config, a.category))
+			: all.filter((a) => a.category === categorySlug);
+	return excludeSlug ? filtered.filter((a) => a.slug !== excludeSlug) : filtered;
+}
+
+export function getArticlesByTag(config: ResolvedCosmoloConfig, tag: string): Article[] {
+	return getArticles(config).filter((a) => a.tags.includes(tag));
+}
+
+export function getArticlesBySeries(config: ResolvedCosmoloConfig, seriesKey: string): Article[] {
+	return getArticles(config)
+		.filter((a) => a.series === seriesKey)
+		.sort((a, b) => (a.seriesOrder ?? 0) - (b.seriesOrder ?? 0));
+}
+
+export function getTags(config: ResolvedCosmoloConfig): string[] {
+	const tags = new Set<string>();
+	getArticles(config).forEach((a) => a.tags.forEach((t) => tags.add(t)));
+	return Array.from(tags).sort();
+}
+
+/**
+ * Returns the Svelte component constructor for an .svx article, or undefined
+ * if the article is a plain .md file. Safe to call from Svelte components.
+ */
+export function getSvxComponent(
+	config: ResolvedCosmoloConfig,
+	slug: string
+): unknown | undefined {
+	const dir = '/' + config.articlesDir.replace(/^\/|\/$/g, '');
+	return (svxModules[`${dir}/${slug}.svx`] as { default: unknown } | undefined)?.default;
+}

package/src/categories.ts

@@ -0,0 +1,35 @@
+import { categoriesData, siteConfigData } from 'cosmolo:content';
+import type { CategoryEntry, ResolvedCosmoloConfig, SiteConfig } from './types.js';
+
+type CategoriesMap = Record<string, { label: string; description: string }>;
+
+const map = categoriesData as CategoriesMap;
+
+export function getAllCategories(_config: ResolvedCosmoloConfig): CategoryEntry[] {
+	return Object.entries(map).map(([slug, { label, description }]) => ({
+		slug,
+		label,
+		description,
+	}));
+}
+
+export function isKnownCategory(_config: ResolvedCosmoloConfig, key: string): boolean {
+	return Object.prototype.hasOwnProperty.call(map, key);
+}
+
+export function getCategoryLabel(_config: ResolvedCosmoloConfig, key: string): string {
+	if (Object.prototype.hasOwnProperty.call(map, key)) return map[key].label;
+	return (siteConfigData as SiteConfig).fallbackCategoryLabel;
+}
+
+export function getCategoryDescription(_config: ResolvedCosmoloConfig, key: string): string {
+	return map[key]?.description ?? '';
+}
+
+export function getCategorySlugs(_config: ResolvedCosmoloConfig): string[] {
+	return [...Object.keys(map), 'other'];
+}
+
+export function loadSiteConfig(_config: ResolvedCosmoloConfig): SiteConfig {
+	return siteConfigData as SiteConfig;
+}

package/src/cli/generate.ts

@@ -0,0 +1,190 @@
+import * as readline from 'readline';
+import * as fs from 'fs';
+import * as path from 'path';
+import { DEFAULT_CONFIG } from '../config.js';
+import type { ResolvedCosmoloConfig } from '../types.js';
+
+// ─── config ──────────────────────────────────────────────────────────────────
+
+async function loadConfig(): Promise<ResolvedCosmoloConfig> {
+	const root = process.cwd();
+	for (const name of ['cosmolo.config.ts', 'cosmolo.config.js']) {
+		const p = path.join(root, name);
+		if (fs.existsSync(p)) {
+			try {
+				const mod = await import(p);
+				return mod.default as ResolvedCosmoloConfig;
+			} catch {
+				// fall through to defaults
+			}
+		}
+	}
+	return DEFAULT_CONFIG;
+}
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function ask(rl: readline.Interface, question: string, fallback = ''): Promise<string> {
+	const hint = fallback ? ` [${fallback}]` : '';
+	return new Promise((resolve) =>
+		rl.question(`  ${question}${hint}: `, (ans) => resolve(ans.trim() || fallback))
+	);
+}
+
+function slugify(text: string): string {
+	return text
+		.toLowerCase()
+		.replace(/[^\w\s-]/g, '')
+		.trim()
+		.replace(/[\s_]+/g, '-')
+		.replace(/-+/g, '-');
+}
+
+function today(): string {
+	return new Date().toISOString().split('T')[0];
+}
+
+function readCategories(config: ResolvedCosmoloConfig): Record<string, { label: string; description: string }> {
+	const p = path.resolve(process.cwd(), config.categoriesConfigPath);
+	if (!fs.existsSync(p)) return {};
+	return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+
+// ─── generators ──────────────────────────────────────────────────────────────
+
+async function generateArticle(rl: readline.Interface, config: ResolvedCosmoloConfig): Promise<void> {
+	console.log('\nGenerate Article\n');
+
+	const title = await ask(rl, 'Title');
+	if (!title) { console.error('\nError: Title is required.'); process.exit(1); }
+
+	const defaultSlug = slugify(title);
+	const slug = await ask(rl, 'Slug', defaultSlug);
+
+	const articlesDir = path.resolve(process.cwd(), config.articlesDir);
+	const filePath = path.join(articlesDir, `${slug}.md`);
+
+	if (fs.existsSync(filePath)) {
+		console.error(`\nError: ${config.articlesDir}/${slug}.md already exists.`);
+		process.exit(1);
+	}
+
+	const categories = readCategories(config);
+	const catKeys = Object.keys(categories);
+	if (catKeys.length > 0) console.log(`\n  Categories: ${catKeys.join(', ')}`);
+
+	const category    = await ask(rl, 'Category', catKeys[0] ?? 'other');
+	const excerpt     = await ask(rl, 'Excerpt', '');
+	const tagsRaw     = await ask(rl, 'Tags (comma-separated)', '');
+	const tags        = tagsRaw ? tagsRaw.split(',').map((t) => t.trim()).filter(Boolean) : [];
+	const sort        = await ask(rl, 'Sort', '0');
+	const date        = await ask(rl, 'Date', today());
+	const draftAns    = await ask(rl, 'Draft? (y/N)', 'N');
+	const draft       = draftAns.toLowerCase() === 'y';
+	const series      = await ask(rl, 'Series (optional)', '');
+	const seriesOrder = series ? await ask(rl, 'Series order', '1') : '';
+
+	const lines = [
+		'---',
+		`title: "${title}"`,
+		`category: "${category}"`,
+		`excerpt: "${excerpt}"`,
+		`sort: ${parseInt(sort, 10) || 0}`,
+		`date: "${date}"`,
+	];
+	if (tags.length > 0) lines.push(`tags: [${tags.map((t) => `"${t}"`).join(', ')}]`);
+	if (series) {
+		lines.push(`series: "${series}"`);
+		lines.push(`seriesOrder: ${parseInt(seriesOrder, 10) || 1}`);
+	}
+	if (draft) lines.push('draft: true');
+	lines.push('---', '', '');
+
+	fs.mkdirSync(articlesDir, { recursive: true });
+	fs.writeFileSync(filePath, lines.join('\n'));
+	console.log(`\nCreated: ${config.articlesDir}/${slug}.md`);
+}
+
+async function generatePage(rl: readline.Interface, config: ResolvedCosmoloConfig): Promise<void> {
+	console.log('\nGenerate Page\n');
+
+	const title = await ask(rl, 'Title');
+	if (!title) { console.error('\nError: Title is required.'); process.exit(1); }
+
+	const defaultSlug = slugify(title);
+	const slug = await ask(rl, 'Slug', defaultSlug);
+
+	const pagesDir = path.resolve(process.cwd(), config.pagesDir);
+	const filePath = path.join(pagesDir, `${slug}.md`);
+
+	if (fs.existsSync(filePath)) {
+		console.error(`\nError: ${config.pagesDir}/${slug}.md already exists.`);
+		process.exit(1);
+	}
+
+	const content = ['---', `title: "${title}"`, '---', '', ''].join('\n');
+	fs.mkdirSync(pagesDir, { recursive: true });
+	fs.writeFileSync(filePath, content);
+	console.log(`\nCreated: ${config.pagesDir}/${slug}.md`);
+}
+
+async function generateCategory(rl: readline.Interface, config: ResolvedCosmoloConfig): Promise<void> {
+	console.log('\nGenerate Category\n');
+
+	const key = await ask(rl, 'Key (slug)');
+	if (!key) { console.error('\nError: Key is required.'); process.exit(1); }
+
+	const categoriesPath = path.resolve(process.cwd(), config.categoriesConfigPath);
+	const categories = readCategories(config);
+
+	if (categories[key]) {
+		console.error(`\nError: Category "${key}" already exists.`);
+		process.exit(1);
+	}
+
+	const label       = await ask(rl, 'Label');
+	const description = await ask(rl, 'Description', '');
+
+	categories[key] = { label, description };
+	fs.mkdirSync(path.dirname(categoriesPath), { recursive: true });
+	fs.writeFileSync(categoriesPath, JSON.stringify(categories, null, '\t') + '\n');
+	console.log(`\nAdded: "${key}" to ${config.categoriesConfigPath}`);
+}
+
+// ─── main ─────────────────────────────────────────────────────────────────────
+
+export async function main(): Promise<void> {
+	const config = await loadConfig();
+	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+	const subcommand = process.argv[3]; // argv[2] is "generate"
+
+	const commands: Record<string, (rl: readline.Interface, config: ResolvedCosmoloConfig) => Promise<void>> = {
+		article:  generateArticle,
+		page:     generatePage,
+		category: generateCategory,
+	};
+
+	try {
+		if (subcommand && commands[subcommand]) {
+			await commands[subcommand](rl, config);
+		} else if (subcommand) {
+			console.error(`Unknown subcommand: ${subcommand}`);
+			console.error('Available: article, page, category');
+			process.exit(1);
+		} else {
+			console.log('Cosmolo Generator\n');
+			console.log('  1. Article');
+			console.log('  2. Page');
+			console.log('  3. Category');
+			const choice = await new Promise<string>((resolve) =>
+				rl.question('\nWhat would you like to generate? (1/2/3): ', (ans) => resolve(ans.trim()))
+			);
+			const picked = ({ '1': generateArticle, '2': generatePage, '3': generateCategory } as Record<string, typeof generateArticle>)[choice];
+			if (!picked) { console.error('Invalid choice.'); process.exit(1); }
+			await picked(rl, config);
+		}
+	} finally {
+		rl.close();
+	}
+}

package/src/cli/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env bun
+export {};
+
+const cmd = process.argv[2];
+
+switch (cmd) {
+	case 'init':
+		await (await import('./init.js')).main();
+		break;
+	case 'generate':
+		await (await import('./generate.js')).main();
+		break;
+	default: {
+		const isUnknown = Boolean(cmd);
+		if (isUnknown) console.error(`Unknown command: ${cmd}\n`);
+		console.log('Usage: cosmolo <command>\n');
+		console.log('Commands:');
+		console.log('  init                             Scaffold routes into an existing SvelteKit project');
+		console.log('  generate [article|page|category] Create content files');
+		process.exit(isUnknown ? 1 : 0);
+	}
+}

package/src/cli/init.ts

@@ -0,0 +1,173 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { fileURLToPath } from 'url';
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const TEMPLATE_DIR = path.resolve(__dirname, '../../templates');
+
+function ask(rl: readline.Interface, question: string): Promise<string> {
+	return new Promise((resolve) => rl.question(question, resolve));
+}
+
+function copyFile(src: string, dest: string): void {
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	fs.copyFileSync(src, dest);
+}
+
+function writeFile(dest: string, content: string): void {
+	fs.mkdirSync(path.dirname(dest), { recursive: true });
+	fs.writeFileSync(dest, content, 'utf-8');
+}
+
+function collectFiles(dir: string): Array<[string, string]> {
+	const results: Array<[string, string]> = [];
+	function walk(current: string) {
+		for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+			const full = path.join(current, entry.name);
+			if (entry.isDirectory()) walk(full);
+			else results.push([full, path.relative(dir, full)]);
+		}
+	}
+	walk(dir);
+	return results;
+}
+
+function destPath(relativePath: string, projectRoot: string): string {
+	const mapped = relativePath
+		.replace(/^routes\//, 'src/routes/')
+		.replace(/^lib\//, 'src/lib/');
+	return path.join(projectRoot, mapped);
+}
+
+function injectPackageScripts(projectRoot: string): void {
+	const pkgPath = path.join(projectRoot, 'package.json');
+	if (!fs.existsSync(pkgPath)) return;
+
+	const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+	pkg.scripts = pkg.scripts ?? {};
+
+	let added = false;
+	const scripts: Record<string, string> = {
+		'generate:article':  'cosmolo generate article',
+		'generate:page':     'cosmolo generate page',
+		'generate:category': 'cosmolo generate category',
+	};
+	for (const [key, val] of Object.entries(scripts)) {
+		if (!pkg.scripts[key]) {
+			pkg.scripts[key] = val;
+			added = true;
+		}
+	}
+
+	if (added) {
+		fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, '\t') + '\n');
+		console.log('  updated  package.json (added generate:* scripts)');
+	}
+}
+
+// ─── main ─────────────────────────────────────────────────────────────────────
+
+export async function main(): Promise<void> {
+	const PROJECT_ROOT = process.cwd();
+	const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+	console.log('\ncosmolo init\n');
+
+	// ── Mode selection ──────────────────────────────────────────────────────
+	console.log('Choose an initialization mode:\n');
+	console.log('  A) Full  — server routes + Svelte page components');
+	console.log('  B) Slim  — server routes only (bring your own Svelte UI)\n');
+
+	let modeRaw = '';
+	while (!['a', 'b'].includes(modeRaw)) {
+		modeRaw = (await ask(rl, 'Mode [A/B]: ')).trim().toLowerCase();
+		if (!['a', 'b'].includes(modeRaw)) console.log('  Please enter A or B.');
+	}
+	const mode: 'full' | 'slim' = modeRaw === 'a' ? 'full' : 'slim';
+
+	// ── Adapter selection ───────────────────────────────────────────────────
+	console.log('\nChoose your deployment adapter:\n');
+	console.log('  1) SSG              — @sveltejs/adapter-static (Cloudflare Pages static, GitHub Pages, etc.)');
+	console.log('  2) Serverless/SSR   — Cloudflare Workers, Vercel, Node, etc.\n');
+
+	let adapterRaw = '';
+	while (!['1', '2'].includes(adapterRaw)) {
+		adapterRaw = (await ask(rl, 'Adapter [1/2]: ')).trim();
+		if (!['1', '2'].includes(adapterRaw)) console.log('  Please enter 1 or 2.');
+	}
+	const isSSG = adapterRaw === '1';
+
+	rl.close();
+
+	// ── Collect files ───────────────────────────────────────────────────────
+	const sharedFiles = collectFiles(path.join(TEMPLATE_DIR, 'shared'));
+	const fullFiles = mode === 'full' ? collectFiles(path.join(TEMPLATE_DIR, 'full')) : [];
+
+	const allFiles: Array<[string, string]> = [
+		...sharedFiles.map(([src, rel]) => [src, rel] as [string, string]),
+		...fullFiles.map(([src, rel]) => [src, rel] as [string, string]),
+	];
+
+	const layoutTsPath = path.join(PROJECT_ROOT, 'src/routes/+layout.ts');
+	const layoutTsContent = 'export const prerender = true;\n';
+
+	// ── Conflict detection ──────────────────────────────────────────────────
+	const conflicts: string[] = [];
+
+	for (const [, rel] of allFiles) {
+		const dest = destPath(rel, PROJECT_ROOT);
+		if (fs.existsSync(dest)) conflicts.push(path.relative(PROJECT_ROOT, dest));
+	}
+	if (isSSG && fs.existsSync(layoutTsPath)) {
+		conflicts.push(path.relative(PROJECT_ROOT, layoutTsPath));
+	}
+
+	if (conflicts.length > 0) {
+		console.error('\nError: The following files already exist and would be overwritten:\n');
+		for (const f of conflicts) console.error(`  ${f}`);
+		console.error('\nTo resolve, either:');
+		console.error('  1. Remove or rename the conflicting files, then run cosmolo init again.');
+		console.error('  2. Manually copy the needed templates from the cosmolo package:');
+		console.error(`     node_modules/cosmolo/templates/shared/`);
+		if (mode === 'full') console.error(`     node_modules/cosmolo/templates/full/`);
+		if (isSSG) {
+			console.error('\n  For SSG prerendering, add this to src/routes/+layout.ts manually:');
+			console.error('     export const prerender = true;');
+		}
+		process.exit(1);
+	}
+
+	// ── Write files ─────────────────────────────────────────────────────────
+	for (const [src, rel] of allFiles) {
+		const dest = destPath(rel, PROJECT_ROOT);
+		copyFile(src, dest);
+		console.log(`  created  ${path.relative(PROJECT_ROOT, dest)}`);
+	}
+
+	if (isSSG) {
+		writeFile(layoutTsPath, layoutTsContent);
+		console.log(`  created  src/routes/+layout.ts`);
+	}
+
+	injectPackageScripts(PROJECT_ROOT);
+
+	// ── Next steps ──────────────────────────────────────────────────────────
+	console.log('\nDone! Next steps:\n');
+	console.log('  1. Install cosmolo:  npm install cosmolo  (or bun add cosmolo)');
+	if (isSSG) {
+		console.log('  2. Install adapter:  npm install -D @sveltejs/adapter-static');
+	} else {
+		console.log('  2. Install adapter:  npm install -D @sveltejs/adapter-cloudflare  (or your adapter)');
+	}
+	if (mode === 'full') {
+		console.log('  3. Install sass:     npm install -D sass  (SCSS used in Svelte templates)');
+		console.log('  4. Run:              npm run dev');
+	} else {
+		console.log('  3. Add your own +page.svelte files for each route.');
+		console.log('  4. Run:              npm run dev');
+	}
+	console.log('\n  See https://github.com/alcogy/cosmolo for full documentation.\n');
+}

package/src/config.ts

@@ -0,0 +1,12 @@
+import type { CosmoloConfig, ResolvedCosmoloConfig } from './types.js';
+
+export const DEFAULT_CONFIG: ResolvedCosmoloConfig = {
+	articlesDir: 'src/content/articles',
+	pagesDir: 'src/content/pages',
+	siteConfigPath: 'config/site.json',
+	categoriesConfigPath: 'config/categories.json',
+};
+
+export function resolveConfig(userConfig: CosmoloConfig = {}): ResolvedCosmoloConfig {
+	return { ...DEFAULT_CONFIG, ...userConfig };
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+export type {
+	CosmoloConfig,
+	ResolvedCosmoloConfig,
+	TocEntry,
+	ArticleFrontmatter,
+	Article,
+	Page,
+	CategoryEntry,
+	SiteConfig,
+} from './types.js';
+
+export { DEFAULT_CONFIG, resolveConfig } from './config.js';
+export {
+	getAllCategories,
+	isKnownCategory,
+	getCategoryLabel,
+	getCategoryDescription,
+	getCategorySlugs,
+	loadSiteConfig,
+} from './categories.js';
+export { articleFrontmatterSchema, getArticles, getArticle, getSlugs, getArticlesByCategory, getArticlesByTag, getArticlesBySeries, getTags, getSvxComponent } from './articles.js';
+export { getPageSlugs, getPage } from './pages.js';
+export { renderMarkdown, generateToc } from './markdown.js';
+export {
+	createArticlesLoader,
+	createArticleLoader,
+	createCategoryLoader,
+	createTagLoader,
+	createPageLoader,
+	createArticleEntries,
+	createCategoryEntries,
+	createTagEntries,
+	createPageEntries,
+} from './loaders.js';