@void/svelte 0.0.0

package/dist/plugin.mjs

@@ -0,0 +1,681 @@
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+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, extractCssImports, fileHasCssImports, 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 = [
+	".svelte",
+	".ts",
+	".js"
+];
+/**
+* Prefix for virtual island wrapper modules. Must NOT use the `\0` prefix
+* because `@sveltejs/vite-plugin-svelte` skips `\0`-prefixed modules in
+* its transform filter.
+*/
+const WRAPPER_PREFIX = "/@void-island-wrap/";
+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 fileHasCssImports). */
+	function rebuildIslandCssMap$1() {
+		if (!pageScan) return;
+		rebuildIslandCssMap(pageScan, pagesDir, islandCssMap, fileHasCssImports);
+	}
+	function computePagesNeedingClientJS$1() {
+		if (!pageScan) return /* @__PURE__ */ new Set();
+		return computePagesNeedingClientJS(pageScan, pagesDir, resolvedConfig);
+	}
+	return [{
+		name: "void-svelte: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(".svelte")) 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)|\/@void-island-wrap\/)|\.svelte\.css$/ },
+			handler(source) {
+				if (source === ISLANDS_RENDERER_ID || source === ISLANDS_CLIENT_ENTRY_ID) return "\0" + source;
+				if (source.startsWith(WRAPPER_PREFIX)) return 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)|\/@void-island-wrap\/)|\.svelte\.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.startsWith(WRAPPER_PREFIX)) return generateWrapperComponent(id);
+				if (id.endsWith(".css") && !id.startsWith("\0")) {
+					const srcPath = id.slice(0, -4);
+					if (islandCssFiles.has(srcPath)) return extractCssImports(srcPath);
+				}
+			}
+		},
+		transform: {
+			filter: { id: /\.island\.svelte$/ },
+			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;
+				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 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 wrapperUrl = WRAPPER_PREFIX + encodeURIComponent(islandId) + ".svelte?src=" + encodeURIComponent(absPath || spec) + "&island=" + encodeURIComponent(islandId) + "&hydrate=" + encodeURIComponent(strategy);
+					const replacement = `import ${name} from ${JSON.stringify(wrapperUrl)}`;
+					transformed = transformed.replace(match[0], replacement);
+				}
+				if (transformed !== code) return {
+					code: transformed,
+					map: null
+				};
+			}
+		},
+		config(_, env) {
+			if (!existsSync(pagesDir)) return;
+			if (env.command === "serve") return { optimizeDeps: { include: ["svelte"] } };
+			if (needsIslandClientBundle(pagesDir, /\.island\.svelte$/, true)) return { environments: { client: { build: {
+				manifest: true,
+				rollupOptions: { input: { "islands-client": ISLANDS_CLIENT_ENTRY_ID } }
+			} } } };
+		}
+	}, {
+		name: "void-svelte:islands-style",
+		resolveId: {
+			filter: { id: /\?island-style&/ },
+			handler(source) {
+				return source;
+			}
+		},
+		load: {
+			filter: { id: /\?island-style&/ },
+			handler(id) {
+				const filePath = id.replace(/\?island-style&.*$/, "");
+				const params = new URLSearchParams(id.slice(id.indexOf("?island-style&") + 1));
+				const index = parseInt(params.get("index") || "0", 10);
+				const content = readFileSync(filePath, "utf-8");
+				const styleBlockRe = /<style\b[^>]*>([\s\S]*?)<\/style>/g;
+				let match;
+				let i = 0;
+				while ((match = styleBlockRe.exec(content)) !== null) {
+					if (i === index) return match[1];
+					i++;
+				}
+				return "/* style block not found */";
+			}
+		}
+	}];
+}
+/**
+* Generate a virtual Svelte wrapper component from a wrapper URL.
+* The URL encodes: src (absolute component path), island (ID), hydrate (strategy).
+*/
+function generateWrapperComponent(id) {
+	const url = new URL(id, "file://");
+	const src = decodeURIComponent(url.searchParams.get("src") || "");
+	const islandId = decodeURIComponent(url.searchParams.get("island") || "");
+	const hydrate = decodeURIComponent(url.searchParams.get("hydrate") || "load");
+	return `<script>
+  import Cmp from ${JSON.stringify(src)};
+  let props = $props();
+<\/script>
+<div data-island="${islandId}" data-props={JSON.stringify(props)} data-hydrate="${hydrate}">
+  <Cmp {...props} />
+</div>
+`;
+}
+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 { render } from "svelte/server";
+import App from "@void/svelte/App.svelte";
+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 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 { html, head } = render(App, {
+    props: {
+      page: PageComponent,
+      layouts: layoutComponents,
+      pageProps: pageObj.props,
+      shared: pageObj.shared || {},
+      errors: pageObj.errors || {},
+      router: null,
+      stores: null,
+    },
+  });
+
+  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") : ""}\${head}\${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) for (const file of cssFiles) {
+		const content = readFileSync(file, "utf-8");
+		const styleRe = /<style\b([^>]*)>/g;
+		styleRe.lastIndex = 0;
+		let styleIndex = 0;
+		let styleMatch;
+		while ((styleMatch = styleRe.exec(content)) !== null) {
+			const langMatch = styleMatch[1].match(/\blang\s*=\s*["'](\w+)["']/);
+			const lang = langMatch ? langMatch[1] : "css";
+			lines.push(`import ${JSON.stringify(file + "?island-style&index=" + styleIndex + "&lang." + lang)};`);
+			styleIndex++;
+		}
+		const scriptRe = /<script\b[^>]*>([\s\S]*?)<\/script>/g;
+		const cssImportRe = /^\s*import\b[^"']*["']([^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss))["']/gm;
+		let scriptMatch;
+		while ((scriptMatch = scriptRe.exec(content)) !== null) {
+			const scriptContent = scriptMatch[1];
+			let cssMatch;
+			cssImportRe.lastIndex = 0;
+			while ((cssMatch = cssImportRe.exec(scriptContent)) !== null) lines.push(rewriteCssImportForVirtualModule(cssMatch[0], cssMatch[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 { hydrate } = await import("svelte");
+  const Component = mod.default || mod;
+  hydrate(Component, { target: el, props });
+  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";
+/** Check if the pages directory has any non-island Svelte 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(".svelte") && !name.includes(".island.")) return true;
+		}
+	} catch {}
+	return false;
+}
+function pagesPlugin(pagesDir, options) {
+	let pageScan = null;
+	let isDev = false;
+	let viteConfig;
+	const root = dirname(pagesDir);
+	return {
+		name: "void-svelte: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, isDev);
+				}
+				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") {
+				isDev = true;
+				return { optimizeDeps: {
+					exclude: ["@void/svelte"],
+					include: [
+						"svelte",
+						"svelte/store",
+						"svelte/internal",
+						"svelte/internal/client"
+					]
+				} };
+			}
+			if (!hasNonIslandPages(pagesDir)) return;
+			return { build: {
+				manifest: true,
+				rollupOptions: { input: { "pages-client": CLIENT_ENTRY_ID } }
+			} };
+		}
+	};
+}
+function generateRendererModule(scan, pagesDir, _isDev) {
+	return `
+import { render } from "svelte/server";
+import App from "@void/svelte/App.svelte";
+import { createSsrRouter, idleNavigationState } from "void/pages-client";
+import { renderHeadToString, renderHtmlAttrs, renderBodyAttrs } from "void/pages-head";
+import { serializePageData } from "void/pages-server";
+
+${generateComponentManifest(scan, pagesDir)}
+
+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 { html, head } = render(App, {
+    props: {
+      page: PageComponent,
+      layouts: layoutComponents,
+      pageProps: pageObj.props,
+      shared: pageObj.shared || {},
+      errors: pageObj.errors || {},
+      router: createSsrRouter(pageObj.url || "/"),
+      routeUrl: pageObj.url || "/",
+      navigation: idleNavigationState(),
+      stores: null,
+    },
+  });
+
+  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}\${head}\${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 { hydrate } from "svelte";
+import { writable } from "svelte/store";
+import App from "@void/svelte/App.svelte";
+import { setActionRouter } from "@void/svelte";
+import { createRouterFacade, createVoidRouter, idleNavigationState } from "void/pages-client";
+import { parseCacheFor } from "void/pages-prefetch";
+
+${generateComponentManifest(scan, pagesDir)}
+
+const pageStore = writable(null);
+const propsStore = writable({});
+const layoutsStore = writable([]);
+const sharedStore = writable({});
+const errorsStore = writable({});
+let routeUrl = window.location.pathname + window.location.search + window.location.hash;
+const routeStore = writable(routeUrl);
+const navigationStore = writable(idleNavigationState());
+
+const { router, initialPageData, initialComponent, initialLayouts, start } =
+  await createVoidRouter({
+    adapter: {
+      createDeferred: () => ({ value: null, loading: true, error: null }),
+      resolveDeferred(ref, value) { return { value, loading: false, error: null }; },
+      rejectDeferred(ref, error) { return { value: null, loading: false, error: new Error(error) }; },
+      isLoading: (ref) => ref.loading,
+      applyUpdate(pageData, comp, layouts) {
+        propsStore.set(pageData.props);
+        sharedStore.update((s) => ({ ...s, ...(pageData.shared || {}) }));
+        errorsStore.set(pageData.errors || {});
+        layoutsStore.set(layouts);
+        pageStore.set(comp);
+      },
+      onDeferredUpdate(props) {
+        propsStore.set({ ...props });
+      },
+    },
+    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 = url;
+      routeStore.set(url);
+    },
+    onNavigationChange(navigation) {
+      navigationStore.set(navigation);
+    },
+  });
+
+const reactiveRouter = createRouterFacade(router, () => routeUrl);
+
+setActionRouter(reactiveRouter);
+
+pageStore.set(initialComponent);
+propsStore.set(initialPageData.props);
+layoutsStore.set(initialLayouts);
+sharedStore.set(initialPageData.shared || {});
+errorsStore.set(initialPageData.errors || {});
+
+const appEl = document.getElementById("app");
+hydrate(App, {
+  target: appEl,
+  props: {
+    page: initialComponent,
+    layouts: initialLayouts,
+    pageProps: initialPageData.props,
+    shared: initialPageData.shared || {},
+    errors: initialPageData.errors || {},
+    router,
+    routeUrl,
+    navigation: idleNavigationState(),
+    stores: {
+      page: pageStore,
+      props: propsStore,
+      layouts: layoutsStore,
+      shared: sharedStore,
+      errors: errorsStore,
+      route: routeStore,
+      navigation: navigationStore,
+    },
+  },
+});
+
+appEl.setAttribute("data-hydrated", "true");
+export { reactiveRouter as router };
+start();
+`;
+}
+//#endregion
+//#region src/plugin.ts
+function voidSvelte(options) {
+	const pagesDir = join(process.cwd(), "pages");
+	return [
+		...svelte(options?.svelte),
+		pagesPlugin(pagesDir, {
+			viewTransitions: options?.viewTransitions,
+			prefetch: options?.prefetch
+		}),
+		...islandsPlugin(pagesDir)
+	];
+}
+//#endregion
+export { voidSvelte };