@void/vue 0.0.0

package/dist/plugin.mjs

@@ -0,0 +1,729 @@
+import vue from "@vitejs/plugin-vue";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { normalizePath } from "vite";
+import { generateComponentManifest, resolveEffectiveLayoutChain, resolveStaticPageDataBuildOptions, scanPages } from "void/pages";
+import { ISLANDS_CLIENT_ENTRY_ID, ISLANDS_RENDERER_ID, computePagesNeedingClientJS, configureIslandCssServer, needsIslandClientBundle, rebuildIslandCssMap, resolveSpecifier, rewriteCssImportForVirtualModule, watchPagesForRescan } from "void/pages-islands-plugin";
+//#region ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
+const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+	if (!input) return input;
+	return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
+}
+const _UNC_REGEX = /^[/\\]{2}/;
+const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+const _ROOT_FOLDER_RE = /^\/([A-Za-z]:)?$/;
+const normalize = function(path) {
+	if (path.length === 0) return ".";
+	path = normalizeWindowsPath(path);
+	const isUNCPath = path.match(_UNC_REGEX);
+	const isPathAbsolute = isAbsolute(path);
+	const trailingSeparator = path[path.length - 1] === "/";
+	path = normalizeString(path, !isPathAbsolute);
+	if (path.length === 0) {
+		if (isPathAbsolute) return "/";
+		return trailingSeparator ? "./" : ".";
+	}
+	if (trailingSeparator) path += "/";
+	if (_DRIVE_LETTER_RE.test(path)) path += "/";
+	if (isUNCPath) {
+		if (!isPathAbsolute) return `//./${path}`;
+		return `//${path}`;
+	}
+	return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+const join = function(...segments) {
+	let path = "";
+	for (const seg of segments) {
+		if (!seg) continue;
+		if (path.length > 0) {
+			const pathTrailing = path[path.length - 1] === "/";
+			const segLeading = seg[0] === "/";
+			if (pathTrailing && segLeading) path += seg.slice(1);
+			else path += pathTrailing || segLeading ? seg : `/${seg}`;
+		} else path += seg;
+	}
+	return normalize(path);
+};
+function cwd() {
+	if (typeof process !== "undefined" && typeof process.cwd === "function") return process.cwd().replace(/\\/g, "/");
+	return "/";
+}
+const resolve = function(...arguments_) {
+	arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+	let resolvedPath = "";
+	let resolvedAbsolute = false;
+	for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+		const path = index >= 0 ? arguments_[index] : cwd();
+		if (!path || path.length === 0) continue;
+		resolvedPath = `${path}/${resolvedPath}`;
+		resolvedAbsolute = isAbsolute(path);
+	}
+	resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+	if (resolvedAbsolute && !isAbsolute(resolvedPath)) return `/${resolvedPath}`;
+	return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path, allowAboveRoot) {
+	let res = "";
+	let lastSegmentLength = 0;
+	let lastSlash = -1;
+	let dots = 0;
+	let char = null;
+	for (let index = 0; index <= path.length; ++index) {
+		if (index < path.length) char = path[index];
+		else if (char === "/") break;
+		else char = "/";
+		if (char === "/") {
+			if (lastSlash === index - 1 || dots === 1);
+			else if (dots === 2) {
+				if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+					if (res.length > 2) {
+						const lastSlashIndex = res.lastIndexOf("/");
+						if (lastSlashIndex === -1) {
+							res = "";
+							lastSegmentLength = 0;
+						} else {
+							res = res.slice(0, lastSlashIndex);
+							lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+						}
+						lastSlash = index;
+						dots = 0;
+						continue;
+					} else if (res.length > 0) {
+						res = "";
+						lastSegmentLength = 0;
+						lastSlash = index;
+						dots = 0;
+						continue;
+					}
+				}
+				if (allowAboveRoot) {
+					res += res.length > 0 ? "/.." : "..";
+					lastSegmentLength = 2;
+				}
+			} else {
+				if (res.length > 0) res += `/${path.slice(lastSlash + 1, index)}`;
+				else res = path.slice(lastSlash + 1, index);
+				lastSegmentLength = index - lastSlash - 1;
+			}
+			lastSlash = index;
+			dots = 0;
+		} else if (char === "." && dots !== -1) ++dots;
+		else dots = -1;
+	}
+	return res;
+}
+const isAbsolute = function(p) {
+	return _IS_ABSOLUTE_RE.test(p);
+};
+const relative = function(from, to) {
+	const _from = resolve(from).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	const _to = resolve(to).replace(_ROOT_FOLDER_RE, "$1").split("/");
+	if (_to[0][1] === ":" && _from[0][1] === ":" && _from[0] !== _to[0]) return _to.join("/");
+	const _fromCopy = [..._from];
+	for (const segment of _fromCopy) {
+		if (_to[0] !== segment) break;
+		_from.shift();
+		_to.shift();
+	}
+	return [..._from.map(() => ".."), ..._to].join("/");
+};
+const dirname = function(p) {
+	const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+	if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) segments[0] += "/";
+	return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+//#endregion
+//#region src/plugin-islands.ts
+const COMPONENT_EXTENSIONS = [
+	".vue",
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+function fileHasCss(filePath) {
+	try {
+		const code = readFileSync(filePath, "utf-8");
+		if (/import\b[^"']*["'][^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss)["']/.test(code)) return true;
+		if (/<style\b(?![^>]*\bscoped\b)[^>]*>/.test(code)) return true;
+		return false;
+	} catch {
+		return false;
+	}
+}
+function extractCss(filePath) {
+	const code = readFileSync(filePath, "utf-8");
+	const parts = [];
+	const jsRe = /^\s*import\b[^"']*["']([^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss))["']/gm;
+	let match;
+	while ((match = jsRe.exec(code)) !== null) parts.push(`@import ${JSON.stringify(match[1])};`);
+	const styleBlockRe = /<style\b([^>]*)>([\s\S]*?)<\/style>/g;
+	while ((match = styleBlockRe.exec(code)) !== null) {
+		const attrs = match[1];
+		if (/\bscoped\b/.test(attrs)) continue;
+		const content = match[2].trim();
+		if (content) parts.push(content);
+	}
+	return parts.join("\n");
+}
+function islandsPlugin(pagesDir) {
+	let pageScan = null;
+	const root = dirname(pagesDir);
+	const islandManifest = /* @__PURE__ */ new Map();
+	const islandCssFiles = /* @__PURE__ */ new Set();
+	let isDev = false;
+	let viteRoot = "";
+	const islandCssMap = /* @__PURE__ */ new Map();
+	let resolvedConfig = null;
+	/** Rebuild islandCssMap from current file contents (re-runs fileHasCss). */
+	function rebuildIslandCssMap$1() {
+		if (!pageScan) return;
+		rebuildIslandCssMap(pageScan, pagesDir, islandCssMap, fileHasCss);
+	}
+	function computePagesNeedingClientJS$1() {
+		if (!pageScan) return /* @__PURE__ */ new Set();
+		return computePagesNeedingClientJS(pageScan, pagesDir, resolvedConfig);
+	}
+	return [{
+		name: "void-vue:islands",
+		enforce: "pre",
+		configResolved(config) {
+			resolvedConfig = config;
+			viteRoot = config.root;
+			isDev = config.command === "serve";
+		},
+		configureServer(server) {
+			configureIslandCssServer(server, islandCssFiles, viteRoot, rebuildIslandCssMap$1);
+			watchPagesForRescan(server, pagesDir, root, (scan) => {
+				pageScan = scan;
+				rebuildIslandCssMap$1();
+			});
+		},
+		async buildStart() {
+			if (existsSync(pagesDir)) {
+				pageScan = await scanPages(root);
+				const importAttrRe = /import\s+\w+\s+from\s+("[^"]+"|'[^']+')\s+with\s*\{\s*island\s*:\s*("[^"]+"|'[^']+')\s*\}/g;
+				const filesToScan = [
+					...pageScan.pages.map((p) => ({
+						filePath: p.componentPath,
+						island: p.island
+					})),
+					...pageScan.layouts.map((l) => ({
+						filePath: l.filePath,
+						island: l.island
+					})),
+					...pageScan.namedLayouts.map((nl) => ({
+						filePath: nl.filePath,
+						island: nl.island
+					}))
+				];
+				for (const entry of filesToScan) {
+					if (!entry.island) continue;
+					const filePath = resolve(pagesDir, entry.filePath);
+					const code = readFileSync(filePath, "utf-8");
+					const importerDir = dirname(filePath);
+					importAttrRe.lastIndex = 0;
+					let m;
+					while ((m = importAttrRe.exec(code)) !== null) {
+						const spec = m[1].slice(1, -1);
+						const strategy = m[2].slice(1, -1);
+						const absPath = resolveSpecifier(spec, importerDir, COMPONENT_EXTENSIONS);
+						if (absPath) {
+							const islandId = normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "");
+							islandManifest.set(islandId, {
+								componentPath: absPath,
+								islandId,
+								hydrate: strategy
+							});
+						}
+					}
+				}
+				for (const page of pageScan.pages) {
+					if (!page.island) continue;
+					if (page.componentPath.endsWith(".vue")) islandCssFiles.add(normalizePath(resolve(pagesDir, page.componentPath)));
+					const layoutChain = resolveEffectiveLayoutChain(page, pageScan.layouts, pageScan.namedLayouts);
+					for (const layout of layoutChain) islandCssFiles.add(normalizePath(resolve(pagesDir, layout.filePath)));
+				}
+				rebuildIslandCssMap$1();
+			}
+		},
+		resolveId: {
+			filter: { id: /^virtual:void-islands-(renderer|client)$|\.vue\.css$/ },
+			handler(source) {
+				if (source === ISLANDS_RENDERER_ID || source === ISLANDS_CLIENT_ENTRY_ID) return "\0" + source;
+				if (source.endsWith(".css")) {
+					const srcPath = normalizePath(source.slice(0, -4));
+					if (islandCssFiles.has(srcPath)) return srcPath + ".css";
+					if (srcPath.startsWith("/")) {
+						const absPath = normalizePath(resolve(viteRoot, srcPath.slice(1)));
+						if (islandCssFiles.has(absPath)) return absPath + ".css";
+					}
+				}
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:void-islands-(renderer|client)$|\.vue\.css$/ },
+			handler(id) {
+				if (id === "\0" + ISLANDS_RENDERER_ID) {
+					if (!pageScan) return "export function renderIslandPage() { throw new Error('No pages found'); }";
+					const mdPlugin = resolvedConfig?.plugins?.find((p) => p.name === "void-md");
+					const mdScriptIds = new Set(mdPlugin?.api?.getClientScripts?.()?.keys() ?? []);
+					const needsJS = computePagesNeedingClientJS$1();
+					return generateIslandRenderer(pageScan, pagesDir, isDev, islandCssMap, viteRoot, mdScriptIds, needsJS);
+				}
+				if (id === "\0" + ISLANDS_CLIENT_ENTRY_ID) {
+					if (!pageScan) return "";
+					return generateIslandClientEntry(islandManifest, islandCssFiles, isDev);
+				}
+				if (id.endsWith(".css") && !id.startsWith("\0")) {
+					const srcPath = id.slice(0, -4);
+					if (islandCssFiles.has(srcPath)) return extractCss(srcPath);
+				}
+			}
+		},
+		transform: {
+			filter: { id: /\.island\.vue$/ },
+			handler(code, id) {
+				if (/import\s+\{[^}]*\buseForm\b/.test(code)) this.warn(`islands: useForm cannot be imported in island page '${id}'. Use useIslandForm instead.`);
+				const importAttrRe = /import\s+(\w+)\s+from\s+("[^"]+"|'[^']+')\s+with\s*\{\s*island\s*:\s*("[^"]+"|'[^']+')\s*\}/g;
+				const importerDir = dirname(id);
+				let transformed = code;
+				const wrappers = [];
+				let idx = 0;
+				let match;
+				while ((match = importAttrRe.exec(code)) !== null) {
+					const name = match[1];
+					const specRaw = match[2];
+					const strategyRaw = match[3];
+					const spec = specRaw.slice(1, -1);
+					const strategy = strategyRaw.slice(1, -1);
+					const rawName = `_raw_island_${idx++}`;
+					const absPath = resolveSpecifier(spec, importerDir, COMPONENT_EXTENSIONS);
+					if (absPath) {
+						const islandId = normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "");
+						islandManifest.set(islandId, {
+							componentPath: absPath,
+							islandId,
+							hydrate: strategy
+						});
+					}
+					const islandId = absPath ? normalizePath(relative(root, absPath)).replace(/\.[^.]+$/, "") : spec;
+					const replacement = `import ${rawName} from ${specRaw}`;
+					transformed = transformed.replace(match[0], replacement);
+					wrappers.push(`const ${name} = { inheritAttrs: false, render() { const props = this.$attrs; return _h_island("div", { "data-island": ${JSON.stringify(islandId)}, "data-props": JSON.stringify(props), "data-hydrate": ${JSON.stringify(strategy)} }, _h_island(${rawName}, props)); } };`);
+				}
+				if (wrappers.length > 0) {
+					const setupMatch = transformed.match(/<script\b[^>]*\bsetup\b[^>]*>/);
+					if (setupMatch) {
+						const openEnd = setupMatch.index + setupMatch[0].length;
+						const closeIdx = transformed.indexOf("<\/script>", openEnd);
+						if (closeIdx !== -1) transformed = transformed.slice(0, openEnd) + "\nimport { h as _h_island } from \"vue\";" + transformed.slice(openEnd, closeIdx) + "\n" + wrappers.join("\n") + "\n" + transformed.slice(closeIdx);
+					}
+					return {
+						code: transformed,
+						map: null
+					};
+				}
+			}
+		},
+		config(_, env) {
+			if (!existsSync(pagesDir)) return;
+			if (env.command === "serve") return { optimizeDeps: { include: ["vue"] } };
+			if (needsIslandClientBundle(pagesDir, /\.island\.vue$/, true)) return { environments: { client: { build: {
+				manifest: true,
+				rollupOptions: { input: { "islands-client": ISLANDS_CLIENT_ENTRY_ID } }
+			} } } };
+		}
+	}];
+}
+function generateIslandRenderer(scan, pagesDir, isDev, islandCssMap, viteRoot, mdScriptIds, pagesNeedingClientJS) {
+	let cssMapCode = "";
+	if (isDev && islandCssMap.size > 0) {
+		const cssMapObj = {};
+		for (const [compId, paths] of islandCssMap) cssMapObj[compId] = paths.map((p) => "/" + normalizePath(relative(viteRoot, p)) + ".css");
+		cssMapCode = `const __cssPaths = ${JSON.stringify(cssMapObj)};`;
+	}
+	const mdScriptIdsCode = `const __mdClientScriptIds = new Set(${JSON.stringify([...mdScriptIds])});`;
+	const needsJSCode = `const __pagesNeedingClientJS = new Set(${JSON.stringify([...pagesNeedingClientJS])});`;
+	return `
+import { createSSRApp, h, reactive, provide } from "vue";
+import { renderToString } from "vue/server-renderer";
+import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from "void/pages-head";
+
+${generateComponentManifest(scan, pagesDir)}
+${cssMapCode}
+${mdScriptIdsCode}
+${needsJSCode}
+
+function escapeAttr(s) {
+  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+
+export async function renderIslandPage(pageObj, assetTags) {
+  const __pageModule = await components[pageObj.component]();
+  const PageComponent = __pageModule.default;
+  const __frontmatter = __pageModule.frontmatter;
+  const layoutIds = layoutTree[pageObj.component] || [];
+  const layoutComponents = await Promise.all(
+    layoutIds.map(async (id) => (await components[id]()).default)
+  );
+
+  const app = createSSRApp({
+    setup() {
+      provide("__void_shared", reactive(pageObj.shared || {}));
+      provide("__void_errors", reactive(pageObj.errors || {}));
+      if (__frontmatter) provide("__void_frontmatter", __frontmatter);
+      // No router provided — islands have no Void Router
+      return () => {
+        let vnode = h(PageComponent, pageObj.props);
+        for (let i = layoutComponents.length - 1; i >= 0; i--) {
+          const inner = vnode;
+          vnode = h(layoutComponents[i], null, { default: () => inner });
+        }
+        return vnode;
+      };
+    }
+  });
+
+  const html = await renderToString(app);
+  const __mdScriptAttr = __mdClientScriptIds.has(pageObj.component) ? \` data-md-script="\${escapeAttr(pageObj.component)}"\` : "";
+  const headHtml = pageObj.head ? renderHeadToString(pageObj.head) : "";
+  const htmlAttrs = pageObj.head ? renderHtmlAttrs(pageObj.head) : "";
+  const bodyAttrs = pageObj.head ? renderBodyAttrs(pageObj.head) : "";
+
+  return \`<!doctype html>
+<html\${htmlAttrs}>
+<head>\${headHtml}\${typeof __cssPaths !== "undefined" ? (__cssPaths[pageObj.component] || []).map(url => '<link rel="stylesheet" href="' + url + '">').join("\\n") : ""}\${assetTags.css}\${__pagesNeedingClientJS.has(pageObj.component) ? assetTags.preloads : ""}</head>
+<body\${bodyAttrs}>
+  <div id="app"\${__mdScriptAttr}>\${html}</div>
+  \${__pagesNeedingClientJS.has(pageObj.component) ? assetTags.body : ""}
+</body>
+</html>\`;
+}
+`;
+}
+function generateIslandClientEntry(manifest, cssFiles, isDev) {
+	const entries = [...manifest.values()];
+	const uniqueIslands = /* @__PURE__ */ new Map();
+	for (const entry of entries) uniqueIslands.set(entry.islandId, entry.componentPath);
+	const lines = [];
+	lines.push("import { initIslands } from \"void/pages-client\";");
+	if (!isDev) {
+		const styleRe = /<style\b([^>]*)>/g;
+		const cssImportRe = /^\s*import\b[^"']*["']([^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss))["']/gm;
+		for (const file of cssFiles) {
+			const content = readFileSync(file, "utf-8");
+			styleRe.lastIndex = 0;
+			let index = 0;
+			let match;
+			while ((match = styleRe.exec(content)) !== null) {
+				const attrs = match[1];
+				const scoped = /\bscoped\b/.test(attrs);
+				const langMatch = attrs.match(/\blang\s*=\s*["'](\w+)["']/);
+				const lang = langMatch ? langMatch[1] : "css";
+				let query = `?vue&type=style&index=${index}&lang.${lang}`;
+				if (scoped) query += "&scoped=true";
+				lines.push(`import ${JSON.stringify(file + query)};`);
+				index++;
+			}
+			cssImportRe.lastIndex = 0;
+			while ((match = cssImportRe.exec(content)) !== null) lines.push(rewriteCssImportForVirtualModule(match[0], match[1], file));
+		}
+	}
+	lines.push("const islands = {");
+	for (const [id, path] of uniqueIslands) lines.push(`  ${JSON.stringify(id)}: () => import(${JSON.stringify(path)}),`);
+	lines.push("};");
+	lines.push(`
+async function hydrateIsland(el, mod, props) {
+  const { createSSRApp, h } = await import("vue");
+  const Component = mod.default || mod;
+  const app = createSSRApp({ render: () => h(Component, props) });
+  app.mount(el);
+  el.setAttribute("data-hydrated", "true");
+}
+
+initIslands(islands, hydrateIsland);
+`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/plugin-pages.ts
+const RENDERER_ID = "virtual:void-pages-renderer";
+const CLIENT_ENTRY_ID = "virtual:void-pages-client";
+function isVuePageFile(id, pagesDir) {
+	if (!id.startsWith(pagesDir + "/")) return false;
+	const rel = id.slice(pagesDir.length + 1);
+	if (rel.split("/").some((s) => s.startsWith("_"))) return false;
+	const basename = rel.slice(rel.lastIndexOf("/") + 1);
+	return basename !== "layout.vue" && !basename.endsWith(".island.vue");
+}
+function stripDefinePropsTypeArgument(code) {
+	const match = /\bdefineProps\s*</.exec(code);
+	if (!match) return null;
+	const start = match.index + match[0].length - 1;
+	let depth = 0;
+	let end = -1;
+	let newlineCount = 0;
+	for (let i = start; i < code.length; i++) {
+		const ch = code[i];
+		if (ch === "\n") newlineCount++;
+		else if (ch === "<") depth++;
+		else if (ch === ">") {
+			depth--;
+			if (depth === 0) {
+				end = i;
+				break;
+			}
+		}
+	}
+	if (end === -1) return null;
+	return code.slice(0, start) + "\n".repeat(newlineCount) + code.slice(end + 1);
+}
+/** Check if the pages directory has any non-island Vue page files. */
+function hasNonIslandPages(dir) {
+	try {
+		for (const entry of readdirSync(dir, {
+			withFileTypes: true,
+			recursive: true
+		})) {
+			if (!entry.isFile()) continue;
+			const name = entry.name;
+			if (name.startsWith("_") || name.startsWith("layout.")) continue;
+			if (name.endsWith(".vue") && !name.includes(".island.")) return true;
+		}
+	} catch {}
+	return false;
+}
+function pagesPlugin(pagesDir, options) {
+	let pageScan = null;
+	let viteConfig;
+	const root = dirname(pagesDir);
+	return [{
+		name: "void-vue:pages-transform",
+		enforce: "pre",
+		transform: {
+			filter: { id: /\.vue$/ },
+			handler(code, id) {
+				if (!isVuePageFile(id, pagesDir)) return;
+				const transformed = stripDefinePropsTypeArgument(code);
+				if (!transformed) return;
+				return {
+					code: transformed,
+					map: { mappings: "" }
+				};
+			}
+		},
+		handleHotUpdate: {
+			order: "pre",
+			handler(ctx) {
+				if (!isVuePageFile(ctx.file, pagesDir)) return;
+				const read = ctx.read;
+				ctx.read = async () => {
+					const code = await read();
+					return stripDefinePropsTypeArgument(code) ?? code;
+				};
+			}
+		}
+	}, {
+		name: "void-vue:pages",
+		async buildStart() {
+			if (existsSync(pagesDir)) pageScan = await scanPages(root);
+		},
+		resolveId: {
+			filter: { id: /^virtual:void-pages-(renderer|client)$/ },
+			handler(id) {
+				return "\0" + id;
+			}
+		},
+		load: {
+			filter: { id: /^\0virtual:void-pages-(renderer|client)$/ },
+			handler(id) {
+				if (id === "\0" + RENDERER_ID) {
+					if (!pageScan) return "export function renderPage() { throw new Error('No pages found'); }";
+					return generateRendererModule(pageScan, pagesDir);
+				}
+				if (id === "\0" + CLIENT_ENTRY_ID) {
+					if (!pageScan) return "";
+					return generateClientEntry(pageScan, pagesDir, options?.viewTransitions, options?.prefetch, resolveStaticPageDataBuildOptions(root, { publicDir: viteConfig?.publicDir }));
+				}
+			}
+		},
+		configResolved(config) {
+			viteConfig = config;
+		},
+		config(_, env) {
+			if (!existsSync(pagesDir)) return;
+			if (env.command === "serve") return { optimizeDeps: { include: ["vue"] } };
+			if (!hasNonIslandPages(pagesDir)) return;
+			return { environments: { client: { build: {
+				manifest: true,
+				rollupOptions: { input: { "pages-client": CLIENT_ENTRY_ID } }
+			} } } };
+		}
+	}];
+}
+function generateRendererModule(scan, pagesDir) {
+	return `
+import { createSSRApp, h, reactive, provide } from "vue";
+import { renderToString } from "vue/server-renderer";
+import { createSsrRouter, idleNavigationState } from "void/pages-client";
+import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from "void/pages-head";
+import { serializePageData } from "void/pages-server";
+
+${generateComponentManifest(scan, pagesDir)}
+
+function patchProps(comp, props) {
+  if (comp.__voidPatched) return;
+  comp.props = Object.keys(props);
+  comp.__voidPatched = true;
+}
+
+export async function renderPage(pageObj, assetTags) {
+  const PageComponent = (await components[pageObj.component]()).default;
+  const layoutIds = layoutTree[pageObj.component] || [];
+  const layoutComponents = await Promise.all(
+    layoutIds.map(async (id) => (await components[id]()).default)
+  );
+
+  const app = createSSRApp({
+    setup() {
+      provide("__void_shared", reactive(pageObj.shared || {}));
+      provide("__void_errors", reactive(pageObj.errors || {}));
+      provide("__void_router", createSsrRouter(pageObj.url || "/"));
+      provide("__void_navigation", idleNavigationState());
+      return () => {
+        patchProps(PageComponent, pageObj.props);
+        let vnode = h(PageComponent, pageObj.props);
+        for (let i = layoutComponents.length - 1; i >= 0; i--) {
+          const inner = vnode;
+          vnode = h(layoutComponents[i], null, { default: () => inner });
+        }
+        return vnode;
+      };
+    }
+  });
+
+  const html = await renderToString(app);
+  const pageData = serializePageData(pageObj);
+  const headHtml = pageObj.head ? renderHeadToString(pageObj.head) : "";
+  const htmlAttrs = pageObj.head ? renderHtmlAttrs(pageObj.head) : "";
+  const bodyAttrs = pageObj.head ? renderBodyAttrs(pageObj.head) : "";
+
+  return \`<!doctype html>
+<html\${htmlAttrs}>
+<head>\${headHtml}\${assetTags.css}\${assetTags.preloads}</head>
+<body\${bodyAttrs}>
+  <script id="__VOID_PAGE_DATA__" type="application/json">\${pageData}<\/script>
+  <div id="app">\${html}</div>
+  \${assetTags.body}
+</body>
+</html>\`;
+}
+`;
+}
+function generateClientEntry(scan, pagesDir, viewTransitions, prefetch, staticPageData) {
+	return `
+import { createSSRApp, h, reactive, provide, shallowRef, nextTick, ref } from "vue";
+import { createDeferred, resolveDeferred, rejectDeferred } from "@void/vue/deferred";
+import { setActionRouter } from "@void/vue";
+import { createRouterFacade, createVoidRouter, idleNavigationState } from "void/pages-client";
+import { parseCacheFor } from "void/pages-prefetch";
+
+${generateComponentManifest(scan, pagesDir)}
+
+const shared = reactive({});
+const errors = reactive({});
+const currentComponent = shallowRef(null);
+const currentLayouts = shallowRef([]);
+const currentProps = shallowRef({});
+const routeUrl = ref(window.location.pathname + window.location.search + window.location.hash);
+const navigation = reactive(idleNavigationState());
+
+function patchProps(comp, props) {
+  if (comp.__voidPatched) return;
+  comp.props = Object.keys(props);
+  comp.__voidPatched = true;
+}
+
+const { router, initialPageData, initialComponent, initialLayouts, start } =
+  await createVoidRouter({
+    adapter: {
+      createDeferred: () => createDeferred(),
+      resolveDeferred(ref, value) { resolveDeferred(ref, value); return ref; },
+      rejectDeferred(ref, error) { rejectDeferred(ref, error); return ref; },
+      isLoading: (ref) => ref.loading,
+      applyUpdate(pageData, comp, layouts) {
+        Object.assign(shared, pageData.shared || {});
+        for (const key of Object.keys(errors)) delete errors[key];
+        Object.assign(errors, pageData.errors || {});
+        currentProps.value = pageData.props;
+        currentLayouts.value = layouts;
+        currentComponent.value = comp;
+        return nextTick();
+      },
+    },
+    components, layoutTree, routeMeta, matchRoute,
+    staticPageData: ${!!staticPageData?.enabled},
+    staticPageDataFastPath: ${!!staticPageData?.fastPath},
+    viewTransitions: ${!!viewTransitions},
+    prefetchHoverDelay: ${prefetch?.hoverDelay ?? 75},
+    prefetchDefaultCacheFor: parseCacheFor(${JSON.stringify(prefetch?.cacheFor ?? "30s")}),
+    onRouteChange(url) {
+      routeUrl.value = url;
+    },
+    onNavigationChange(next) {
+      navigation.state = next.state;
+      navigation.location = next.location;
+      navigation.method = next.method;
+    },
+  });
+
+const reactiveRouter = createRouterFacade(router, () => routeUrl.value);
+
+setActionRouter(reactiveRouter);
+
+Object.assign(shared, initialPageData.shared || {});
+Object.assign(errors, initialPageData.errors || {});
+currentProps.value = initialPageData.props;
+currentComponent.value = initialComponent;
+currentLayouts.value = initialLayouts;
+
+const app = createSSRApp({
+  setup() {
+    provide("__void_shared", shared);
+    provide("__void_errors", errors);
+    provide("__void_router", reactiveRouter);
+    provide("__void_navigation", navigation);
+
+    return () => {
+      if (!currentComponent.value) return null;
+      patchProps(currentComponent.value, currentProps.value);
+      let vnode = h(currentComponent.value, currentProps.value);
+      for (let i = currentLayouts.value.length - 1; i >= 0; i--) {
+        const inner = vnode;
+        vnode = h(currentLayouts.value[i], null, { default: () => inner });
+      }
+      return vnode;
+    };
+  }
+});
+
+app.mount("#app");
+document.getElementById("app").setAttribute("data-hydrated", "true");
+export { reactiveRouter as router };
+start();
+`;
+}
+//#endregion
+//#region src/plugin.ts
+function voidVue(options) {
+	const pagesDir = join(process.cwd(), "pages");
+	return [
+		vue(options?.vue),
+		...pagesPlugin(pagesDir, { viewTransitions: options?.viewTransitions }),
+		...islandsPlugin(pagesDir)
+	];
+}
+//#endregion
+export { voidVue };