@tenjot/fumi 0.1.0

package/LICENSE

@@ -0,0 +1,48 @@
+MIT License
+
+Copyright (c) 2025 tenjo-t
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+Portions of this software are derived from VitePress
+(https://github.com/vuejs/vitepress).
+
+MIT License
+
+Copyright (c) 2019-present, Yuxi (Evan You) and VitePress contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/app-DvBaD5aw.mjs

@@ -0,0 +1,19 @@
+import { n as createRouter, t as RouterSymbol } from "./router-DZgDu6-U.mjs";
+import { n as initData, t as DataSymbol } from "./data-CRbUH9pt.mjs";
+import { createSSRApp } from "vue";
+import App from "@app";
+//#region src/client/app.ts
+/** 初期ルートを元にVue appを作成する */
+function createApp(initialRoute) {
+	const app = createSSRApp(App);
+	const router = createRouter(initialRoute);
+	app.provide(RouterSymbol, router);
+	const data = initData(router.route);
+	app.provide(DataSymbol, data);
+	return {
+		app,
+		router
+	};
+}
+//#endregion
+export { createApp as t };

package/dist/client.d.mts

@@ -0,0 +1,8 @@
+import { a as useData, n as useRouter, t as useRoute } from "./router-BEb_gb9D.mjs";
+import * as _$vue from "vue";
+
+//#region src/client/content.vue.d.ts
+declare const __VLS_export: _$vue.DefineComponent<{}, {}, {}, {}, {}, _$vue.ComponentOptionsMixin, _$vue.ComponentOptionsMixin, {}, string, _$vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, _$vue.ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default as Content, useData, useRoute, useRouter };

package/dist/client.mjs

@@ -0,0 +1,15 @@
+import { a as useRoute, o as useRouter } from "./router-DZgDu6-U.mjs";
+import { r as useData } from "./data-CRbUH9pt.mjs";
+import { createBlock, createCommentVNode, defineComponent, openBlock, resolveDynamicComponent, unref } from "vue";
+//#region src/client/content.vue
+const _sfc_main = /* @__PURE__ */ defineComponent({
+	__name: "content",
+	setup(__props) {
+		const route = useRoute();
+		return (_ctx, _cache) => {
+			return unref(route).component ? (openBlock(), createBlock(resolveDynamicComponent(unref(route).component), { key: 0 })) : createCommentVNode("v-if", true);
+		};
+	}
+});
+//#endregion
+export { _sfc_main as Content, useData, useRoute, useRouter };

package/dist/config-BqdJHMUf.mjs

@@ -0,0 +1,20 @@
+//#region src/client/config.ts
+function resolveTitle(config) {
+	return config.title ? config.titleTemplate?.replaceAll(":title", config.title) ?? config.title : config.titleTemplate;
+}
+function configToHeadConfig(config) {
+	const head = config.head ?? [];
+	const title = resolveTitle(config);
+	if (title) head.push([
+		"title",
+		{},
+		title
+	]);
+	if (config.description) head.push(["meta", {
+		name: "description",
+		content: config.description
+	}]);
+	return head;
+}
+//#endregion
+export { resolveTitle as n, configToHeadConfig as t };

package/dist/data-CRbUH9pt.mjs

@@ -0,0 +1,14 @@
+import { computed, inject } from "vue";
+//#region src/client/data.ts
+const DataSymbol = Symbol();
+function initData(route) {
+	return { page: computed(() => route.data) };
+}
+/** サイトのメタデータ */
+function useData() {
+	const data = inject(DataSymbol);
+	if (!data) throw new Error("fumi data not properly injected in app");
+	return data;
+}
+//#endregion
+export { initData as n, useData as r, DataSymbol as t };

package/dist/index.d.mts

@@ -0,0 +1,14 @@
+import { c as defineConfig, i as SiteData, o as FumiUserConfig, r as PageData, s as HeadConfig } from "./router-BEb_gb9D.mjs";
+
+//#region src/content-loader.d.ts
+type DataLoader<T> = {
+  watch?: never;
+  load(): Promise<T>;
+} | {
+  watch: string[];
+  load(watchFiles: string[], loadMarkdown: (path: string) => Promise<PageData>): Promise<T>;
+};
+type LoadedData<T extends DataLoader<unknown>> = T extends DataLoader<infer U> ? U : never;
+declare function defineLoader<T>(dataLoader: DataLoader<T>): DataLoader<T>;
+//#endregion
+export { type DataLoader, type FumiUserConfig, type HeadConfig, type LoadedData, type PageData, type SiteData, defineConfig, defineLoader };

package/dist/index.mjs

@@ -0,0 +1,437 @@
+import { i as pathToPageComponentPath } from "./router-DZgDu6-U.mjs";
+import { t as configToHeadConfig } from "./config-BqdJHMUf.mjs";
+import path, { dirname, extname, relative, resolve } from "path";
+import vue from "@vitejs/plugin-vue";
+import { createFilter, defineConfig as defineConfig$1, loadConfigFromFile, normalizePath } from "vite";
+import { mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { toHtml } from "hast-util-to-html";
+import { glob } from "tinyglobby";
+import pm from "picomatch";
+import { unified } from "unified";
+import { select } from "hast-util-select";
+import { toText } from "hast-util-to-text";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import rehypeStringify from "rehype-stringify";
+import matter from "gray-matter";
+//#region src/utils.ts
+function headConfigToHast(head) {
+	return head.map(([tagName, a, c]) => {
+		return {
+			type: "element",
+			tagName,
+			properties: a,
+			children: c == null ? [] : [{
+				type: "text",
+				value: c
+			}]
+		};
+	});
+}
+function headConfigStringify(head) {
+	return toHtml(headConfigToHast(head));
+}
+//#endregion
+//#region src/plugins/build.ts
+const EXCLUDE_DIRS = new Set([
+	".fumi",
+	".git",
+	"dist",
+	"node_modules",
+	"packages",
+	"public"
+]);
+function discoverPages(root) {
+	const pages = [];
+	function walk(dir) {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory()) {
+			if (!EXCLUDE_DIRS.has(entry.name)) walk(resolve(dir, entry.name));
+		} else if (entry.isFile()) {
+			const ext = extname(entry.name);
+			const isUpperCase = entry.name[0] === entry.name[0].toUpperCase() && entry.name[0] !== entry.name[0].toLowerCase();
+			if ((ext === ".md" || ext === ".vue") && !isUpperCase) {
+				const filePath = resolve(dir, entry.name);
+				let url = "/" + relative(root, filePath).replace(/\\/g, "/").replace(/\.(md|vue)$/, "");
+				if (url.endsWith("/index")) url = url.slice(0, -6) || "/";
+				pages.push({
+					url,
+					filePath
+				});
+			}
+		}
+	}
+	walk(root);
+	return pages;
+}
+function urlToInputKey(url) {
+	return url === "/" ? "__app/index" : `__app${url}`;
+}
+function urlToOutPath(outDir, url) {
+	if (url === "/") return resolve(outDir, "index.html");
+	return resolve(outDir, url.slice(1) + ".html");
+}
+function build(config) {
+	let outDir;
+	return {
+		name: "fumi:build",
+		apply: "build",
+		configEnvironment(name, config) {
+			const cwd = process.cwd();
+			const pages = discoverPages(cwd);
+			if (name === "client") return { build: { rolldownOptions: {
+				preserveEntrySignatures: "strict",
+				input: {
+					index: resolve(cwd, ".fumi/index.html"),
+					...Object.fromEntries(pages.map(({ url }) => [urlToInputKey(url), `/${urlToInputKey(url)}.js`]))
+				},
+				output: {
+					entryFileNames: (chunk) => {
+						if (chunk.name.startsWith("__app/")) return chunk.name + ".js";
+						return "assets/[name]-[hash].js";
+					},
+					chunkFileNames: "assets/[name]-[hash].js",
+					assetFileNames: "assets/[name]-[hash].[ext]"
+				}
+			} } };
+			if (name === "ssr") return { build: {
+				outDir: `${config.build?.outDir ?? "dist"}/.fumi`,
+				emptyOutDir: false,
+				rolldownOptions: {
+					input: {
+						ssr: "@tenjot/fumi/ssr",
+						...Object.fromEntries(pages.map(({ url }) => [urlToInputKey(url), `/${urlToInputKey(url)}.js`]))
+					},
+					output: {
+						entryFileNames: (chunk) => {
+							if (chunk.name.startsWith("__app/")) return chunk.name + ".js";
+							return "[name].js";
+						},
+						chunkFileNames: "assets/[name]-[hash].js",
+						assetFileNames: "assets/[name]-[hash][ext]"
+					}
+				}
+			} };
+		},
+		configResolved(config) {
+			outDir = config.build.outDir;
+		},
+		async closeBundle() {
+			if (this.environment?.name !== "ssr") return;
+			const cwd = process.cwd();
+			const pages = discoverPages(cwd);
+			const ssrOutDir = outDir;
+			const clientOutDir = resolve(ssrOutDir, "..");
+			const template = await readFile(resolve(ssrOutDir, "index.html"), "utf-8");
+			const { render } = await import(
+				/* @vite-ignore */
+				resolve(ssrOutDir, "ssr.js") + `?t=${Date.now()}`
+);
+			console.log("\nRendering pages...");
+			for (const { url } of pages) {
+				const { default: component, __pageData: data } = await import(
+					/* @vite-ignore */
+					resolve(ssrOutDir, `.${pathToPageComponentPath(url)}`)
+);
+				const appHtml = await render(url, component, data);
+				if (appHtml === null) {
+					console.log(`  skip ${url}`);
+					continue;
+				}
+				const appHead = headConfigStringify(configToHeadConfig(data));
+				const html = template.replace("<!--app-html-->", appHtml).replace("<!--app-head-->", appHead);
+				const outPath = urlToOutPath(clientOutDir, url);
+				mkdirSync(dirname(outPath), { recursive: true });
+				writeFileSync(outPath, html);
+				console.log(`  ${url} → ${relative(cwd, outPath)}`);
+			}
+			rmSync(ssrOutDir, { recursive: true });
+		}
+	};
+}
+//#endregion
+//#region src/plugins/markdown.ts
+const extractTitle = function() {
+	return (tree, file) => {
+		const node = select("h1", tree);
+		if (node) file.data.title = toText(node);
+	};
+};
+function createProcessor(options = {}) {
+	let remark = unified().use(remarkParse);
+	if (options.remarkPlugins?.length) remark = remark.use(options.remarkPlugins);
+	let rehype = remark.use(remarkRehype, { allowDangerousHtml: true });
+	if (options.rehypePlugins?.length) rehype = rehype.use(options.rehypePlugins);
+	rehype.use(extractTitle);
+	return rehype.use(rehypeStringify, { allowDangerousHtml: true });
+}
+function markdown(options, config) {
+	const processor = createProcessor(options);
+	let root;
+	return {
+		name: "fumi:markdown",
+		configResolved(config) {
+			root = config.root;
+		},
+		transform: {
+			filter: { id: /\.md$/ },
+			async handler(code, id) {
+				const { content, data: frontmatter } = matter(code);
+				const file = await processor.process(content);
+				const html = JSON.stringify(`<div class="fumi-markdown-content">${file.toString()}</div>`);
+				const pageConfig = { ...frontmatter };
+				if (pageConfig.title == null && file.data.title != null) pageConfig.title = file.data.title;
+				const resolvedConfig = resolveFumiConfig(config, pageConfig);
+				const data = {
+					path: id.replace("index.md", "index.html").replace(".md", ".html").replace(root, ""),
+					isNotFound: false,
+					frontmatter,
+					...resolvedConfig
+				};
+				return `import { createStaticVNode } from "vue";
+export default { render: () => createStaticVNode(${html}, 1) };
+export const __pageData = JSON.parse(${JSON.stringify(JSON.stringify(data))})`;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/plugins/data-loader.ts
+function dataLoader(markdownOptions, config) {
+	const depToLoaderModuleIdsMap = /* @__PURE__ */ new Map();
+	const idToLoaderModulesMap = /* @__PURE__ */ new Map();
+	return {
+		name: "fumi:data-loader",
+		sharedDuringBuild: true,
+		load: {
+			filter: { id: /\.data\.[tj]s$/ },
+			async handler(id) {
+				const root = this.environment.config.root;
+				const isBuild = this.environment.config.command === "build";
+				let loader;
+				const existing = idToLoaderModulesMap.get(id);
+				if (existing) loader = existing;
+				else {
+					const res = await loadConfigFromFile({}, id);
+					if (!res?.config) return null;
+					if (!isBuild) for (const dep of res.dependencies) {
+						const depPath = normalizePath(path.resolve(dep));
+						let set = depToLoaderModuleIdsMap.get(depPath);
+						if (!set) depToLoaderModuleIdsMap.set(depPath, set = /* @__PURE__ */ new Set());
+						set.add(id);
+					}
+					loader = res.config;
+					if (!isBuild) idToLoaderModulesMap.set(id, loader);
+				}
+				let data;
+				if (loader.watch) {
+					const watchFiles = (await glob(loader.watch, {
+						absolute: true,
+						expandDirectories: true,
+						ignore: [
+							"**/node_modules/**",
+							"**/dist/**",
+							"**/.fumi/**"
+						]
+					})).sort();
+					const processor = createProcessor(markdownOptions);
+					data = await loader.load(watchFiles, async (path) => {
+						const { content, data: frontmatter } = matter(await readFile(path, "utf-8"));
+						const file = await processor.process(content);
+						const pageConfig = { ...frontmatter };
+						if (pageConfig.title == null && file.data.title != null) pageConfig.title = file.data.title;
+						const resolvedConfig = resolveFumiConfig(config, pageConfig);
+						return {
+							path: path.replace("index.md", "index.html").replace(".md", ".html").replace(root, ""),
+							isNotFound: false,
+							...resolvedConfig
+						};
+					});
+				} else data = await loader.load();
+				if (!isBuild) idToLoaderModulesMap.set(id, loader);
+				return `export const data = JSON.parse(${JSON.stringify(JSON.stringify(data))})`;
+			}
+		},
+		hotUpdate({ file, modules: existingMods }) {
+			if (this.environment.name !== "client") return;
+			const modules = [];
+			const normalizedFile = normalizePath(file);
+			if (depToLoaderModuleIdsMap.has(normalizedFile)) for (const id of depToLoaderModuleIdsMap.get(normalizedFile) ?? []) {
+				idToLoaderModulesMap.delete(id);
+				const mod = this.environment.moduleGraph.getModuleById(id);
+				if (mod) modules.push(mod);
+			}
+			for (const [id, loader] of idToLoaderModulesMap.entries()) if (loader.watch?.length && pm(loader.watch)(normalizedFile)) {
+				const mod = this.environment.moduleGraph.getModuleById(id);
+				if (mod) modules.push(mod);
+			}
+			return modules.length ? [...existingMods, ...modules] : void 0;
+		}
+	};
+}
+//#endregion
+//#region src/plugins/dev-server.ts
+const isCss = createFilter([/\.css(?:$|\?)/], [/[?&](?:worker|sharedworker|raw|url)\b/, /[?&]commonjs-proxy/]);
+function devServer(config) {
+	return {
+		name: "fumi:dev-server",
+		apply: "serve",
+		configureServer(server) {
+			return dev(server, config);
+		}
+	};
+}
+async function dev(server, config) {
+	const root = server.config.root;
+	const fumiRoot = resolve(root, ".fumi");
+	const ssrEnv = server.environments.ssr;
+	const clientEnv = server.environments.client;
+	return () => {
+		server.middlewares.use(async (req, res, next) => {
+			try {
+				const url = req.originalUrl ?? req.url ?? "/";
+				if (url.endsWith(".map")) return next();
+				if (url === "/favicon.ico") return next();
+				if (url.startsWith("/__app/")) return next();
+				let html = readFileSync(resolve(fumiRoot, "index.html"), "utf-8");
+				html = await server.transformIndexHtml(url, html);
+				const { render } = await ssrEnv.runner.import("@tenjot/fumi/ssr");
+				const pageComponentPath = pathToPageComponentPath(url);
+				const { default: component, __pageData } = await ssrEnv.runner.import(pageComponentPath).catch(async (e) => {
+					if (e.code !== "ERR_LOAD_URL") throw e;
+					const page = await ssrEnv.runner.import("/__app/404.js").catch(() => void 0);
+					return {
+						default: page?.default,
+						__pageData: {
+							...page?.__pageData,
+							path: url,
+							isNotFound: true
+						}
+					};
+				});
+				const appHtml = await render(url, component, __pageData);
+				if (appHtml === null) return next();
+				const pageMod = await clientEnv.moduleGraph.getModuleByUrl("/.fumi/App.vue");
+				const styleTag = pageMod ? renderCss(pageMod) : [];
+				const headTag = configToHeadConfig(__pageData);
+				const appHead = headConfigStringify([...styleTag, ...headTag]);
+				html = html.replace("<!--app-html-->", appHtml);
+				html = html.replace("<!--app-head-->", appHead);
+				res.writeHead(component != null ? 200 : 404, { "Content-Type": "text/html" });
+				res.end(html);
+			} catch (e) {
+				server.ssrFixStacktrace(e);
+				console.error(e);
+				next(e);
+			}
+		});
+	};
+}
+const viteCssRe = /\bconst __vite__css\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`[\s\S]*?`)/;
+const viteIdRe = /\bconst __vite__id\s*=\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`[\s\S]*?`)/;
+function renderCss(entry, visited = /* @__PURE__ */ new Set()) {
+	const result = [];
+	for (const mod of entry.importedModules) {
+		if (mod.id === null || visited.has(mod.id)) continue;
+		visited.add(mod.id);
+		if (isCss(mod.url)) {
+			const style = renderCssMod(mod);
+			if (!style) continue;
+			result.push(style);
+		} else result.push(...renderCss(mod, visited));
+	}
+	return result.filter(Boolean);
+}
+function renderCssMod(mod) {
+	const code = mod.transformResult?.code;
+	if (!code) return null;
+	const css = viteCssRe.exec(code);
+	if (!css) return null;
+	const id = viteIdRe.exec(code);
+	if (!id) return null;
+	return [
+		"style",
+		{ "data-vite-dev-id": JSON.parse(id[1]) },
+		JSON.parse(css[1])
+	];
+}
+//#endregion
+//#region src/plugins/page.ts
+function page(config) {
+	let root;
+	return [{
+		name: "fumi:page",
+		configResolved(config) {
+			root = config.root;
+		},
+		resolveId: {
+			filter: { id: /^\/__app\/.*\.js(?:\.(?:md|vue))?$/ },
+			handler(source) {
+				const path = source.replace(/\.(?:md|vue)$/, "").replace(/^\/__app\//, "").replace(/\.js$/, "");
+				const vuePath = resolve(root, `${path}.vue`);
+				if (existsFile(vuePath)) return vuePath;
+				const mdPath = resolve(root, `${path}.md`);
+				if (existsFile(mdPath)) return mdPath;
+				return null;
+			}
+		}
+	}];
+}
+function existsFile(path) {
+	try {
+		return statSync(path).isFile();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/config.ts
+/**
+* Viteの設定。
+* Fumiのために幾つかの設定が追加・上書きされる。
+*/
+function defineConfig(userConfig = {}) {
+	const { vite: viteUserConfig = {}, vue: vueOptions, markdown: markdownOptions = {}, ...fumiConfig } = userConfig;
+	const cwd = process.cwd();
+	return defineConfig$1({
+		...viteUserConfig,
+		plugins: [
+			vue(vueOptions),
+			devServer(fumiConfig),
+			build(fumiConfig),
+			page(fumiConfig),
+			markdown(markdownOptions, fumiConfig),
+			dataLoader(markdownOptions, fumiConfig),
+			...viteUserConfig.plugins ?? []
+		],
+		resolve: {
+			...viteUserConfig.resolve,
+			alias: {
+				...viteUserConfig.resolve?.alias,
+				"@app": resolve(cwd, ".fumi/App.vue")
+			}
+		}
+	});
+}
+function resolveFumiConfig(global, page) {
+	const title = page.title ?? global.title;
+	let titleTemplate = page.titleTemplate === false ? void 0 : page.titleTemplate ?? (global.titleTemplate === false ? void 0 : global.titleTemplate);
+	if (title == null) {
+		if (titleTemplate?.includes(":title")) titleTemplate = void 0;
+	} else if (!titleTemplate?.includes(":title")) titleTemplate = void 0;
+	const head = [...global.head ?? [], ...page.head ?? []];
+	return {
+		title,
+		titleTemplate,
+		description: page.description ?? global.description,
+		head: head.length ? head : void 0,
+		lang: page.lang ?? global.lang
+	};
+}
+//#endregion
+//#region src/content-loader.ts
+function defineLoader(dataLoader) {
+	return dataLoader;
+}
+//#endregion
+export { defineConfig, defineLoader };

package/dist/main.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/main.mjs

@@ -0,0 +1,67 @@
+import { r as loadPage } from "./router-DZgDu6-U.mjs";
+import { n as resolveTitle } from "./config-BqdJHMUf.mjs";
+import { t as createApp } from "./app-DvBaD5aw.mjs";
+import { markRaw, watchEffect } from "vue";
+//#region src/client/head.ts
+function useHead(route) {
+	let isFirstUpdate = true;
+	let elements = [];
+	function updateHead(tags) {
+		if (isFirstUpdate) {
+			isFirstUpdate = false;
+			const children = [...document.head.children];
+			for (const tag of tags) {
+				const newEl = createHeadElement(tag);
+				const el = children.find((el) => el.isEqualNode(newEl));
+				if (el != null) elements.push(el);
+			}
+			return;
+		}
+		const newElements = tags.map(createHeadElement);
+		for (const [oldIndex, oldEl] of elements.entries()) {
+			const matched = newElements.findIndex((el) => el?.isEqualNode(oldEl ?? null));
+			if (matched !== -1) delete newElements[matched];
+			else {
+				oldEl?.remove();
+				delete elements[oldIndex];
+			}
+		}
+		for (const el of newElements) if (el) document.head.appendChild(el);
+		elements = [...elements, ...newElements].filter(Boolean);
+	}
+	watchEffect(() => {
+		const config = route.data;
+		const title = resolveTitle(config);
+		if (title !== document.title && title) document.title = title;
+		const metaDescElm = document.querySelector("meta[name=description]");
+		if (metaDescElm) {
+			if (!config.description) metaDescElm.remove();
+			else if (metaDescElm.getAttribute("content") !== config.description) metaDescElm.setAttribute("content", config.description);
+		} else if (config.description) createHeadElement(["meta", {
+			name: "description",
+			content: config.description
+		}]);
+		updateHead(config.head ?? []);
+	});
+}
+function createHeadElement([tag, attrs, innerHTML]) {
+	const el = document.createElement(tag);
+	for (const key in attrs) el.setAttribute(key, attrs[key]);
+	if (innerHTML) el.innerHTML = innerHTML;
+	if (tag === "script" && attrs.async == null) el.async = false;
+	return el;
+}
+//#endregion
+//#region src/client/main.ts
+const path = location.pathname;
+loadPage(path).then(({ default: cmp, __pageData }) => {
+	const { app, router } = createApp({
+		path,
+		component: cmp ? markRaw(cmp) : null,
+		data: __pageData
+	});
+	useHead(router.route);
+	app.mount("#app");
+});
+//#endregion
+export {};

package/dist/router-BEb_gb9D.d.mts

@@ -0,0 +1,85 @@
+import { Options } from "@vitejs/plugin-vue";
+import { UserConfig } from "vite";
+import { Component, Ref } from "vue";
+import { PluggableList } from "unified";
+
+//#region src/plugins/markdown.d.ts
+interface MarkdownOptions {
+  /** remark-parse の後に適用する remark プラグイン */
+  remarkPlugins?: PluggableList;
+  /** remark-rehype の後に適用する rehype プラグイン */
+  rehypePlugins?: PluggableList;
+}
+//#endregion
+//#region src/config.d.ts
+type HeadConfig = [tag: string, attr: Record<string, string>] | [tag: string, attr: Record<string, string>, content: string];
+interface FumiConfig {
+  /** サイトタイトル。Frontmatterで上書き可能。 */
+  title?: string;
+  /**
+   * サイトタイトルテンプレート。
+   * `:title`シンボルがFrontmatterまたは`h1`から推測されたタイトルが挿入される。
+   * `false`を設定するとテンプレートを無効にします。
+   */
+  titleTemplate?: string | false;
+  /** サイトの説明。Frontmatterで上書き可能 */
+  description?: string;
+  /** `<head>`に追加する要素。 */
+  head?: HeadConfig[];
+  /** サイトの言語属性 */
+  lang?: string;
+}
+interface ResolvedFumiConfig extends FumiConfig {
+  titleTemplate?: string;
+}
+interface FumiUserConfig extends FumiConfig {
+  vite?: UserConfig;
+  vue?: Options;
+  markdown?: MarkdownOptions;
+}
+/**
+ * Viteの設定。
+ * Fumiのために幾つかの設定が追加・上書きされる。
+ */
+declare function defineConfig$1(userConfig?: FumiUserConfig): UserConfig;
+//#endregion
+//#region src/client/data.d.ts
+/** Page-level metadata */
+interface PageData extends ResolvedFumiConfig {
+  /** 現在のページのパス (`/`は`/index.html`となる) */
+  path: string;
+  /** もしページが見つからない場合trueになる */
+  isNotFound: boolean;
+  /** Markdown frontmatter */
+  frontmatter?: Record<string, unknown>;
+}
+/** Fumi metadata */
+interface SiteData {
+  /** Page-level metadata */
+  page: Ref<PageData>;
+}
+/** サイトのメタデータ */
+declare function useData(): SiteData;
+//#endregion
+//#region src/client/router.d.ts
+interface Route {
+  /** 現在のページのパス (`new URL(location.href).pathname`と同じ) */
+  path: string;
+  /** 現在のページのコンポーネント */
+  component: Component | null;
+  /** 現在のページのメタデータ */
+  data: PageData;
+}
+interface Router {
+  /** 現在のルート情報 */
+  route: Route;
+}
+/**
+ * ルーター
+ * ナビゲーションにはNavigation APIを使用します。
+ */
+declare function useRouter(): Router;
+/** 現在のルート情報 */
+declare function useRoute(): Route;
+//#endregion
+export { useData as a, defineConfig$1 as c, SiteData as i, useRouter as n, FumiUserConfig as o, PageData as r, HeadConfig as s, useRoute as t };

package/dist/router-DZgDu6-U.mjs

@@ -0,0 +1,69 @@
+import { inject, markRaw, reactive } from "vue";
+//#region src/client/router.ts
+const RouterSymbol = Symbol();
+function createRouter(initialRoute) {
+	const route = reactive({
+		path: initialRoute?.path ?? "/",
+		component: initialRoute?.component ? markRaw(initialRoute.component) : null,
+		data: initialRoute?.data ?? {
+			path: "/",
+			isNotFound: true
+		}
+	});
+	if (typeof navigation !== "undefined") navigation.addEventListener("navigate", (e) => {
+		if (!e.canIntercept || e.hashChange || e.downloadRequest !== null) return;
+		const url = new URL(e.destination.url);
+		if (url.origin !== location.origin) return;
+		if (import.meta.env.DEV && url.pathname.startsWith("/__fumi/editor")) return;
+		e.intercept({ async handler() {
+			const page = await loadPage(url.pathname);
+			route.component = page.default ? markRaw(page.default) : null;
+			route.path = url.pathname;
+			route.data = page.__pageData;
+		} });
+	});
+	return { route };
+}
+function pathToPageComponentPath(pathname) {
+	let path = pathname.replace(/\.html$/, "");
+	if (path === "/" || path === "") path = "/index";
+	else if (path.endsWith("/")) path = path.slice(0, -1) + "/index";
+	return `/__app${path}.js`;
+}
+async function loadPage(pathname) {
+	try {
+		return await import(
+			/* @vite-ignore */
+			pathToPageComponentPath(pathname)
+);
+	} catch (e) {
+		if (!(e instanceof TypeError)) throw e;
+		const page = await import(
+			/* @vite-ignore */
+			"/__app/404.js"
+);
+		return {
+			default: page?.default,
+			__pageData: {
+				...page?.__pageData,
+				url: pathname,
+				isNotFound: true
+			}
+		};
+	}
+}
+/**
+* ルーター
+* ナビゲーションにはNavigation APIを使用します。
+*/
+function useRouter() {
+	const router = inject(RouterSymbol);
+	if (!router) throw new Error("useRouter() is called without provider.");
+	return router;
+}
+/** 現在のルート情報 */
+function useRoute() {
+	return useRouter().route;
+}
+//#endregion
+export { useRoute as a, pathToPageComponentPath as i, createRouter as n, useRouter as o, loadPage as r, RouterSymbol as t };

package/dist/ssr.d.mts

@@ -0,0 +1,8 @@
+import { r as PageData } from "./router-BEb_gb9D.mjs";
+import { Component } from "vue";
+
+//#region src/ssr.d.ts
+/** FumiをSSR用にレンダリングする */
+declare function render(url: string, component: Component, data: PageData): Promise<string>;
+//#endregion
+export { render };

package/dist/ssr.mjs

@@ -0,0 +1,14 @@
+import { t as createApp } from "./app-DvBaD5aw.mjs";
+import { renderToString } from "vue/server-renderer";
+//#region src/ssr.ts
+/** FumiをSSR用にレンダリングする */
+async function render(url, component, data) {
+	const { app } = createApp({
+		path: url,
+		component,
+		data
+	});
+	return await renderToString(app);
+}
+//#endregion
+export { render };

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@tenjot/fumi",
+  "version": "0.1.0",
+  "description": "A static site generator for Vue + remark",
+  "license": "MIT",
+  "author": "tenjo-t",
+  "type": "module",
+  "imports": {
+    "#editor/*": "./dist/editor/*"
+  },
+  "exports": {
+    ".": {
+      "default": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    },
+    "./client": {
+      "default": "./dist/client.mjs",
+      "types": "./dist/client.d.mts"
+    },
+    "./main": {
+      "default": "./dist/main.mjs",
+      "types": "./dist/main.d.mts"
+    },
+    "./ssr": {
+      "default": "./dist/ssr.mjs",
+      "types": "./dist/ssr.d.mts"
+    },
+    "./ssr.mjs": {
+      "default": "./dist/ssr.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/node": "^25.4.0",
+    "@vitejs/plugin-vue": "^6.0.5",
+    "gray-matter": "^4.0.3",
+    "hast-util-select": "^6.0.4",
+    "hast-util-to-html": "^9.0.5",
+    "hast-util-to-text": "^4.0.2",
+    "picomatch": "^4.0.4",
+    "rehype-stringify": "^10.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.1",
+    "tinyglobby": "^0.2.15",
+    "unified": "^11.0.5",
+    "vite": "^8.0.14",
+    "vue": "^3.5.34"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.3.0",
+    "@types/hast": "^3.0.4",
+    "@types/picomatch": "^4.0.2",
+    "tailwindcss": "^4.3.0",
+    "tsdown": "^0.21.2",
+    "typescript": "^6.0.3",
+    "unplugin-vue": "^7.1.1",
+    "vue-tsc": "^3.2.5"
+  },
+  "scripts": {
+    "dev": "tsdown -w",
+    "build": "tsdown"
+  }
+}