@twango/twiki 0.0.0-stage → 0.1.1

package/site/tooling/lib/runtime-data-modules.ts

@@ -0,0 +1,30 @@
+import path from 'node:path';
+
+// Content changes update these revalidated assets without renaming application
+// chunks referenced by every prerendered page. Keep them outside _app/immutable.
+export const runtimeDataAssets = {
+	'nav.json': 'navigation.js',
+	'file-icons.json': 'file-icons.js'
+} as const;
+
+export function runtimeDataModuleSource(data: unknown): string {
+	// JSON.parse preserves own "__proto__" keys in filename/folder catalogs;
+	// a JavaScript object literal would interpret those keys as prototype setters.
+	return `export default JSON.parse(${JSON.stringify(JSON.stringify(data))});\n`;
+}
+
+export function resolveRuntimeDataImport(
+	source: string,
+	config: { root: string; command: 'build' | 'serve'; consumer?: 'client' | 'server' }
+) {
+	if (config.command !== 'build' || config.consumer !== 'client') return;
+	// SSR and development retain the JSON import. Production browsers load exactly
+	// the same edition-specific data through the authenticated asset routing layer.
+	for (const [input, asset] of Object.entries(runtimeDataAssets)) {
+		if (
+			source === `$lib/generated/${input}` ||
+			source === path.join(config.root, 'src/lib/generated', input)
+		)
+			return { id: `/${asset}`, external: 'absolute' as const };
+	}
+}

package/site/tooling/lib/runtime-packaging.ts

@@ -0,0 +1,321 @@
+import {
+	constants,
+	cpSync,
+	existsSync,
+	lstatSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	readdirSync,
+	realpathSync,
+	renameSync,
+	rmSync,
+	writeFileSync
+} from 'node:fs';
+import path from 'node:path';
+import type { ContentManifest, PageDoc } from '../../src/lib/types';
+import { fileRoute } from '../../src/lib/files';
+import { createContentModel } from '../../src/lib/server/content-model';
+import { captureAssetHashes } from './asset-hash-cache';
+import { sha256 } from './deployment-config';
+import {
+	assetContentType,
+	createAssetInventory,
+	mergeVerifiedInventories,
+	type AssetInventory,
+	type DeploymentAsset
+} from './deployment-manifest';
+
+export type RuntimeEdition = 'public' | 'full';
+export type CapturedEdition = {
+	edition: RuntimeEdition;
+	metadata: string;
+	staticRoot: string;
+	routes: string[];
+	staticAssets: Record<string, DeploymentAsset>;
+	sources: Record<string, string>;
+};
+const copyOptions = { recursive: true, mode: constants.COPYFILE_FICLONE, preserveTimestamps: true };
+const urlPath = (file: string) => '/' + file.split('/').map(encodeURIComponent).join('/');
+function ownedFile(root: string, file: string) {
+	const absolute = path.resolve(root, file);
+	if (
+		!absolute.startsWith(path.resolve(root) + path.sep) ||
+		!lstatSync(absolute).isFile() ||
+		realpathSync(absolute) !== absolute
+	)
+		throw new Error('Runtime artifact must be an owned regular file');
+	return absolute;
+}
+function files(directory: string): string[] {
+	const result: string[] = [];
+	function walk(relative: string) {
+		for (const entry of readdirSync(path.join(directory, relative), { withFileTypes: true })) {
+			const file = relative ? `${relative}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) walk(file);
+			else {
+				ownedFile(directory, file);
+				result.push(file);
+			}
+		}
+	}
+	walk('');
+	return result.sort();
+}
+function copy(source: string, destination: string) {
+	mkdirSync(path.dirname(destination), { recursive: true });
+	cpSync(source, destination, copyOptions);
+}
+function asset(site: string, source: string, filename: string): DeploymentAsset {
+	return { ...captureAssetHashes(site, source), contentType: assetContentType(filename) };
+}
+function staticFiles(root: string) {
+	return files(root).filter(
+		(file) => !file.startsWith('.') && !['_headers', '_redirects', '_worker.js'].includes(file)
+	);
+}
+
+/** Capture an edition immediately after its pipeline, before the next edition replaces shared JSON. */
+export function captureRuntimeEdition(
+	site: string,
+	edition: RuntimeEdition,
+	metadata: string,
+	searchDirectory?: string
+): CapturedEdition {
+	if (existsSync(metadata)) throw new Error('Runtime metadata staging already exists');
+	mkdirSync(metadata, { recursive: true });
+	const generated = path.join(site, 'build/generated');
+	const manifest: ContentManifest = JSON.parse(
+		readFileSync(ownedFile(generated, 'content-manifest.json'), 'utf8')
+	);
+	copy(ownedFile(generated, 'content-manifest.json'), path.join(metadata, 'manifest.json'));
+	for (const slug of Object.keys(manifest.pages)) {
+		const name = `pages/${slug}.json`;
+		const source = ownedFile(generated, name);
+		const page: PageDoc = JSON.parse(readFileSync(source, 'utf8'));
+		if (
+			page.slug !== slug ||
+			page.publication.public !== manifest.pages[slug].publication.public ||
+			(edition === 'public' &&
+				!page.publication.public &&
+				(!page.locked || page.html || page.markdown || page.description))
+		)
+			throw new Error('Runtime PageDoc publication does not match its edition');
+		copy(source, path.join(metadata, name));
+	}
+	for (const name of ['nav.json', 'file-icons.json'])
+		copy(ownedFile(path.join(site, 'src/lib/generated'), name), path.join(metadata, name));
+	const staticRoot = path.join(
+		site,
+		edition === 'public' ? 'build/generated/public-static' : 'static'
+	);
+	const staticAssets: Record<string, DeploymentAsset> = Object.create(null);
+	const sources: Record<string, string> = Object.create(null);
+	for (const name of staticFiles(staticRoot)) {
+		if (name.startsWith('pagefind/')) continue;
+		if (/^(?:_app|_content|_published)(?:\/|$)/.test(name))
+			throw new Error('Runtime assets cannot replace application/internal namespaces');
+		sources[name] = ownedFile(staticRoot, name);
+		staticAssets[name] = asset(site, sources[name], urlPath(name));
+	}
+	if (searchDirectory)
+		for (const name of files(path.join(searchDirectory, 'pagefind'))) {
+			const target = `pagefind/${name}`;
+			sources[target] = ownedFile(path.join(searchDirectory, 'pagefind'), name);
+			staticAssets[target] = asset(site, sources[target], urlPath(target));
+		}
+	const model = createContentModel(manifest);
+	const routes = new Set([
+		'/',
+		'/tags',
+		'/index.xml',
+		'/sitemap.xml',
+		'/graph.json',
+		'/robots.txt',
+		'/404',
+		...model.contentEntries().map((route) => (route ? '/' + route : '/')),
+		...Object.keys(manifest.tags).map((tag) => `/tags/${tag}`)
+	]);
+	const catalogs = path.join(staticRoot, '_files/index');
+	if (existsSync(catalogs))
+		for (const name of readdirSync(catalogs)) {
+			if (!name.endsWith('.json')) continue;
+			const course = name.slice(0, -5);
+			const entries = JSON.parse(readFileSync(ownedFile(catalogs, name), 'utf8')) as {
+				path: string;
+			}[];
+			routes.add(fileRoute(course, ''));
+			for (const entry of entries) {
+				const segments = entry.path.split('/');
+				for (let i = 1; i <= segments.length; i++)
+					routes.add(fileRoute(course, segments.slice(0, i).join('/')));
+			}
+		}
+	const aliases: Record<string, string> = Object.create(null);
+	for (const name of Object.keys(staticAssets))
+		aliases[urlPath(name)] = edition === 'public' ? `/_published${urlPath(name)}` : urlPath(name);
+	for (const name of manifest.htmlAssets) {
+		const target =
+			edition === 'public' ? `/_published${urlPath(`${name}.html`)}` : urlPath(`${name}.html`);
+		if (!staticAssets[`${name}.html`]) throw new Error('Runtime HTML asset is missing');
+		aliases[urlPath(name)] = aliases[urlPath(`${name}.html`)] = target;
+	}
+	const navHash = captureAssetHashes(site, path.join(metadata, 'nav.json')).sha256;
+	const iconHash = captureAssetHashes(site, path.join(metadata, 'file-icons.json')).sha256;
+	const manifestHash = captureAssetHashes(site, path.join(metadata, 'manifest.json')).sha256;
+	const htmlKeys: Record<string, string> = Object.create(null);
+	for (const route of routes) {
+		const slug = model.pageSlugForRoute(route === '/' ? '' : route.slice(1));
+		htmlKeys[route] = slug
+			? sha256(
+					JSON.stringify([
+						captureAssetHashes(site, path.join(metadata, `pages/${slug}.json`)).sha256,
+						navHash,
+						iconHash
+					])
+				)
+			: sha256(JSON.stringify([manifestHash, navHash, iconHash, route]));
+	}
+	writeFileSync(
+		path.join(metadata, 'routing.json'),
+		JSON.stringify({ schemaVersion: 1, routes: [...routes].sort(), assets: aliases, htmlKeys })
+	);
+	return { edition, metadata, staticRoot, routes: [...routes].sort(), staticAssets, sources };
+}
+
+export function packageRuntime(
+	site: string,
+	output: string,
+	applicationVersion: string,
+	editions: CapturedEdition[],
+	appInventory: AssetInventory
+) {
+	if (
+		!/^[a-f0-9]{64}$/.test(applicationVersion) ||
+		editions.length !== 2 ||
+		new Set(editions.map((value) => value.edition)).size !== 2
+	)
+		throw new Error('Runtime package requires one verified public and full edition');
+	const pieces = [{ owner: 'application', inventory: appInventory }];
+	const ownership: Record<string, { owner: string; sha256: string; size: number }> =
+		Object.create(null);
+	for (const [name, value] of Object.entries(appInventory.assets))
+		ownership[name] = { owner: 'application', sha256: value.sha256, size: value.size };
+	const snapshots = { public: '', full: '' };
+	for (const edition of editions) {
+		if (edition.edition === 'public') {
+			const routeFile = path.join(edition.metadata, 'routing.json');
+			const routing = JSON.parse(readFileSync(routeFile, 'utf8'));
+			for (const [name, value] of Object.entries(appInventory.assets)) {
+				if (!name.startsWith('/_app/') && !name.startsWith('/fonts/') && name !== '/favicon.png')
+					continue;
+				const key = urlPath(name.slice(1));
+				const inherited = edition.staticAssets[name.slice(1)];
+				if (inherited && (inherited.sha256 !== value.sha256 || inherited.size !== value.size))
+					throw new Error('Shared application asset conflicts with public static output');
+				routing.assets[key] = key;
+			}
+			writeFileSync(routeFile, JSON.stringify(routing));
+		}
+		const metadataAssets: Record<string, DeploymentAsset> = Object.create(null);
+		for (const name of files(edition.metadata))
+			metadataAssets[name] = asset(site, ownedFile(edition.metadata, name), urlPath(name));
+		const snapshot = sha256(
+			JSON.stringify([
+				edition.edition,
+				Object.entries(metadataAssets).map(([name, value]) => [name, value.sha256, value.size]),
+				Object.entries(edition.staticAssets).map(([name, value]) => [
+					name,
+					value.sha256,
+					value.size
+				])
+			])
+		);
+		snapshots[edition.edition] = snapshot;
+		const assets: Record<string, DeploymentAsset> = Object.create(null);
+		for (const [name, value] of Object.entries(metadataAssets)) {
+			const physical = `/_content/${edition.edition}/${snapshot}/${name}`;
+			copy(ownedFile(edition.metadata, name), path.join(output, physical));
+			assets[physical] = value;
+		}
+		for (const [name, value] of Object.entries(edition.staticAssets)) {
+			const physical = edition.edition === 'public' ? `/_published/${name}` : `/${name}`;
+			const source = edition.sources[name];
+			if (!source || !lstatSync(source).isFile() || realpathSync(source) !== source)
+				throw new Error('Runtime source changed before packaging');
+			copy(source, path.join(output, physical));
+			assets[physical] = value;
+		}
+		const product = createAssetInventory(assets, snapshot);
+		pieces.push({ owner: edition.edition, inventory: product });
+		for (const [name, value] of Object.entries(assets))
+			ownership[name] = { owner: edition.edition, sha256: value.sha256, size: value.size };
+	}
+	const descriptor = Buffer.from(
+		JSON.stringify({ schemaVersion: 1, applicationVersion, snapshots })
+	);
+	const provenance = sha256(descriptor);
+	const currentPath = path.join(output, '_content/current.json');
+	mkdirSync(path.dirname(currentPath), { recursive: true });
+	writeFileSync(currentPath, descriptor); // Immutable snapshots are complete before the current pointer appears.
+	const control = createAssetInventory(
+		{ '/_content/current.json': asset(site, currentPath, '/_content/current.json') },
+		provenance
+	);
+	pieces.push({ owner: 'current', inventory: control });
+	ownership['/_content/current.json'] = {
+		owner: 'current',
+		sha256: control.assets['/_content/current.json'].sha256,
+		size: descriptor.length
+	};
+	const inventory = mergeVerifiedInventories({
+		pieces,
+		expectedProducts: Object.fromEntries(
+			pieces.map((piece) => [
+				piece.owner,
+				{ provenance: piece.inventory.provenance, digest: piece.inventory.digest }
+			])
+		),
+		ownership,
+		provenance,
+		controlFiles: appInventory.controlFiles
+	});
+	return {
+		snapshots,
+		provenance,
+		inventory,
+		publicRoutes: editions.find((value) => value.edition === 'public')!.routes.length
+	};
+}
+
+/** Install a complete product after its application, both editions and descriptor have succeeded. */
+export function promoteRuntimeProduct(site: string, staged: string) {
+	const target = path.join(site, 'build/.svelte-kit');
+	const transaction = mkdtempSync(path.join(site, 'build/.runtime-promotion-'));
+	const previous = path.join(transaction, 'previous');
+	let moved = false,
+		preserve = false;
+	try {
+		if (existsSync(target)) {
+			renameSync(target, previous);
+			moved = true;
+		}
+		try {
+			renameSync(staged, target);
+		} catch (error) {
+			if (moved)
+				try {
+					renameSync(previous, target);
+				} catch (rollback) {
+					preserve = true;
+					throw new AggregateError(
+						[error, rollback],
+						'Previous runtime product preserved for recovery'
+					);
+				}
+			throw error;
+		}
+	} finally {
+		if (!preserve) rmSync(transaction, { recursive: true, force: true });
+	}
+}

package/site/tooling/lib/search-cache.js

@@ -0,0 +1,165 @@
+import { createHash } from 'node:crypto';
+import {
+	lstatSync,
+	mkdirSync,
+	mkdtempSync,
+	readFileSync,
+	readdirSync,
+	realpathSync,
+	renameSync,
+	rmSync,
+	writeFileSync
+} from 'node:fs';
+import path from 'node:path';
+
+/** @param {string | Uint8Array} bytes */
+const digest = (bytes) => createHash('sha256').update(bytes).digest('hex');
+
+/** The exact HTML/custom records, their submission order and Pagefind version
+ * identify the complete index. Neither checkout paths nor filesystem timestamps
+ * participate. Edition is explicit even when two tiny fixtures happen to match.
+ * @param {{html: import('pagefind').HTMLFile[]; records: import('pagefind').CustomRecord[]; pagefindVersion: string; edition: string}} input
+ */
+export function searchInputKey(input) {
+	return digest(JSON.stringify(['pagefind-inputs-v1', input]));
+}
+
+/** @param {string} file */
+function safePath(file) {
+	return (
+		file.length < 1024 &&
+		/^[\w.-]+(?:\/[\w.-]+)*$/.test(file) &&
+		file.split('/').every((segment) => segment !== '.' && segment !== '..')
+	);
+}
+
+/** @param {string} root */
+function filesIn(root) {
+	/** @type {string[]} */
+	const files = [];
+	/** @param {string} directory */
+	function visit(directory) {
+		for (const entry of readdirSync(path.join(root, directory), { withFileTypes: true })) {
+			const relative = directory ? `${directory}/${entry.name}` : entry.name;
+			if (!safePath(relative)) throw new Error('Invalid Pagefind output path');
+			if (entry.isDirectory()) visit(relative);
+			else if (entry.isFile()) files.push(relative);
+			else throw new Error('Pagefind output must contain regular files');
+		}
+	}
+	visit('');
+	return files.sort();
+}
+
+/** Copy a fully validated generation into a clean directory. Validate before
+ * replacing any output so a corrupt/missing cache cannot leave a partial index.
+ * @param {string} cache @param {string} output @param {string} key @param {string} edition
+ */
+export function restoreSearchCache(cache, output, key, edition) {
+	/** @type {string | undefined} */
+	let temporary;
+	try {
+		const root = realpathSync(cache);
+		const manifestPath = path.join(root, 'manifest.json');
+		if (!lstatSync(manifestPath).isFile() || realpathSync(manifestPath) !== manifestPath)
+			return false;
+		const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+		if (
+			manifest.version !== 1 ||
+			manifest.key !== key ||
+			manifest.edition !== edition ||
+			!Array.isArray(manifest.files) ||
+			manifest.filesSha256 !== digest(JSON.stringify(manifest.files)) ||
+			!manifest.files.length ||
+			manifest.files.length > 100000
+		)
+			return false;
+		/** @type {Map<string, Buffer>} */
+		const verified = new Map();
+		let total = 0;
+		for (const file of manifest.files) {
+			if (
+				typeof file.path !== 'string' ||
+				!safePath(file.path) ||
+				verified.has(file.path) ||
+				!Number.isSafeInteger(file.bytes) ||
+				file.bytes < 0 ||
+				!/^[a-f0-9]{64}$/.test(file.sha256)
+			)
+				return false;
+			total += file.bytes;
+			if (total > 512 * 1024 * 1024) return false;
+			const source = path.join(root, 'files', file.path);
+			const stat = lstatSync(source);
+			if (!stat.isFile() || stat.size !== file.bytes || realpathSync(source) !== source)
+				return false;
+			const bytes = readFileSync(source);
+			if (digest(bytes) !== file.sha256) return false;
+			verified.set(file.path, bytes);
+		}
+		if (!verified.has('pagefind.js') || !verified.has('pagefind-entry.json')) return false;
+		mkdirSync(path.dirname(output), { recursive: true });
+		temporary = mkdtempSync(`${output}.tmp-`);
+		for (const [file, bytes] of verified) {
+			mkdirSync(path.dirname(path.join(temporary, file)), { recursive: true });
+			writeFileSync(path.join(temporary, file), bytes);
+		}
+		rmSync(output, { recursive: true, force: true });
+		renameSync(temporary, output);
+		temporary = undefined;
+		return true;
+	} catch {
+		return false;
+	} finally {
+		if (temporary) rmSync(temporary, { recursive: true, force: true });
+	}
+}
+
+/** Publish a successful complete index, then its manifest. Returns portable
+ * filenames for encrypted cache transport, including the validating manifest.
+ * @param {string} cacheRoot @param {string} output @param {string} key @param {string} edition
+ */
+export function saveSearchCache(cacheRoot, output, key, edition) {
+	const relative = `search/${edition}/${key}`;
+	const cache = path.join(cacheRoot, relative);
+	const files = filesIn(output);
+	if (!files.includes('pagefind.js') || !files.includes('pagefind-entry.json'))
+		throw new Error('Incomplete Pagefind output');
+	mkdirSync(path.dirname(cache), { recursive: true });
+	const temporary = mkdtempSync(`${cache}.tmp-`);
+	try {
+		const manifest = {
+			version: 1,
+			key,
+			edition,
+			files: files.map((file) => {
+				const bytes = readFileSync(path.join(output, file));
+				mkdirSync(path.dirname(path.join(temporary, 'files', file)), { recursive: true });
+				writeFileSync(path.join(temporary, 'files', file), bytes);
+				return { path: file, bytes: bytes.length, sha256: digest(bytes) };
+			})
+		};
+		writeFileSync(
+			path.join(temporary, 'manifest.json'),
+			JSON.stringify({ ...manifest, filesSha256: digest(JSON.stringify(manifest.files)) })
+		);
+		rmSync(cache, { recursive: true, force: true });
+		renameSync(temporary, cache);
+		return [`${relative}/manifest.json`, ...files.map((file) => `${relative}/files/${file}`)];
+	} finally {
+		rmSync(temporary, { recursive: true, force: true });
+	}
+}
+
+/** @param {string} cacheRoot @param {string} edition @param {string[]} files */
+export function selectSearchCache(cacheRoot, edition, files) {
+	mkdirSync(cacheRoot, { recursive: true });
+	const target = path.join(cacheRoot, `search-current-${edition}.json`);
+	const temporary = `${target}.tmp-${process.pid}`;
+	try {
+		writeFileSync(temporary, JSON.stringify(files));
+		renameSync(temporary, target);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}

package/site/tooling/lib/search-inputs.js

@@ -0,0 +1,129 @@
+/** Lightweight equivalents of the searchable content in the document routes.
+ * The application shell, controls, backlinks and ignored metadata are not search
+ * content. Keep HTML rather than custom records so Pagefind retains heading
+ * anchors, HTML tokenization and excerpt semantics.
+ */
+
+/** @param {string} value */
+export function escapeSearchHtml(value) {
+	return value
+		.replaceAll('&', '&')
+		.replaceAll('<', '&lt;')
+		.replaceAll('>', '&gt;')
+		.replaceAll('"', '&quot;')
+		.replaceAll("'", '&#39;');
+}
+
+/** @param {string} slug */
+function displayRoute(slug) {
+	return slug === 'index' ? '' : slug.endsWith('/index') ? slug.slice(0, -6) : slug;
+}
+
+/** @param {string} title @param {string} body */
+function document(title, body) {
+	return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${escapeSearchHtml(title)}</title></head><body><article data-pagefind-body>${body}</article></body></html>`;
+}
+
+/** @param {string} course */
+function courseFilter(course) {
+	return `<span data-pagefind-ignore data-pagefind-filter="course">${escapeSearchHtml(course)}</span>`;
+}
+
+/** Match the article in [...slug]/+page.svelte, including its leading-H1 fallback.
+ * @param {import('../../src/lib/types').PageDoc} page
+ */
+export function noteSearchInput(page) {
+	if (page.locked) return;
+	const route = displayRoute(page.slug);
+	const heading = page.html.match(/^\s*<h1\b[^>]*>[\s\S]*?<\/h1>/i)?.[0];
+	const metadata = route
+		? `<div data-pagefind-ignore>${courseFilter(route.split('/')[0])}${page.tags.map((tag) => `<span data-pagefind-filter="tag">${escapeSearchHtml(tag)}</span>`).join('')}</div><span data-pagefind-meta="title">${escapeSearchHtml(page.title)}</span>`
+		: '';
+	return {
+		url: `/${route}`,
+		content: document(
+			page.title,
+			`${metadata}${heading ? page.html : `<h1>${escapeSearchHtml(page.title)}</h1>${page.html}`}`
+		)
+	};
+}
+
+/** @param {import('../../src/lib/types').ContentManifest} manifest
+ * @param {(slug: string) => import('../../src/lib/types').PageDoc} loadPage
+ * @returns {import('pagefind').HTMLFile[]}
+ */
+export function searchHtmlInputs(manifest, loadPage) {
+	/** @type {import('pagefind').HTMLFile[]} */
+	const inputs = [];
+	const routes = new Set();
+	for (const slug of Object.keys(manifest.pages)) {
+		const route = displayRoute(slug);
+		// The route loader prefers an exact page over a colliding folder index.
+		if (routes.has(route) || (slug.endsWith('/index') && manifest.pages[route])) continue;
+		routes.add(route);
+		const input = noteSearchInput(loadPage(slug));
+		if (input) inputs.push(input);
+	}
+	/** @type {Map<string, {name: string; count: number}>} */
+	const folders = new Map();
+	/** @param {import('../../src/lib/types').TreeNode} node @returns {number} */
+	function visit(node) {
+		const count = node.pages.length + node.children.reduce((sum, child) => sum + visit(child), 0);
+		folders.set(node.slug, { name: node.name, count });
+		return count;
+	}
+	visit(manifest.tree);
+	for (const folder of ['', ...manifest.folders]) {
+		if (routes.has(folder)) continue;
+		const listing = folders.get(folder);
+		if (!listing) continue;
+		routes.add(folder);
+		const name = folder ? folder.split('/').at(-1) || folder : listing.name;
+		inputs.push({
+			url: `/${folder}`,
+			content: document(
+				name,
+				`${folder ? courseFilter(folder.split('/')[0]) : ''}<h1>${escapeSearchHtml(name)}</h1><p>${listing.count} ${listing.count === 1 ? 'item' : 'items'} under this folder.</p>`
+			)
+		});
+	}
+	const collator = new Intl.Collator(undefined, { numeric: true, sensitivity: 'base' });
+	const tags = Object.keys(manifest.tags).sort((a, b) => collator.compare(a, b));
+	inputs.push({
+		url: '/tags',
+		content: document(
+			'Tag Index',
+			`<h1>Tag Index</h1><p>Found ${tags.length} total tags.</p><ul>${tags.map((tag) => `<li><a href="/tags/${escapeSearchHtml(tag)}">${escapeSearchHtml(tag)} ${manifest.tags[tag].length}</a></li>`).join('')}</ul>`
+		)
+	});
+	for (const tag of tags) {
+		const pages = manifest.tags[tag]
+			.map((slug) => manifest.pages[slug])
+			.filter(Boolean)
+			.sort(
+				(a, b) =>
+					Date.parse(b.dates.modified) - Date.parse(a.dates.modified) ||
+					collator.compare(a.title, b.title)
+			);
+		const title = `Tag: ${tag}`;
+		inputs.push({
+			url: `/tags/${tag}`,
+			content: document(
+				title,
+				`<h1>${escapeSearchHtml(title)}</h1><p>${pages.length} ${pages.length === 1 ? 'item' : 'items'} with this tag.</p><ul>${pages
+					.map((page) => {
+						const date = page.dates.modified
+							? new Date(page.dates.modified).toLocaleDateString('en-US', {
+									year: 'numeric',
+									month: 'short',
+									day: 'numeric'
+								})
+							: '';
+						return `<li><a href="/${escapeSearchHtml(displayRoute(page.slug))}">${escapeSearchHtml(page.title)} ${escapeSearchHtml(date)}${page.description ? ` ${escapeSearchHtml(page.description)}` : ''}</a></li>`;
+					})
+					.join('')}</ul>`
+			)
+		});
+	}
+	return inputs.sort((a, b) => (a.url || '').localeCompare(b.url || '', 'en'));
+}