vinojs 0.0.1 → 0.1.0

package/dist/vite.mjs

@@ -0,0 +1,729 @@
+import { d as VIRTUAL_ASSETS, f as VIRTUAL_CLIENT, g as VIRTUAL_SSR_HOOKS, h as VIRTUAL_MANIFEST, m as VIRTUAL_COMPONENTS, p as VIRTUAL_CLIENT_PAGES, s as PAGE_EXTS, u as SHELL_HEADER } from "./constants-BVT2bJEd.mjs";
+import { c as usesDefinePage, o as readPageDefinition } from "./definePage-Ba4r-TFh.mjs";
+import { a as pathDepth, c as SERVER_FN_KIND, f as usesDefineServerFn, i as pathCovers, n as compareRoutes, o as urlToHtmlFile, p as loadMergedConfig, r as compileFilePath, s as DEFINE_SERVER_FN_CALL, t as applyParams$1 } from "./compile-Lxl_tdxL.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+//#region src/vino/prerender.ts
+async function collectPrerenderUrls(pages) {
+	const urls = [];
+	for (const page of pages) {
+		const pageMod = await page.loadPage();
+		const config = loadMergedConfig(page, pageMod);
+		const ssgParams = config.ssgParams;
+		if (config.prerender === false) continue;
+		if (!page.isStatic) {
+			if (!ssgParams) continue;
+			const list = await ssgParams();
+			for (const params of list) urls.push(applyParams$1(page.path, params));
+			continue;
+		}
+		urls.push(page.path === "" ? "/" : page.path);
+	}
+	return [...new Set(urls)];
+}
+async function prerender(options) {
+	const globalMode = options.mode ?? "partial";
+	if (globalMode === false && !options.urls?.length) return { files: [] };
+	const urls = options.urls ?? await collectPrerenderUrls(options.pages);
+	const files = [];
+	for (const url of urls) {
+		const init = (options.urlModes?.[url] ?? (globalMode === false ? "full" : globalMode)) === "partial" ? { headers: { [SHELL_HEADER]: "1" } } : void 0;
+		const res = await options.app.request(url, init);
+		if (!res.ok) {
+			console.warn(`[vino] skip prerender ${url} (${res.status})`);
+			continue;
+		}
+		const html = await res.text();
+		const rel = urlToHtmlFile(url);
+		const dest = join(options.outDir, rel);
+		await mkdir(dirname(dest), { recursive: true });
+		await writeFile(dest, html);
+		files.push(rel);
+	}
+	return { files };
+}
+//#endregion
+//#region src/vite/files.ts
+function stripKnownExt(fileName) {
+	for (const ext of PAGE_EXTS) if (fileName.endsWith(ext)) return fileName.slice(0, -ext.length);
+	return fileName;
+}
+function isPageExt(fileName) {
+	if (fileName.endsWith(".d.ts")) return false;
+	return PAGE_EXTS.some((ext) => fileName.endsWith(ext));
+}
+/** Colocated server modules (`[slug].server.ts`) — not filesystem routes. */
+function isServerModuleFile(filePath) {
+	const base = filePath.split(/[/\\]/).at(-1) ?? filePath;
+	return /\.server\.(tsx|ts|jsx|js|mjs)$/.test(base);
+}
+function isIgnoredPageFile(fileName) {
+	const base = fileName.split("/").at(-1) ?? fileName;
+	if (base.startsWith(".")) return true;
+	if (base.endsWith(".d.ts")) return true;
+	if (isServerModuleFile(base)) return true;
+	const name = stripKnownExt(base);
+	if (name.startsWith("_") || name.startsWith("+")) return true;
+	return false;
+}
+function isNamedComponentFile(filePath) {
+	return /\.component\.(tsx|ts|jsx|js|mjs)$/.test(filePath);
+}
+function isHydratableComponentFile(filePath, componentsDir) {
+	const posix = filePath.replaceAll("\\", "/");
+	const dir = componentsDir.replaceAll("\\", "/").replace(/\/$/, "");
+	if (posix.includes(`/${dir}/`) || posix.startsWith(`${dir}/`) || posix.includes(`${dir}/`)) {
+		const after = posix.split(`/${dir}/`).at(-1) ?? posix;
+		if (after && isPageExt(after) && !isIgnoredPageFile(after)) return true;
+	}
+	if (isNamedComponentFile(posix)) return true;
+	return false;
+}
+//#endregion
+//#region src/vite/crawl.ts
+function toPosix$1(p) {
+	return p.replaceAll("\\", "/");
+}
+async function walkFiles(dir) {
+	const out = [];
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return out;
+	}
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) continue;
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (entry.name === "node_modules") continue;
+			out.push(...await walkFiles(full));
+		} else out.push(full);
+	}
+	return out;
+}
+async function crawlWrappers(dirAbs) {
+	const files = await walkFiles(dirAbs);
+	const byPath = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const rel = toPosix$1(relative(dirAbs, file));
+		const base = rel.split("/").at(-1) ?? rel;
+		if (!isPageExt(base) || isIgnoredPageFile(base)) continue;
+		const compiled = compileFilePath(rel);
+		byPath.set(compiled.path, file);
+	}
+	return [...byPath.entries()].map(([path, file]) => ({
+		path,
+		file
+	}));
+}
+function wrappersForPath(wrappers, pagePath) {
+	return wrappers.filter((w) => pathCovers(w.path, pagePath)).sort((a, b) => pathDepth(a.path) - pathDepth(b.path) || a.path.localeCompare(b.path)).map((w) => w.file);
+}
+async function crawlPages(options) {
+	const pagesAbs = join(options.root, options.pagesDir);
+	const componentsAbs = join(options.root, options.componentsDir);
+	const layoutsAbs = join(options.root, options.layoutsDir);
+	const files = await walkFiles(pagesAbs);
+	const compiledPages = [];
+	for (const file of files) {
+		const rel = toPosix$1(relative(pagesAbs, file));
+		const base = rel.split("/").at(-1) ?? rel;
+		if (!isPageExt(base)) continue;
+		if (isNamedComponentFile(rel) || isIgnoredPageFile(base)) continue;
+		compiledPages.push({
+			file,
+			rel,
+			compiled: compileFilePath(rel)
+		});
+	}
+	const layouts = await crawlWrappers(layoutsAbs);
+	const byPath = /* @__PURE__ */ new Map();
+	for (const item of compiledPages) byPath.set(item.compiled.path, item);
+	const pages = [];
+	for (const [urlPath, item] of byPath) {
+		const compiled = item.compiled;
+		const pageFile = item.file;
+		const isClientPage = usesDefinePage(await readFile(pageFile, "utf8"));
+		pages.push({
+			...compiled,
+			path: urlPath,
+			isClientPage,
+			id: urlPath,
+			pageFile,
+			layouts: wrappersForPath(layouts, urlPath)
+		});
+	}
+	pages.sort(compareRoutes);
+	const componentFiles = [...await walkFiles(componentsAbs), ...(await walkFiles(join(options.root, "src"))).filter((f) => isNamedComponentFile(toPosix$1(f)))];
+	return {
+		pages,
+		components: [...new Set(componentFiles)].filter((file) => {
+			const rel = toPosix$1(relative(options.root, file));
+			const base = rel.split("/").at(-1) ?? rel;
+			return isPageExt(base) && !isIgnoredPageFile(base);
+		}).sort()
+	};
+}
+function componentId(absFile, root) {
+	return `/${toPosix$1(relative(root, absFile))}`;
+}
+//#endregion
+//#region src/vite/match.ts
+function isSourceDirFile(id, dir) {
+	const file = id.split("?")[0].replaceAll("\\", "/");
+	if (file.includes("/node_modules/")) return false;
+	const prefix = dir.replaceAll("\\", "/").replace(/\/$/, "");
+	return file.includes(`/${prefix}/`) || file.startsWith(`${prefix}/`);
+}
+function isHydratableComponentId(id, componentsDir) {
+	const file = id.split("?")[0].replaceAll("\\", "/");
+	if (file.includes("/node_modules/")) return false;
+	return isHydratableComponentFile(file, componentsDir);
+}
+function isPagesDirFile(id, pagesDir) {
+	return isSourceDirFile(id, pagesDir);
+}
+function isLayoutsDirFile(id, layoutsDir) {
+	return isSourceDirFile(id, layoutsDir);
+}
+function isClientPageModule(id, code, pagesDir) {
+	return isPagesDirFile(id, pagesDir) && usesDefinePage(code);
+}
+//#endregion
+//#region src/vite/hmr.ts
+const VINO_HMR_EVENT = "vino:hmr";
+function hmrAcceptSnippet(kind, id) {
+	return `
+if (import.meta.hot) {
+  import.meta.hot.accept((mod) => {
+    globalThis.__VINO_HMR__?.({ kind: ${JSON.stringify(kind)}, id: ${JSON.stringify(id)}, mod })
+  })
+}
+`;
+}
+function hmrRegistrySnippet(exportName) {
+	return `
+if (import.meta.hot) {
+  import.meta.hot.accept((mod) => {
+    globalThis.__VINO_HMR__?.({ kind: "registry", ${exportName}: mod?.${exportName} })
+  })
+}
+`;
+}
+function classifyHmrFile(file, options) {
+	const posix = file.split("?")[0].replaceAll("\\", "/");
+	if (posix.includes("/node_modules/")) return;
+	if (!isPageExt(posix.split("/").at(-1) ?? posix) && !isServerModuleFile(posix)) return;
+	if (isHydratableComponentFile(posix, options.componentsDir)) return "component";
+	if (isLayoutsDirFile(posix, options.layoutsDir)) return "layout";
+	if (!isPagesDirFile(posix, options.pagesDir)) return;
+	if (isServerModuleFile(posix)) return "ssr";
+	if (new Set([...options.clientPageFiles ?? []].map((entry) => entry.replaceAll("\\", "/"))).has(posix)) return "client-page";
+	return "ssr";
+}
+function clientPageFlagChanged(file, tree, code) {
+	const posix = file.replaceAll("\\", "/");
+	const page = tree?.pages.find((entry) => entry.pageFile.replaceAll("\\", "/") === posix);
+	if (!page) return false;
+	return usesDefinePage(code) !== page.isClientPage;
+}
+//#endregion
+//#region src/vite/server-fn.ts
+const CLIENT_STUB_ERROR = "[vino] server function cannot run on the client";
+function listModuleExports(code) {
+	const named = /* @__PURE__ */ new Set();
+	let hasDefault = /(?:^|[\n\r;])\s*export\s+default\b/.test(code);
+	for (const m of code.matchAll(/\bexport\s+(?:async\s+)?(?:function|class)\s+([A-Za-z_$][\w$]*)/g)) named.add(m[1]);
+	for (const m of code.matchAll(/\bexport\s+(?:const|let|var)\s+([A-Za-z_$][\w$]*)/g)) named.add(m[1]);
+	for (const m of code.matchAll(/\bexport\s*\{([^}]+)\}/g)) for (const part of m[1].split(",")) {
+		const bits = part.trim();
+		if (!bits) continue;
+		const asMatch = /\bas\s+([A-Za-z_$][\w$]*)$/.exec(bits);
+		const name = asMatch ? asMatch[1] : bits.split(/\s+/)[0];
+		if (name === "default") hasDefault = true;
+		else if (name) named.add(name);
+	}
+	return {
+		hasDefault,
+		named: [...named]
+	};
+}
+function stubFn(id) {
+	return `Object.assign(function(){throw new Error(${JSON.stringify(CLIENT_STUB_ERROR)})},{kind:${JSON.stringify(SERVER_FN_KIND)},id:${JSON.stringify(id)}})`;
+}
+/** Replace a `*.server.*` module with client stubs of its exports (implementation stays on the server). */
+function stubServerModule(code, fileId) {
+	const { hasDefault, named } = listModuleExports(code);
+	const lines = [];
+	for (const name of named) lines.push(`export const ${name} = ${stubFn(`${fileId}#${name}`)}`);
+	if (hasDefault || named.length === 0) lines.push(`export default ${stubFn(`${fileId}#default`)}`);
+	return `${lines.join("\n")}\n`;
+}
+function skipQuoted(code, start) {
+	const quote = code[start];
+	let escaped = false;
+	for (let i = start + 1; i < code.length; i++) {
+		const ch = code[i];
+		if (!escaped && ch === quote) return i + 1;
+		escaped = !escaped && ch === "\\";
+	}
+	return code.length;
+}
+function findMatchingParen(code, openIndex) {
+	let depth = 0;
+	for (let i = openIndex; i < code.length; i++) {
+		const ch = code[i];
+		const next = code[i + 1];
+		if (ch === "'" || ch === "\"" || ch === "`") {
+			i = skipQuoted(code, i) - 1;
+			continue;
+		}
+		if (ch === "/" && next === "/") {
+			const nl = code.indexOf("\n", i);
+			if (nl < 0) return -1;
+			i = nl;
+			continue;
+		}
+		if (ch === "/" && next === "*") {
+			const end = code.indexOf("*/", i + 2);
+			if (end < 0) return -1;
+			i = end + 1;
+			continue;
+		}
+		if (ch === "(") depth++;
+		else if (ch === ")") {
+			depth--;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+/** True for the vino runtime that *defines* `defineServerFn`. */
+function isDefineServerFnImplementation(code) {
+	return /(?:^|[^\w$])function\s+defineServerFn\s*\(/.test(code);
+}
+/** Skip transforming this package's dist (and any `defineServerFn` implementation). */
+function skipServerFnTransform(file, code = "") {
+	const normalized = file.replaceAll("\\", "/");
+	if (normalized.includes("/node_modules/")) return true;
+	if (normalized.includes("/vinojs/dist/")) return true;
+	if (/\/dist\/(?:vinojs|client|vite|component-wrap|compile-[^/]+)\.m?js$/.test(normalized)) return true;
+	return isDefineServerFnImplementation(code);
+}
+/**
+* Drop `defineServerFn` implementations from client source so handlers are not bundled.
+* The wrapper stays; later this is where an RPC stub id can be injected.
+*/
+function stripServerFnHandlers(code, fileId = "") {
+	if (!usesDefineServerFn(code) || isDefineServerFnImplementation(code)) return code;
+	let out = "";
+	let last = 0;
+	DEFINE_SERVER_FN_CALL.lastIndex = 0;
+	let match;
+	while (match = DEFINE_SERVER_FN_CALL.exec(code)) {
+		const open = match.index + match[0].length - 1;
+		const close = findMatchingParen(code, open);
+		if (close < 0) break;
+		out += code.slice(last, open + 1);
+		const id = fileId ? JSON.stringify(`${fileId}#fn`) : void 0;
+		const stub = id ? `Object.assign(function(){throw new Error(${JSON.stringify(CLIENT_STUB_ERROR)})},{kind:${JSON.stringify(SERVER_FN_KIND)},id:${id}})` : `function(){throw new Error(${JSON.stringify(CLIENT_STUB_ERROR)})}`;
+		out += stub;
+		last = close;
+		DEFINE_SERVER_FN_CALL.lastIndex = close;
+	}
+	out += code.slice(last);
+	return out;
+}
+//#endregion
+//#region src/vite/plugin.ts
+const RESOLVED = {
+	manifest: `\0${VIRTUAL_MANIFEST}`,
+	components: `\0${VIRTUAL_COMPONENTS}`,
+	assets: `\0${VIRTUAL_ASSETS}`,
+	client: `\0${VIRTUAL_CLIENT}`,
+	clientPages: `\0${VIRTUAL_CLIENT_PAGES}`,
+	ssrHooks: `\0${VIRTUAL_SSR_HOOKS}`
+};
+const WRAP = "?vino-wrap";
+const ORIG = "?vino-orig";
+function applyParams(path, params) {
+	let url = path;
+	for (const [key, value] of Object.entries(params)) url = url.replace(`:${key}`, value);
+	if (!url.startsWith("/")) url = `/${url}`;
+	return url;
+}
+function resolveOptions(options = {}) {
+	return {
+		pagesDir: options.pagesDir ?? "src/pages",
+		layoutsDir: options.layoutsDir ?? "src/layout",
+		componentsDir: options.componentsDir ?? "src/components",
+		entry: options.entry ?? "src/server.ts",
+		prerender: options.prerender ?? "partial",
+		clientRouting: options.clientRouting ?? true,
+		client: options.client
+	};
+}
+function toPosix(p) {
+	return p.replaceAll("\\", "/");
+}
+function importPath(abs) {
+	return JSON.stringify(toPosix(abs));
+}
+function generateManifest(tree, defaults) {
+	const baked = JSON.stringify({
+		clientRouting: defaults.clientRouting === true,
+		prerender: defaults.prerender
+	});
+	return `
+export const manifest = {
+  defaults: ${baked},
+  pages: [${tree.pages.map((page) => {
+		return `{
+      id: ${JSON.stringify(page.id)},
+      path: ${JSON.stringify(page.path)},
+      pattern: ${JSON.stringify(page.pattern)},
+      isClientPage: ${page.isClientPage},
+      isStatic: ${page.isStatic},
+      isCatchAll: ${page.isCatchAll},
+      paramNames: ${JSON.stringify(page.paramNames)},
+      config: ${baked},
+      loadPage: () => import(${importPath(page.pageFile)}),
+      ${page.isClientPage ? `loadClientPage: () => import(${importPath(page.pageFile)}),` : ""}
+      loadLayouts: [${page.layouts.map((f) => `() => import(${importPath(f)})`).join(", ")}],
+    }`;
+	}).join(",\n")}],
+}
+`;
+}
+function generateComponents(tree, root) {
+	return `export const components = {\n${tree.components.map((file) => `${JSON.stringify(componentId(file, root))}: () => import(${importPath(file)})`).join(",\n")}\n}\n`;
+}
+function generateClientPages(tree) {
+	return `export const clientPages = {\n${tree.pages.filter((p) => p.isClientPage).map((p) => `${JSON.stringify(p.path)}: () => import(${importPath(p.pageFile)})`).join(",\n")}\n}\n`;
+}
+function rewriteJsxToDom(code) {
+	return code.replaceAll("hono/jsx/jsx-runtime", "hono/jsx/dom/jsx-runtime").replaceAll("hono/jsx/jsx-dev-runtime", "hono/jsx/dom/jsx-dev-runtime").replaceAll(/from\s*(['"])hono\/jsx\1/g, "from $1hono/jsx/dom$1");
+}
+let cachedTree;
+let cachedRoot;
+async function treeFor(root, resolved) {
+	if (cachedTree && cachedRoot === root) return cachedTree;
+	cachedTree = await crawlPages({
+		root,
+		pagesDir: resolved.pagesDir,
+		componentsDir: resolved.componentsDir,
+		layoutsDir: resolved.layoutsDir
+	});
+	cachedRoot = root;
+	return cachedTree;
+}
+function invalidateTree() {
+	cachedTree = void 0;
+}
+function inWatchedDirs(file, resolved) {
+	const posix = toPosix(file);
+	return [
+		resolved.pagesDir,
+		resolved.layoutsDir,
+		resolved.componentsDir
+	].some((dir) => posix.includes(toPosix(dir)));
+}
+function reloadRouteVirtuals(server) {
+	for (const id of [
+		RESOLVED.manifest,
+		RESOLVED.components,
+		RESOLVED.clientPages
+	]) {
+		const mod = server.moduleGraph.getModuleById(id);
+		if (mod) server.reloadModule(mod);
+	}
+}
+function watchPages(server, resolved) {
+	const dirs = [
+		resolved.pagesDir,
+		resolved.layoutsDir,
+		resolved.componentsDir
+	];
+	for (const dir of dirs) server.watcher.add(join(server.config.root, dir));
+	const onTreeChange = (file) => {
+		if (!inWatchedDirs(file, resolved)) return;
+		invalidateTree();
+		reloadRouteVirtuals(server);
+	};
+	const onChange = (file) => {
+		if (!inWatchedDirs(file, resolved)) return;
+		try {
+			const code = readFileSync(file, "utf8");
+			if (!clientPageFlagChanged(file, cachedTree, code)) return;
+		} catch {
+			return;
+		}
+		invalidateTree();
+		reloadRouteVirtuals(server);
+	};
+	server.watcher.on("add", onTreeChange);
+	server.watcher.on("unlink", onTreeChange);
+	server.watcher.on("change", onChange);
+}
+function notifyBrowserHmr(server, kind) {
+	const client = server.environments.client;
+	setTimeout(() => {
+		client?.hot.send({
+			type: "custom",
+			event: VINO_HMR_EVENT,
+			data: { kind }
+		});
+	}, 0);
+}
+/**
+* Vite plugin: filesystem routes, hydratable components, client entry, and SSG.
+*/
+function vino(options = {}) {
+	const resolved = resolveOptions(options);
+	let config;
+	let command = "serve";
+	const clientScriptSrc = "/assets/vino-client.js";
+	return [
+		{
+			name: "vino:config",
+			config(_cfg, env) {
+				command = env.command;
+				return {
+					resolve: { dedupe: ["hono"] },
+					ssr: { noExternal: ["vinojs", "hono"] },
+					optimizeDeps: { exclude: ["vinojs", "hono"] }
+				};
+			},
+			configEnvironment(name) {
+				if (name === "ssr") return {
+					resolve: { noExternal: ["vinojs", "hono"] },
+					optimizeDeps: { exclude: ["hono"] }
+				};
+				if (name === "client") return { build: { rollupOptions: {
+					input: { "vino-client": VIRTUAL_CLIENT },
+					output: { entryFileNames: (chunk) => {
+						if (chunk.name === "vino-client") return "assets/vino-client.js";
+						return "assets/[name]-[hash].js";
+					} }
+				} } };
+			},
+			configResolved(c) {
+				config = c;
+				const detected = join(c.root, "src/client.ts");
+				if (!resolved.client && existsSync(detected)) resolved.client = detected;
+			},
+			configureServer(server) {
+				watchPages(server, resolved);
+			},
+			hotUpdate({ file, server }) {
+				const kind = classifyHmrFile(file, {
+					pagesDir: resolved.pagesDir,
+					layoutsDir: resolved.layoutsDir,
+					componentsDir: resolved.componentsDir,
+					clientPageFiles: cachedTree?.pages.filter((page) => page.isClientPage).map((page) => page.pageFile)
+				});
+				if (!kind) return;
+				if (kind === "component" || kind === "client-page") return;
+				if (this.environment.name === "client") {
+					if (!server.environments.ssr) notifyBrowserHmr(server, kind);
+					return [];
+				}
+				if (this.environment.name === "ssr") notifyBrowserHmr(server, kind);
+			}
+		},
+		{
+			name: "vino:virtual",
+			resolveId(id) {
+				if (id === "virtual:vino/manifest") return RESOLVED.manifest;
+				if (id === "virtual:vino/components") return RESOLVED.components;
+				if (id === "virtual:vino/assets") return RESOLVED.assets;
+				if (id === "virtual:vino/client") return RESOLVED.client;
+				if (id === "virtual:vino/client-pages") return RESOLVED.clientPages;
+				if (id === "virtual:vino/ssr-hooks") return RESOLVED.ssrHooks;
+			},
+			async load(id) {
+				const root = config?.root ?? process.cwd();
+				const isDev = command === "serve";
+				if (id === RESOLVED.manifest) return generateManifest(await treeFor(root, resolved), {
+					clientRouting: resolved.clientRouting,
+					prerender: resolved.prerender
+				});
+				if (id === RESOLVED.components) {
+					const code = generateComponents(await treeFor(root, resolved), root);
+					return isDev ? `${code}${hmrRegistrySnippet("components")}` : code;
+				}
+				if (id === RESOLVED.clientPages) {
+					const code = generateClientPages(await treeFor(root, resolved));
+					return isDev ? `${code}${hmrRegistrySnippet("clientPages")}` : code;
+				}
+				if (id === RESOLVED.assets) return `export const isDev = ${isDev}\nexport const clientScriptSrc = ${JSON.stringify(isDev ? "/@id/virtual:vino/client" : clientScriptSrc)}\n`;
+				if (id === RESOLVED.ssrHooks) return `
+export function useState(initial) {
+  const value = typeof initial === 'function' ? initial() : initial
+  return [value, () => {}]
+}
+export function useEffect() {}
+export function useLayoutEffect() {}
+export function useInsertionEffect() {}
+export function useCallback(fn) { return fn }
+export function useMemo(fn) { return fn() }
+export function useRef(initial) { return { current: initial } }
+export function useId() { return 'vino-ssr' }
+export function useReducer(reducer, initial) {
+  const value = typeof initial === 'function' ? initial() : initial
+  return [value, () => {}]
+}
+export * from 'hono/jsx'
+`;
+				if (id === RESOLVED.client) {
+					const user = resolved.client;
+					const userAbs = user ? isAbsolute(user) ? user : join(root, user) : void 0;
+					return `${userAbs && existsSync(userAbs) ? `import ${importPath(userAbs)}\n` : ""}import { createClient } from 'vinojs/client'
+const vino = createClient()
+if (import.meta.hot) {
+  import.meta.hot.accept()
+  import.meta.hot.on(${JSON.stringify(VINO_HMR_EVENT)}, (data) => vino.hmr(data))
+}
+`;
+				}
+			}
+		},
+		{
+			name: "vino:server-fn",
+			enforce: "pre",
+			transform(code, id, extra) {
+				if (extra?.ssr) return null;
+				const file = id.split("?")[0].replaceAll("\\", "/");
+				if (skipServerFnTransform(file, code)) return null;
+				if (isServerModuleFile(file)) return {
+					code: stubServerModule(code, file),
+					map: null
+				};
+				if (!usesDefineServerFn(code)) return null;
+				return {
+					code: stripServerFnHandlers(code, file),
+					map: null
+				};
+			}
+		},
+		{
+			name: "vino:components",
+			enforce: "pre",
+			async resolveId(source, importer, extra) {
+				if (source.includes(ORIG)) return source.slice(0, source.indexOf(ORIG));
+				if (source.includes(WRAP) || importer?.includes(WRAP) || importer?.includes(ORIG)) return;
+				if (!importer || !extra?.ssr) return;
+				const next = await this.resolve(source, importer, { skipSelf: true });
+				if (!next) return;
+				const file = next.id.split("?")[0];
+				if (isHydratableComponentId(file, resolved.componentsDir)) return `${file}${WRAP}`;
+			},
+			load(id) {
+				if (!id.includes(WRAP)) return;
+				const file = id.split("?")[0];
+				const cid = componentId(file, config?.root ?? process.cwd());
+				return `
+import Component from ${JSON.stringify(file + ORIG)}
+import { wrapComponent } from 'vinojs/component-wrap'
+export default wrapComponent(Component, ${JSON.stringify(cid)}, 'default')
+`;
+			},
+			async transform(code, id, extra) {
+				const file = id.split("?")[0];
+				const hydratable = isHydratableComponentId(file, resolved.componentsDir);
+				const clientPage = isClientPageModule(id, code, resolved.pagesDir);
+				if (!hydratable && !clientPage) return null;
+				if (extra?.ssr) return {
+					code: code.replaceAll(/from\s*(['"])hono\/jsx(?:\/dom)?\1/g, `from '${VIRTUAL_SSR_HOOKS}'`),
+					map: null
+				};
+				let next = rewriteJsxToDom(code);
+				if (command === "serve") {
+					if (hydratable) next += hmrAcceptSnippet("component", componentId(file, config?.root ?? process.cwd()));
+					else if (clientPage) {
+						const page = (await treeFor(config?.root ?? process.cwd(), resolved)).pages.find((entry) => toPosix(entry.pageFile) === toPosix(file));
+						if (page) next += hmrAcceptSnippet("client-page", page.path);
+					}
+				}
+				return {
+					code: next,
+					map: null
+				};
+			}
+		},
+		{
+			name: "vino:prerender",
+			apply: "build",
+			enforce: "post",
+			async closeBundle() {
+				if (!resolved.prerender) return;
+				const envName = this.environment?.name;
+				if (envName && envName !== "client") return;
+				const root = config.root;
+				try {
+					const ssrOutDir = config.environments?.ssr?.build?.outDir ? isAbsolute(config.environments.ssr.build.outDir) ? config.environments.ssr.build.outDir : join(root, config.environments.ssr.build.outDir) : join(root, "dist", "ssr");
+					const clientOut = config.environments?.client?.build?.outDir ? isAbsolute(config.environments.client.build.outDir) ? config.environments.client.build.outDir : join(root, config.environments.client.build.outDir) : join(root, "dist", "client");
+					const workerMain = join(ssrOutDir, "index.js");
+					if (!existsSync(workerMain)) {
+						console.warn(`[vino] prerender skipped: missing ${workerMain}`);
+						return;
+					}
+					const app = (await import(pathToFileURL(workerMain).href)).default;
+					if (typeof app?.request !== "function") {
+						console.warn("[vino] prerender skipped: worker has no request()");
+						return;
+					}
+					const tree = await treeFor(root, resolved);
+					const viteManifestPath = join(ssrOutDir, ".vite", "manifest.json");
+					const viteManifest = existsSync(viteManifestPath) ? JSON.parse(readFileSync(viteManifestPath, "utf8")) : {};
+					const loadBuilt = async (absFile) => {
+						const rel = toPosix(relative(root, absFile));
+						const chunk = viteManifest[rel] ?? viteManifest[`/${rel}`];
+						if (!chunk?.file) return void 0;
+						return import(pathToFileURL(join(ssrOutDir, chunk.file)).href);
+					};
+					const urls = [];
+					const urlModes = {};
+					for (const page of tree.pages) {
+						const pageMod = await loadBuilt(page.pageFile);
+						const inline = readPageDefinition(pageMod && typeof pageMod === "object" ? pageMod.default : void 0);
+						const pagePrerender = inline?.config?.prerender ?? resolved.prerender;
+						if (pagePrerender === false) continue;
+						const ssgParams = inline?.config?.ssgParams;
+						const mode = pagePrerender === "full" ? "full" : "partial";
+						if (page.isStatic) {
+							const url = page.path;
+							urls.push(url);
+							urlModes[url] = mode;
+						} else if (ssgParams) {
+							const list = await ssgParams();
+							for (const params of list) {
+								const url = applyParams(page.path, params);
+								urls.push(url);
+								urlModes[url] = mode;
+							}
+						}
+					}
+					const result = await prerender({
+						app,
+						pages: [],
+						urls,
+						outDir: clientOut,
+						mode: resolved.prerender,
+						urlModes
+					});
+					if (result.files.length) console.info(`[vino] prerendered ${result.files.length} page(s) → ${clientOut}`);
+				} catch (err) {
+					console.warn("[vino] prerender skipped:", err);
+				}
+			}
+		}
+	];
+}
+//#endregion
+export { vino };
+
+//# sourceMappingURL=vite.mjs.map