@pracht/vite-plugin 0.0.0

package/dist/index.d.mts

@@ -0,0 +1,50 @@
+import { Plugin } from "vite";
+
+//#region src/index.d.ts
+declare const PRACHT_CLIENT_MODULE_ID = "virtual:pracht/client";
+declare const PRACHT_SERVER_MODULE_ID = "virtual:pracht/server";
+/**
+ * An adapter object that bridges pracht's platform-agnostic core to a specific
+ * deployment target.  Built-in adapters are provided by `@pracht/adapter-node`,
+ * `@pracht/adapter-cloudflare`, and `@pracht/adapter-vercel`.  You can also
+ * supply a custom adapter that conforms to this interface.
+ */
+interface PrachtAdapter {
+  /** A short identifier used at build time (e.g. "node", "cloudflare", "vercel"). */
+  id: string;
+  /**
+   * Extra import statements that must appear at the top of the generated
+   * `virtual:pracht/server` module.  Return an empty string if none are needed.
+   */
+  serverImports: string;
+  /**
+   * Returns the JavaScript source code appended to the generated
+   * `virtual:pracht/server` module.  This is where the adapter wires up its
+   * request handler or default export.
+   */
+  createServerEntryModule(): string;
+}
+type RenderMode = "spa" | "ssr" | "ssg" | "isg";
+interface PrachtPluginOptions {
+  appFile?: string;
+  routesDir?: string;
+  shellsDir?: string;
+  middlewareDir?: string;
+  apiDir?: string;
+  serverDir?: string;
+  adapter?: PrachtAdapter;
+  /** Enable file-system pages routing by pointing to the pages directory (e.g. "/src/pages"). */
+  pagesDir?: string;
+  /** Default render mode for pages when RENDER_MODE is not exported. Defaults to "ssr". */
+  pagesDefaultRender?: RenderMode;
+}
+declare function pracht(options?: PrachtPluginOptions): Promise<Plugin[]>;
+declare function createPrachtClientModuleSource(options?: PrachtPluginOptions, buildOptions?: {
+  root?: string;
+}): string;
+declare function createPrachtServerModuleSource(options?: PrachtPluginOptions, buildOptions?: {
+  root?: string;
+}): string;
+declare function createPrachtRegistryModuleSource(options?: PrachtPluginOptions): string;
+//#endregion
+export { PRACHT_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, PrachtAdapter, PrachtPluginOptions, RenderMode, createPrachtClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, pracht };

package/dist/index.mjs

@@ -0,0 +1,382 @@
+import { generatePagesManifestSource, scanPagesDirectory } from "./pages-router.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import preact from "@preact/preset-vite";
+//#region src/index.ts
+const PRACHT_CLIENT_MODULE_ID = "virtual:pracht/client";
+const PRACHT_SERVER_MODULE_ID = "virtual:pracht/server";
+const CLIENT_BROWSER_PATH = "/@pracht/client.js";
+function isClientModule(id) {
+	return id === "virtual:pracht/client" || id === CLIENT_BROWSER_PATH || id.endsWith("virtual:pracht/client");
+}
+function isServerModule(id) {
+	return id === "virtual:pracht/server" || id.endsWith("virtual:pracht/server");
+}
+function createDefaultNodeAdapter() {
+	return {
+		id: "node",
+		serverImports: "import { resolveApp, resolveApiRoutes } from \"@pracht/core\";",
+		createServerEntryModule() {
+			return [
+				"import { existsSync, readFileSync } from \"node:fs\";",
+				"import { createServer } from \"node:http\";",
+				"import { dirname, resolve } from \"node:path\";",
+				"import { fileURLToPath, pathToFileURL } from \"node:url\";",
+				"import { createNodeRequestHandler } from \"@pracht/adapter-node\";",
+				"",
+				"const serverDir = dirname(fileURLToPath(import.meta.url));",
+				"const staticDir = resolve(serverDir, \"../client\");",
+				"const isgManifestPath = resolve(serverDir, \"isg-manifest.json\");",
+				"const isgManifest = existsSync(isgManifestPath)",
+				"  ? JSON.parse(readFileSync(isgManifestPath, \"utf-8\"))",
+				"  : {};",
+				"",
+				"export const handler = createNodeRequestHandler({",
+				"  app: resolvedApp,",
+				"  registry,",
+				"  staticDir,",
+				"  isgManifest,",
+				"  apiRoutes,",
+				"  clientEntryUrl: clientEntryUrl ?? undefined,",
+				"  cssManifest,",
+				"  jsManifest,",
+				"});",
+				"",
+				"const entryHref = process.argv[1] ? pathToFileURL(process.argv[1]).href : null;",
+				"if (entryHref && import.meta.url === entryHref) {",
+				"  const server = createServer(handler);",
+				"  const port = Number(process.env.PORT ?? 3000);",
+				"  server.listen(port, () => {",
+				"    console.log(`pracht node server listening on http://localhost:${port}`);",
+				"  });",
+				"}",
+				""
+			].join("\n");
+		}
+	};
+}
+const DEFAULTS = {
+	appFile: "/src/routes.ts",
+	middlewareDir: "/src/middleware",
+	routesDir: "/src/routes",
+	shellsDir: "/src/shells",
+	apiDir: "/src/api",
+	serverDir: "/src/server",
+	adapter: createDefaultNodeAdapter(),
+	pagesDir: "",
+	pagesDefaultRender: "ssr"
+};
+async function pracht(options = {}) {
+	const resolved = resolveOptions(options);
+	const isPagesMode = !!resolved.pagesDir;
+	let root = process.cwd();
+	if (isPagesMode && options.appFile) console.warn("[pracht] Both `pagesDir` and `appFile` are set. `pagesDir` takes precedence — `appFile` will be ignored.");
+	const prachtPlugin = {
+		name: "pracht",
+		enforce: "pre",
+		config() {
+			return {
+				appType: "custom",
+				build: { rollupOptions: { output: { manualChunks(id) {
+					if (id.includes("node_modules/preact") || id.includes("node_modules/preact-suspense")) return "vendor";
+				} } } }
+			};
+		},
+		configResolved(config) {
+			root = config.root;
+		},
+		resolveId(id) {
+			if (isClientModule(id)) return PRACHT_CLIENT_MODULE_ID;
+			if (isServerModule(id)) return PRACHT_SERVER_MODULE_ID;
+			return null;
+		},
+		load(id) {
+			if (isClientModule(id)) return createPrachtClientModuleSource(resolved, { root });
+			if (isServerModule(id)) return createPrachtServerModuleSource(resolved, { root });
+			return null;
+		},
+		configureServer(server) {
+			if (isPagesMode) {
+				const abs = resolve(root, resolved.pagesDir.slice(1));
+				server.watcher.on("add", (f) => {
+					if (f.startsWith(abs)) server.restart();
+				});
+				server.watcher.on("unlink", (f) => {
+					if (f.startsWith(abs)) server.restart();
+				});
+			}
+			if (resolved.adapter.id === "cloudflare") return;
+			return () => {
+				server.middlewares.use(createDevSSRMiddleware(server, resolved));
+			};
+		},
+		handleHotUpdate({ file, server }) {
+			const root = server.config.root;
+			const relative = file.startsWith(root) ? file.slice(root.length) : file;
+			if (isPagesMode && relative.startsWith(resolved.pagesDir)) {
+				const clientMod = server.moduleGraph.getModuleById(PRACHT_CLIENT_MODULE_ID);
+				const serverMod = server.moduleGraph.getModuleById(PRACHT_SERVER_MODULE_ID);
+				if (clientMod) server.moduleGraph.invalidateModule(clientMod);
+				if (serverMod) server.moduleGraph.invalidateModule(serverMod);
+				return;
+			}
+			if (!isPagesMode && relative === resolved.appFile) {
+				server.restart();
+				return [];
+			}
+			if ([
+				resolved.routesDir,
+				resolved.shellsDir,
+				resolved.middlewareDir,
+				resolved.apiDir,
+				resolved.serverDir
+			].some((dir) => relative.startsWith(dir))) {
+				const serverMod = server.moduleGraph.getModuleById(PRACHT_SERVER_MODULE_ID);
+				if (serverMod) server.moduleGraph.invalidateModule(serverMod);
+			}
+		}
+	};
+	const plugins = [...preact(), prachtPlugin];
+	if (resolved.adapter.id === "cloudflare") {
+		const { cloudflare } = await import("@cloudflare/vite-plugin");
+		plugins.push(...cloudflare({ config: { main: "virtual:pracht/server" } }));
+	}
+	return plugins;
+}
+function createPrachtClientModuleSource(options = {}, buildOptions = {}) {
+	const resolved = resolveOptions(options);
+	const isPagesMode = !!resolved.pagesDir;
+	const appImport = isPagesMode ? generatePagesAppInlineSource(resolved, buildOptions.root) : `import { app } from ${JSON.stringify(resolved.appFile)};`;
+	const routeGlob = isPagesMode ? `${resolved.pagesDir}/**/*.{ts,tsx,js,jsx,md,mdx}` : `${resolved.routesDir}/**/*.{ts,tsx,js,jsx,md,mdx}`;
+	const shellGlob = isPagesMode ? `${resolved.pagesDir}/**/_app.{ts,tsx,js,jsx}` : `${resolved.shellsDir}/**/*.{ts,tsx,js,jsx,md,mdx}`;
+	return [
+		"import { resolveApp, initClientRouter, readHydrationState } from \"@pracht/core\";",
+		appImport,
+		"",
+		`const routeModules = import.meta.glob(${JSON.stringify(routeGlob)});`,
+		`const shellModules = import.meta.glob(${JSON.stringify(shellGlob)});`,
+		"",
+		"const resolvedApp = resolveApp(app);",
+		"",
+		"function findModuleKey(modules, file) {",
+		"  if (file in modules) return file;",
+		"  const suffix = file.replace(/^\\.\\//,\"\");",
+		"  for (const key of Object.keys(modules)) {",
+		"    if (key.endsWith(\"/\" + suffix) || key.endsWith(suffix)) return key;",
+		"  }",
+		"  return null;",
+		"}",
+		"",
+		"const state = readHydrationState();",
+		"const root = document.getElementById(\"pracht-root\");",
+		"if (state && root) {",
+		"  initClientRouter({",
+		"    app: resolvedApp,",
+		"    routeModules,",
+		"    shellModules,",
+		"    initialState: state,",
+		"    root,",
+		"    findModuleKey,",
+		"  });",
+		"}",
+		""
+	].join("\n");
+}
+function createPrachtServerModuleSource(options = {}, buildOptions = {}) {
+	const resolved = resolveOptions(options);
+	const isPagesMode = !!resolved.pagesDir;
+	const registrySource = createPrachtRegistryModuleSource(resolved);
+	const clientBuild = readClientBuildAssets(buildOptions.root);
+	const adapter = resolved.adapter;
+	const source = [
+		adapter?.serverImports ? adapter.serverImports : "import { resolveApp, resolveApiRoutes } from \"@pracht/core\";",
+		isPagesMode ? generatePagesAppInlineSource(resolved, buildOptions.root) : `import { app } from ${JSON.stringify(resolved.appFile)};`,
+		"",
+		registrySource,
+		"",
+		"export const resolvedApp = resolveApp(app);",
+		`export const apiRoutes = resolveApiRoutes(Object.keys(apiModules), ${JSON.stringify(resolved.apiDir)});`,
+		`export const buildTarget = ${JSON.stringify(adapter?.id ?? "node")};`,
+		`export const clientEntryUrl = ${JSON.stringify(clientBuild.clientEntryUrl ?? CLIENT_BROWSER_PATH)};`,
+		`export const cssManifest = ${JSON.stringify(clientBuild.cssManifest)};`,
+		`export const jsManifest = ${JSON.stringify(clientBuild.jsManifest)};`,
+		""
+	];
+	if (adapter) source.push(adapter.createServerEntryModule());
+	return source.join("\n");
+}
+function createPrachtRegistryModuleSource(options = {}) {
+	const resolved = resolveOptions(options);
+	const isPagesMode = !!resolved.pagesDir;
+	const routeGlob = isPagesMode ? `${resolved.pagesDir}/**/*.{ts,tsx,js,jsx,md}` : `${resolved.routesDir}/**/*.{ts,tsx,js,jsx,md}`;
+	const shellGlob = isPagesMode ? `${resolved.pagesDir}/**/_app.{ts,tsx,js,jsx}` : `${resolved.shellsDir}/**/*.{ts,tsx,js,jsx,md}`;
+	return [
+		`export const routeModules = import.meta.glob(${JSON.stringify(routeGlob)});`,
+		`export const shellModules = import.meta.glob(${JSON.stringify(shellGlob)});`,
+		`export const middlewareModules = import.meta.glob(${JSON.stringify(`${resolved.middlewareDir}/**/*.{ts,tsx,js,jsx,md}`)});`,
+		`export const apiModules = import.meta.glob(${JSON.stringify(`${resolved.apiDir}/**/*.{ts,js}`)});`,
+		`export const dataModules = import.meta.glob(${JSON.stringify(`${resolved.serverDir}/**/*.{ts,js}`)});`,
+		"",
+		"export const registry = {",
+		"  routeModules,",
+		"  shellModules,",
+		"  middlewareModules,",
+		"  apiModules,",
+		"  dataModules,",
+		"};"
+	].join("\n");
+}
+function generatePagesAppInlineSource(options, root = process.cwd()) {
+	const absPagesDir = resolve(root, options.pagesDir.slice(1));
+	return generatePagesManifestSource(scanPagesDirectory(absPagesDir), {
+		pagesDir: absPagesDir,
+		pagesDefaultRender: options.pagesDefaultRender,
+		pagesDirPrefix: options.pagesDir
+	});
+}
+function createDevSSRMiddleware(server, _pluginOptions) {
+	return async (req, res, next) => {
+		const url = req.url ?? "/";
+		if (url.includes(".") || url.startsWith("/node_modules/")) return next();
+		try {
+			const [framework, serverMod] = await Promise.all([server.ssrLoadModule("@pracht/core"), server.ssrLoadModule(PRACHT_SERVER_MODULE_ID)]);
+			let webRequest;
+			try {
+				webRequest = await nodeToWebRequest(req);
+			} catch (err) {
+				if (err instanceof Error && err.message === "Request body too large") {
+					res.statusCode = 413;
+					res.end("Payload Too Large");
+					return;
+				}
+				throw err;
+			}
+			const response = await framework.handlePrachtRequest({
+				app: serverMod.resolvedApp,
+				registry: serverMod.registry,
+				request: webRequest,
+				clientEntryUrl: CLIENT_BROWSER_PATH,
+				apiRoutes: serverMod.apiRoutes
+			});
+			if (response.status === 404) return next();
+			const contentType = response.headers.get("content-type") ?? "text/html";
+			let body = await response.text();
+			if (contentType.includes("text/html")) body = await server.transformIndexHtml(url, body);
+			res.statusCode = response.status;
+			response.headers.forEach((value, key) => {
+				res.setHeader(key, value);
+			});
+			res.end(body);
+		} catch (error) {
+			if (error instanceof Error) server.ssrFixStacktrace(error);
+			if (req.headers["x-pracht-route-state-request"] === "1") {
+				res.statusCode = 500;
+				res.setHeader("content-type", "application/json; charset=utf-8");
+				res.end(JSON.stringify({ error: {
+					message: error instanceof Error ? error.message : String(error),
+					name: error instanceof Error ? error.name : "Error",
+					status: 500
+				} }));
+				return;
+			}
+			try {
+				const { buildErrorOverlayHtml } = await server.ssrLoadModule("pracht/error-overlay");
+				let html = buildErrorOverlayHtml({
+					message: error instanceof Error ? error.message : String(error),
+					stack: error instanceof Error ? error.stack : void 0
+				});
+				html = await server.transformIndexHtml(url, html);
+				res.statusCode = 500;
+				res.setHeader("content-type", "text/html; charset=utf-8");
+				res.end(html);
+			} catch {
+				next(error);
+			}
+		}
+	};
+}
+const BODYLESS_METHODS = new Set(["GET", "HEAD"]);
+async function nodeToWebRequest(req) {
+	const protocol = (Array.isArray(req.headers["x-forwarded-proto"]) ? req.headers["x-forwarded-proto"][0] : req.headers["x-forwarded-proto"]) ?? "http";
+	const host = req.headers.host ?? "localhost";
+	const url = new URL(req.url ?? "/", `${protocol}://${host}`);
+	const method = req.method ?? "GET";
+	const headers = new Headers();
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const v of value) headers.append(key, v);
+		else headers.set(key, value);
+	}
+	const init = {
+		method,
+		headers
+	};
+	if (!BODYLESS_METHODS.has(method.toUpperCase())) {
+		const MAX_BODY_SIZE = 1024 * 1024;
+		const chunks = [];
+		let totalSize = 0;
+		for await (const chunk of req) {
+			const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+			totalSize += buf.byteLength;
+			if (totalSize > MAX_BODY_SIZE) {
+				req.destroy();
+				throw new Error("Request body too large");
+			}
+			chunks.push(buf);
+		}
+		const body = Buffer.concat(chunks);
+		if (body.byteLength > 0) init.body = body;
+	}
+	return new Request(url, init);
+}
+function resolveOptions(options) {
+	return {
+		...DEFAULTS,
+		...options
+	};
+}
+function readClientBuildAssets(root = process.cwd()) {
+	const manifestPath = resolve(root, "dist/client/.vite/manifest.json");
+	if (!existsSync(manifestPath)) return {
+		clientEntryUrl: null,
+		cssManifest: {},
+		jsManifest: {}
+	};
+	const rawManifest = readFileSync(manifestPath, "utf-8");
+	const manifest = JSON.parse(rawManifest);
+	const clientEntry = manifest[PRACHT_CLIENT_MODULE_ID];
+	function collectTransitiveDeps(key) {
+		const css = /* @__PURE__ */ new Set();
+		const js = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		function collect(k) {
+			if (visited.has(k)) return;
+			visited.add(k);
+			const entry = manifest[k];
+			if (!entry) return;
+			for (const c of entry.css ?? []) css.add(c);
+			js.add(entry.file);
+			for (const imp of entry.imports ?? []) collect(imp);
+		}
+		collect(key);
+		return {
+			css: [...css],
+			js: [...js]
+		};
+	}
+	const cssManifest = {};
+	const jsManifest = {};
+	for (const [key, entry] of Object.entries(manifest)) {
+		if (!entry.src) continue;
+		const deps = collectTransitiveDeps(key);
+		if (deps.css.length > 0) cssManifest[key] = deps.css.map((f) => `/${f}`);
+		if (deps.js.length > 0) jsManifest[key] = deps.js.map((f) => `/${f}`);
+	}
+	return {
+		clientEntryUrl: clientEntry ? `/${clientEntry.file}` : null,
+		cssManifest,
+		jsManifest
+	};
+}
+//#endregion
+export { PRACHT_CLIENT_MODULE_ID, PRACHT_SERVER_MODULE_ID, createPrachtClientModuleSource, createPrachtRegistryModuleSource, createPrachtServerModuleSource, pracht };

package/dist/pages-router.d.mts

@@ -0,0 +1,23 @@
+//#region src/pages-router.d.ts
+interface ScannedPage {
+  absolutePath: string;
+  relativePath: string;
+  routePath: string;
+  isIndex: boolean;
+  isCatchAll: boolean;
+  isDynamic: boolean;
+  renderMode?: string;
+}
+interface PagesRouterOptions {
+  pagesDir: string;
+  pagesDefaultRender?: string;
+}
+declare function scanPagesDirectory(pagesDir: string): ScannedPage[];
+declare function filePathToRoutePath(relativePath: string): string;
+declare function sortRoutes(pages: ScannedPage[]): ScannedPage[];
+declare function generatePagesManifestSource(pages: ScannedPage[], options: PagesRouterOptions & {
+  pagesDirPrefix?: string;
+}): string;
+declare function generateRoutesFile(pagesDir: string, outputPath: string, options: PagesRouterOptions): void;
+//#endregion
+export { PagesRouterOptions, ScannedPage, filePathToRoutePath, generatePagesManifestSource, generateRoutesFile, scanPagesDirectory, sortRoutes };

package/dist/pages-router.mjs

@@ -0,0 +1,128 @@
+import { readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, extname, join, relative } from "node:path";
+//#region src/pages-router.ts
+const PAGE_EXTENSIONS = new Set([
+	".tsx",
+	".ts",
+	".jsx",
+	".js"
+]);
+function scanPagesDirectory(pagesDir) {
+	const pages = [];
+	scan(pagesDir, pagesDir, pages);
+	return sortRoutes(pages);
+}
+function scan(dir, root, pages) {
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const abs = join(dir, entry);
+		if (statSync(abs).isDirectory()) {
+			scan(abs, root, pages);
+			continue;
+		}
+		const ext = extname(entry);
+		if (!PAGE_EXTENSIONS.has(ext)) continue;
+		const name = basename(entry, ext);
+		if (name.startsWith("_") && name !== "_app") continue;
+		const rel = relative(root, abs);
+		const routePath = filePathToRoutePath(rel);
+		const renderMode = extractRenderMode(readFileSync(abs, "utf-8"));
+		pages.push({
+			absolutePath: abs,
+			relativePath: rel,
+			routePath,
+			isIndex: name === "index",
+			isCatchAll: name.startsWith("[..."),
+			isDynamic: name.startsWith("[") && !name.startsWith("[..."),
+			renderMode
+		});
+	}
+}
+function filePathToRoutePath(relativePath) {
+	let route = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, "");
+	route = route.replace(/\\/g, "/");
+	if (route === "_app" || route.endsWith("/_app")) return "__shell__";
+	if (route === "index") return "/";
+	route = route.replace(/\/index$/, "");
+	route = route.replace(/\[([^\].]+)\]/g, ":$1");
+	route = route.replace(/\[\.\.\.([^\]]+)\]/g, "*");
+	return `/${route}`;
+}
+function sortRoutes(pages) {
+	return [...pages].filter((p) => p.routePath !== "__shell__").sort((a, b) => {
+		if (a.isCatchAll && !b.isCatchAll) return 1;
+		if (!a.isCatchAll && b.isCatchAll) return -1;
+		if (a.isDynamic && !b.isDynamic) return 1;
+		if (!a.isDynamic && b.isDynamic) return -1;
+		return a.routePath.localeCompare(b.routePath);
+	});
+}
+const RENDER_MODE_RE = /export\s+const\s+RENDER_MODE\s*=\s*["'](\w+)["']/;
+function extractRenderMode(source) {
+	const match = RENDER_MODE_RE.exec(source);
+	return match ? match[1] : void 0;
+}
+function generatePagesManifestSource(pages, options) {
+	const pagesDir = options.pagesDir;
+	const defaultRender = options.pagesDefaultRender ?? "ssr";
+	const prefix = options.pagesDirPrefix;
+	const appFile = scanAllFiles(pagesDir).find((f) => basename(f, extname(f)) === "_app" && PAGE_EXTENSIONS.has(extname(f)));
+	const lines = ["import { defineApp, group, route } from \"@pracht/core\";", ""];
+	const routeEntries = [];
+	for (const page of pages) {
+		const render = page.renderMode ?? defaultRender;
+		const filePath = prefix ? `${prefix}/${page.relativePath.replace(/\\/g, "/")}` : `./${page.relativePath.replace(/\\/g, "/")}`;
+		routeEntries.push(`    route(${JSON.stringify(page.routePath)}, ${JSON.stringify(filePath)}, { render: ${JSON.stringify(render)} })`);
+	}
+	if (appFile) {
+		const appPath = prefix ? `${prefix}/_app.${extname(appFile).slice(1)}` : `./${relative(join(pagesDir, ".."), appFile).replace(/\\/g, "/")}`;
+		lines.push("const app = defineApp({");
+		lines.push("  shells: {");
+		lines.push(`    pages: ${JSON.stringify(appPath)},`);
+		lines.push("  },");
+		lines.push("  routes: [");
+		lines.push(`    group({ shell: "pages" }, [`);
+		lines.push(routeEntries.join(",\n"));
+		lines.push("    ]),");
+		lines.push("  ],");
+		lines.push("});");
+	} else {
+		lines.push("const app = defineApp({");
+		lines.push("  routes: [");
+		lines.push(routeEntries.join(",\n"));
+		lines.push("  ],");
+		lines.push("});");
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+function scanAllFiles(dir) {
+	const results = [];
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return results;
+	}
+	for (const entry of entries) {
+		const abs = join(dir, entry);
+		if (statSync(abs).isDirectory()) results.push(...scanAllFiles(abs));
+		else results.push(abs);
+	}
+	return results;
+}
+function generateRoutesFile(pagesDir, outputPath, options) {
+	writeFileSync(outputPath, [
+		"// Auto-generated from pages/ directory by @pracht/vite-plugin.",
+		"// Customize this file and remove `pagesDir` from pracht config to use it directly.",
+		"",
+		generatePagesManifestSource(scanPagesDirectory(pagesDir), options).replace("const app = defineApp(", "export const app = defineApp(")
+	].join("\n"), "utf-8");
+}
+//#endregion
+export { filePathToRoutePath, generatePagesManifestSource, generateRoutesFile, scanPagesDirectory, sortRoutes };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@pracht/vite-plugin",
+  "version": "0.0.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./pages-router": {
+      "types": "./dist/pages-router.d.mts",
+      "default": "./dist/pages-router.mjs"
+    }
+  },
+  "dependencies": {
+    "@preact/preset-vite": "^2.10.5",
+    "@pracht/adapter-cloudflare": "0.0.0",
+    "@pracht/core": "0.0.0",
+    "@pracht/adapter-vercel": "0.0.0"
+  },
+  "peerDependencies": {
+    "@cloudflare/vite-plugin": "^1.0.0",
+    "vite": "^8.0.0",
+    "wrangler": "^4.81.0"
+  },
+  "peerDependenciesMeta": {
+    "@cloudflare/vite-plugin": {
+      "optional": true
+    },
+    "wrangler": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}