@void/solid 0.0.0

package/dist/plugin.mjs

@@ -0,0 +1,708 @@
+import solid from "vite-plugin-solid";
+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 = [
+	".tsx",
+	".jsx",
+	".ts",
+	".js"
+];
+/**
+* Prefix for virtual island wrapper modules. Must NOT use the `\0` prefix
+* because `vite-plugin-solid` skips `\0`-prefixed modules in its transform
+* filter. Uses a clean `.tsx` extension (no query params) so rolldown can
+* detect the language.
+*/
+const WRAPPER_PREFIX = "/@void-island-wrap/";
+function islandsPlugin(pagesDir) {
+	let pageScan = null;
+	let isDev = false;
+	const root = dirname(pagesDir);
+	const islandManifest = /* @__PURE__ */ new Map();
+	const islandCssFiles = /* @__PURE__ */ new Set();
+	const wrapperMeta = /* @__PURE__ */ new Map();
+	let wrapperId = 0;
+	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-solid: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 (/\.(tsx|jsx)$/.test(page.componentPath)) 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\/)|\.(tsx|jsx)\.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\/)|\.(tsx|jsx)\.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)) {
+					const meta = wrapperMeta.get(id);
+					if (meta) return generateWrapperComponent(meta);
+				}
+				if (id.endsWith(".css") && !id.startsWith("\0")) {
+					const srcPath = id.slice(0, -4);
+					if (islandCssFiles.has(srcPath)) return extractCssImports(srcPath);
+				}
+			}
+		},
+		transform: {
+			filter: { id: /\.island\.(tsx|jsx)$/ },
+			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 + "island_" + wrapperId++ + ".tsx";
+					wrapperMeta.set(wrapperUrl, {
+						src: absPath || spec,
+						islandId,
+						hydrate: 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" && needsIslandClientBundle(pagesDir, /\.island\.(tsx|jsx)$/, false)) return { build: {
+				manifest: true,
+				rollupOptions: { input: { "islands-client": ISLANDS_CLIENT_ENTRY_ID } }
+			} };
+		}
+	}];
+}
+/**
+* Generate a virtual TSX wrapper component.
+* vite-plugin-solid compiles the JSX for both SSR and client.
+*/
+function generateWrapperComponent(meta) {
+	return `import _Cmp from ${JSON.stringify(meta.src)};
+export default function _IslandWrap(props) {
+  return <div data-island="${meta.islandId}" data-props={JSON.stringify(props)} data-hydrate="${meta.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 { renderToStringAsync, generateHydrationScript } from "solid-js/web";
+import { createComponent } from "solid-js";
+import { SharedContext, ErrorsContext } from "@void/solid";
+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)
+  );
+
+  function ServerApp() {
+    return createComponent(SharedContext.Provider, {
+      value: pageObj.shared || {},
+      get children() {
+        return createComponent(ErrorsContext.Provider, {
+          value: pageObj.errors || {},
+          get children() {
+            // Build layout chain inside providers so contexts are available.
+            // No RouterContext — islands have no Void Router.
+            let element = createComponent(PageComponent, pageObj.props);
+            for (let i = layoutComponents.length - 1; i >= 0; i--) {
+              const Layout = layoutComponents[i];
+              const child = element;
+              element = createComponent(Layout, { get children() { return child; } });
+            }
+            return element;
+          }
+        });
+      }
+    });
+  }
+
+  const html = await renderToStringAsync(() => createComponent(ServerApp, {}));
+
+  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 : ""}\${__pagesNeedingClientJS.has(pageObj.component) ? generateHydrationScript() : ""}</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 cssImportRe = /^\s*import\b[^"']*["']([^"']+\.(?:css|scss|sass|less|styl|stylus|pcss|postcss))["']/gm;
+		for (const file of cssFiles) {
+			const content = readFileSync(file, "utf-8");
+			cssImportRe.lastIndex = 0;
+			let match;
+			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 mountIsland(el, mod, props) {
+  const { render } = await import("solid-js/web");
+  const { createComponent } = await import("solid-js");
+  const Component = mod.default || mod;
+  el.textContent = "";
+  render(() => createComponent(Component, props), el);
+  el.setAttribute("data-hydrated", "true");
+}
+
+initIslands(islands, mountIsland);
+`);
+	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 page files (.tsx/.jsx without .island.). */
+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 (/\.(tsx|jsx)$/.test(name) && !name.includes(".island.")) return true;
+		}
+	} catch {}
+	return false;
+}
+function pagesPlugin(pagesDir, options) {
+	let pageScan = null;
+	let viteConfig;
+	const root = dirname(pagesDir);
+	return {
+		name: "void-solid: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: {
+				exclude: ["@void/solid"],
+				include: [
+					"solid-js",
+					"solid-js/web",
+					"solid-js/store"
+				]
+			} };
+			if (!hasNonIslandPages(pagesDir)) return;
+			return { build: {
+				manifest: true,
+				rollupOptions: { input: { "pages-client": CLIENT_ENTRY_ID } }
+			} };
+		}
+	};
+}
+function generateRendererModule(scan, pagesDir) {
+	return `
+import { renderToStringAsync, generateHydrationScript } from "solid-js/web";
+import { createComponent } from "solid-js";
+import { SharedContext, ErrorsContext, RouterContext, NavigationContext } from "@void/solid";
+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)
+  );
+
+  function ServerApp() {
+    return createComponent(SharedContext.Provider, {
+      value: pageObj.shared || {},
+      get children() {
+        return createComponent(ErrorsContext.Provider, {
+          value: pageObj.errors || {},
+          get children() {
+            return createComponent(RouterContext.Provider, {
+              value: createSsrRouter(pageObj.url || "/"),
+              get children() {
+                return createComponent(NavigationContext.Provider, {
+                  value: () => idleNavigationState(),
+                  get children() {
+                    // Build layout chain inside providers so contexts are available
+                    let element = createComponent(PageComponent, pageObj.props);
+                    for (let i = layoutComponents.length - 1; i >= 0; i--) {
+                      const Layout = layoutComponents[i];
+                      const child = element;
+                      element = createComponent(Layout, { get children() { return child; } });
+                    }
+                    return element;
+                  }
+                });
+              }
+            });
+          }
+        });
+      }
+    });
+  }
+
+  // Use createComponent to match the client's hydration tree structure
+  const html = await renderToStringAsync(() => createComponent(ServerApp, {}));
+
+  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}\${generateHydrationScript()}</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 { createSignal, createComponent, batch } from "solid-js";
+import { hydrate } from "solid-js/web";
+import { SharedContext, ErrorsContext, RouterContext, NavigationContext, setActionRouter } from "@void/solid";
+import { createRouterFacade, createVoidRouter, idleNavigationState } from "void/pages-client";
+import { parseCacheFor } from "void/pages-prefetch";
+
+${generateComponentManifest(scan, pagesDir)}
+
+const [component, setComponent] = createSignal(null);
+const [pageProps, setPageProps] = createSignal({});
+const [layouts, setLayouts] = createSignal([]);
+const [shared, setShared] = createSignal({});
+const [errors, setErrors] = createSignal({});
+const [routeUrl, setRouteUrl] = createSignal(window.location.pathname + window.location.search + window.location.hash);
+const [navigation, setNavigation] = createSignal(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, layoutComps) {
+        batch(() => {
+          setPageProps(pageData.props);
+          setComponent(() => comp);
+          setLayouts(layoutComps);
+          setShared((prev) => ({ ...prev, ...(pageData.shared || {}) }));
+          setErrors(pageData.errors || {});
+        });
+      },
+      onDeferredUpdate(props) {
+        batch(() => { setPageProps({ ...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) {
+      setRouteUrl(url);
+    },
+    onNavigationChange(next) {
+      setNavigation(next);
+    },
+  });
+
+const reactiveRouter = createRouterFacade(router, () => routeUrl());
+
+setActionRouter(reactiveRouter);
+
+batch(() => {
+  setComponent(() => initialComponent);
+  setPageProps(initialPageData.props);
+  setLayouts(initialLayouts);
+  setShared(initialPageData.shared || {});
+  setErrors(initialPageData.errors || {});
+});
+
+function App() {
+  return createComponent(SharedContext.Provider, {
+    get value() { return shared(); },
+    get children() {
+      return createComponent(ErrorsContext.Provider, {
+        value: errors,
+        get children() {
+          return createComponent(RouterContext.Provider, {
+            value: reactiveRouter,
+            get children() {
+              return createComponent(NavigationContext.Provider, {
+                value: navigation,
+                get children() {
+                  const Comp = component();
+                  if (!Comp) return null;
+                  let element = createComponent(Comp, pageProps());
+                  const layoutList = layouts();
+                  for (let i = layoutList.length - 1; i >= 0; i--) {
+                    const Layout = layoutList[i];
+                    const child = element;
+                    element = createComponent(Layout, { get children() { return child; } });
+                  }
+                  return element;
+                }
+              });
+            }
+          });
+        }
+      });
+    }
+  });
+}
+
+const appEl = document.getElementById("app");
+hydrate(() => createComponent(App, {}), appEl);
+appEl.setAttribute("data-hydrated", "true");
+export { reactiveRouter as router };
+start();
+`;
+}
+//#endregion
+//#region src/plugin.ts
+function configPlugin() {
+	return {
+		name: "void:solid:config",
+		config() {
+			return {
+				optimizeDeps: { exclude: ["@void/solid"] },
+				ssr: {
+					noExternal: ["@void/solid"],
+					optimizeDeps: { exclude: ["@void/solid"] }
+				}
+			};
+		}
+	};
+}
+function voidSolid(options) {
+	const pagesDir = join(process.cwd(), "pages");
+	return [
+		configPlugin(),
+		solid({
+			ssr: true,
+			...options?.solid
+		}),
+		pagesPlugin(pagesDir, {
+			viewTransitions: options?.viewTransitions,
+			prefetch: options?.prefetch
+		}),
+		...islandsPlugin(pagesDir)
+	];
+}
+//#endregion
+export { voidSolid };