rari 0.1.3

package/dist/server-MY0-nRif.d.ts

@@ -0,0 +1,69 @@
+import { Route, RouteGenerationOptions } from "./runtime-client-BEWMJWMx.js";
+import { Plugin, UserConfig } from "rolldown-vite";
+
+//#region src/router/file-routes.d.ts
+declare class FileRouteGenerator {
+  private pagesDir;
+  private extensions;
+  private routes;
+  private routeTree;
+  constructor(options: RouteGenerationOptions);
+  generateRoutes(): Promise<Route[]>;
+  private scanPagesDirectory;
+  private scanDirectory;
+  private shouldSkipDirectory;
+  private shouldSkipFile;
+  private processFiles;
+  private fileToRoute;
+  private buildRouteTree;
+  private insertRouteIntoTree;
+  private applyLayoutToTree;
+  private establishParentChildRelations;
+  private flattenRouteTree;
+  getRoutes(): Route[];
+  getRouteByPath(path: string): Route | undefined;
+  getRouteByFilePath(filePath: string): Route | undefined;
+  refresh(): Promise<Route[]>;
+}
+declare function generateFileRoutes(options: RouteGenerationOptions): Promise<Route[]>;
+declare function watchFileRoutes(options: RouteGenerationOptions, onChange: (routes: Route[]) => void): () => void;
+declare function createRouteManifest(routes: Route[], outputPath: string): Promise<void>;
+declare function loadRouteManifest(manifestPath: string): Promise<Route[]>;
+declare function validateRoutes(routes: Route[]): {
+  valid: boolean;
+  errors: string[];
+};
+declare function convertFilePatternToRoutePattern(pattern: string): string;
+//#endregion
+//#region src/router/vite-plugin.d.ts
+interface RariRouterPluginOptions {
+  pagesDir?: string;
+  extensions?: string[];
+  outDir?: string;
+  generateTypes?: boolean;
+  validate?: boolean;
+  dev?: boolean;
+  transforms?: Array<(route: Route) => Route>;
+}
+declare function rariRouter(options?: RariRouterPluginOptions): Plugin;
+//#endregion
+//#region src/vite/server-build.d.ts
+interface ServerBuildOptions {
+  outDir?: string;
+  serverDir?: string;
+  manifestPath?: string;
+  minify?: boolean;
+}
+//#endregion
+//#region src/vite/index.d.ts
+interface RariOptions {
+  projectRoot?: string;
+  serverBuild?: ServerBuildOptions;
+  serverHandler?: boolean;
+}
+declare function rari(options?: RariOptions): Plugin[];
+declare function defineRariConfig(config: UserConfig & {
+  plugins?: Plugin[];
+}): UserConfig;
+//#endregion
+export { FileRouteGenerator, convertFilePatternToRoutePattern, createRouteManifest, defineRariConfig, generateFileRoutes, loadRouteManifest, rari, rariRouter, validateRoutes, watchFileRoutes };

package/dist/server-build-Cp6_RdeA.js

@@ -0,0 +1,3 @@
+import { ServerComponentBuilder, createServerBuildPlugin, scanDirectory } from "./server-build-DaBgiV55.js";
+
+export { ServerComponentBuilder, scanDirectory };

package/dist/server-build-DaBgiV55.js

@@ -0,0 +1,618 @@
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { build } from "esbuild";
+
+//#region src/vite/server-build.ts
+var ServerComponentBuilder = class {
+	serverComponents = /* @__PURE__ */ new Map();
+	options;
+	projectRoot;
+	getComponentCount() {
+		return this.serverComponents.size;
+	}
+	constructor(projectRoot, options = {}) {
+		this.projectRoot = projectRoot;
+		this.options = {
+			outDir: options.outDir || path.join(projectRoot, "dist"),
+			serverDir: options.serverDir || "server",
+			manifestPath: options.manifestPath || "server-manifest.json",
+			minify: options.minify ?? process.env.NODE_ENV === "production"
+		};
+	}
+	isServerComponent(filePath) {
+		try {
+			if (!fs.existsSync(filePath)) return false;
+			const code = fs.readFileSync(filePath, "utf-8");
+			const serverDirectives = [
+				"'use server'",
+				"\"use server\"",
+				"/* @server */",
+				"// @server"
+			];
+			const trimmedCode = code.trim();
+			const hasServerDirective = serverDirectives.some((directive) => trimmedCode.startsWith(directive) || code.includes(directive));
+			const isInFunctionsDir = filePath.includes("/functions/") || filePath.includes("\\functions\\");
+			const hasServerFunctionSignature = (code.includes("export async function") || code.includes("export function")) && code.includes("'use server'");
+			const hasNodeImports = code.includes("from 'node:") || code.includes("from \"node:") || code.includes("from 'fs'") || code.includes("from \"fs\"") || code.includes("from 'path'") || code.includes("from \"path\"");
+			const hasAsyncDefaultExport = /export\s+default\s+async\s+function/.test(code);
+			const isServer = hasServerDirective || isInFunctionsDir && hasServerFunctionSignature || hasNodeImports && hasAsyncDefaultExport;
+			return isServer;
+		} catch {
+			return false;
+		}
+	}
+	isClientComponent(filePath) {
+		try {
+			if (!fs.existsSync(filePath)) return false;
+			const code = fs.readFileSync(filePath, "utf-8");
+			const clientDirectives = [
+				"'use client'",
+				"\"use client\"",
+				"/* @client */",
+				"// @client"
+			];
+			const trimmedCode = code.trim();
+			const hasClientDirective = clientDirectives.some((directive) => trimmedCode.startsWith(directive) || code.includes(directive));
+			return hasClientDirective;
+		} catch {
+			return false;
+		}
+	}
+	addServerComponent(filePath) {
+		if (!this.isServerComponent(filePath)) return;
+		const code = fs.readFileSync(filePath, "utf-8");
+		const dependencies = this.extractDependencies(code);
+		const hasNodeImports = this.hasNodeImports(code);
+		this.serverComponents.set(filePath, {
+			filePath,
+			originalCode: code,
+			dependencies,
+			hasNodeImports
+		});
+	}
+	extractDependencies(code) {
+		const dependencies = [];
+		const importRegex = /import(?:\s+(?:\w+|\{[^}]*\}|\*\s+as\s+\w+)(?:\s*,\s*(?:\w+|\{[^}]*\}|\*\s+as\s+\w+))*\s+from\s+)?['"]([^'"]+)['"]/g;
+		let match;
+		while (true) {
+			match = importRegex.exec(code);
+			if (match === null) break;
+			const importPath = match[1];
+			if (!importPath.startsWith(".") && !importPath.startsWith("/") && !importPath.startsWith("node:") && !this.isNodeBuiltin(importPath)) dependencies.push(importPath);
+		}
+		return Array.from(new Set(dependencies));
+	}
+	isNodeBuiltin(moduleName) {
+		const nodeBuiltins = [
+			"fs",
+			"path",
+			"os",
+			"crypto",
+			"util",
+			"stream",
+			"events",
+			"process",
+			"buffer",
+			"url",
+			"querystring",
+			"zlib",
+			"http",
+			"https",
+			"net",
+			"tls",
+			"child_process",
+			"cluster",
+			"worker_threads"
+		];
+		return nodeBuiltins.includes(moduleName);
+	}
+	hasNodeImports(code) {
+		return code.includes("from 'node:") || code.includes("from \"node:") || code.includes("from 'fs'") || code.includes("from \"fs\"") || code.includes("from 'path'") || code.includes("from \"path\"") || code.includes("from 'os'") || code.includes("from \"os\"") || code.includes("from 'crypto'") || code.includes("from \"crypto\"") || code.includes("from 'util'") || code.includes("from \"util\"") || code.includes("from 'stream'") || code.includes("from \"stream\"") || code.includes("from 'events'") || code.includes("from \"events\"");
+	}
+	async getTransformedComponentsForDevelopment() {
+		const components = [];
+		for (const [filePath, component] of this.serverComponents) {
+			const relativePath = path.relative(this.projectRoot, filePath);
+			const componentId = this.getComponentId(relativePath);
+			const transformedCode = await this.buildComponentCodeOnly(filePath, componentId, component);
+			components.push({
+				id: componentId,
+				code: transformedCode
+			});
+		}
+		return components;
+	}
+	async buildComponentCodeOnly(inputPath, componentId, _component) {
+		const originalCode = await fs.promises.readFile(inputPath, "utf-8");
+		const clientTransformedCode = this.transformClientImports(originalCode, inputPath);
+		const transformedCode = this.transformNodeImports(clientTransformedCode);
+		const ext = path.extname(inputPath);
+		let loader;
+		if (ext === ".tsx") loader = "tsx";
+		else if (ext === ".ts") loader = "ts";
+		else if (ext === ".jsx") loader = "jsx";
+		else loader = "js";
+		try {
+			const result = await build({
+				stdin: {
+					contents: transformedCode,
+					resolveDir: path.dirname(inputPath),
+					sourcefile: inputPath,
+					loader
+				},
+				bundle: true,
+				platform: "neutral",
+				target: "es2022",
+				format: "esm",
+				external: [],
+				mainFields: ["module", "main"],
+				conditions: [
+					"import",
+					"module",
+					"default"
+				],
+				define: {
+					"global": "globalThis",
+					"process.env.NODE_ENV": "\"production\""
+				},
+				loader: {
+					".ts": "ts",
+					".tsx": "tsx",
+					".js": "js",
+					".jsx": "jsx"
+				},
+				resolveExtensions: [
+					".ts",
+					".tsx",
+					".js",
+					".jsx"
+				],
+				minify: false,
+				minifyIdentifiers: false,
+				sourcemap: false,
+				metafile: false,
+				write: false,
+				plugins: [{
+					name: "hmr-auto-external",
+					setup(build$1) {
+						build$1.onResolve({ filter: /^[^./]/ }, async (args) => {
+							return {
+								path: args.path,
+								external: true
+							};
+						});
+					}
+				}, {
+					name: "resolve-server-functions",
+					setup(build$1) {
+						build$1.onResolve({ filter: /^\.\.?\/.*functions/ }, async (args) => {
+							const resolvedPath = path.resolve(path.dirname(args.importer), args.path);
+							const possibleExtensions = [
+								".ts",
+								".js",
+								".tsx",
+								".jsx",
+								"/index.ts",
+								"/index.js"
+							];
+							for (const ext$1 of possibleExtensions) {
+								const fullPath = resolvedPath + ext$1;
+								if (fs.existsSync(fullPath)) return { path: fullPath };
+							}
+							return null;
+						});
+					}
+				}],
+				banner: { js: `// Rari Server Component Bundle
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// Original file: ${path.relative(this.projectRoot, inputPath)}
+` }
+			});
+			if (result.outputFiles && result.outputFiles.length > 0) {
+				const outputFile = result.outputFiles[0];
+				const finalTransformedCode = this.createSelfRegisteringModule(outputFile.text, componentId);
+				return finalTransformedCode;
+			}
+			if (result.errors.length > 0) {
+				console.error("ESBuild errors:", result.errors);
+				throw new Error(`ESBuild compilation failed with ${result.errors.length} errors`);
+			}
+			throw new Error("No output generated from ESBuild");
+		} catch (error) {
+			console.error(`ESBuild failed for ${inputPath}:`, error);
+			throw error;
+		}
+	}
+	async buildServerComponents() {
+		const serverOutDir = path.join(this.options.outDir, this.options.serverDir);
+		await fs.promises.mkdir(serverOutDir, { recursive: true });
+		const manifest = {
+			components: {},
+			version: "1.0.0",
+			buildTime: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		for (const [filePath, component] of this.serverComponents) {
+			const relativePath = path.relative(this.projectRoot, filePath);
+			const componentId = this.getComponentId(relativePath);
+			const bundlePath = path.join(this.options.serverDir, `${componentId}.js`);
+			const fullBundlePath = path.join(this.options.outDir, bundlePath);
+			const bundleDir = path.dirname(fullBundlePath);
+			await fs.promises.mkdir(bundleDir, { recursive: true });
+			await this.buildSingleComponent(filePath, fullBundlePath, component);
+			manifest.components[componentId] = {
+				id: componentId,
+				filePath,
+				relativePath,
+				bundlePath,
+				dependencies: component.dependencies,
+				hasNodeImports: component.hasNodeImports
+			};
+		}
+		const manifestPath = path.join(this.options.outDir, this.options.manifestPath);
+		await fs.promises.writeFile(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+		return manifest;
+	}
+	async buildSingleComponent(inputPath, outputPath, _component) {
+		const componentId = this.getComponentId(path.relative(this.projectRoot, inputPath));
+		const originalCode = await fs.promises.readFile(inputPath, "utf-8");
+		const clientTransformedCode = this.transformClientImports(originalCode, inputPath);
+		const transformedCode = this.transformNodeImports(clientTransformedCode);
+		const ext = path.extname(inputPath);
+		let loader;
+		if (ext === ".tsx") loader = "tsx";
+		else if (ext === ".ts") loader = "ts";
+		else if (ext === ".jsx") loader = "jsx";
+		else loader = "js";
+		try {
+			const result = await build({
+				stdin: {
+					contents: transformedCode,
+					resolveDir: path.dirname(inputPath),
+					sourcefile: inputPath,
+					loader
+				},
+				bundle: true,
+				platform: "neutral",
+				target: "es2022",
+				format: "esm",
+				outfile: outputPath,
+				external: [],
+				mainFields: ["module", "main"],
+				conditions: [
+					"import",
+					"module",
+					"default"
+				],
+				define: {
+					"global": "globalThis",
+					"process.env.NODE_ENV": "\"production\""
+				},
+				loader: {
+					".ts": "ts",
+					".tsx": "tsx",
+					".js": "js",
+					".jsx": "jsx"
+				},
+				resolveExtensions: [
+					".ts",
+					".tsx",
+					".js",
+					".jsx"
+				],
+				minify: false,
+				minifyIdentifiers: false,
+				sourcemap: false,
+				metafile: false,
+				write: false,
+				plugins: [{
+					name: "auto-external",
+					setup(build$1) {
+						build$1.onResolve({ filter: /^[^./]/ }, async (args) => {
+							return {
+								path: args.path,
+								external: true
+							};
+						});
+					}
+				}, {
+					name: "resolve-server-functions",
+					setup(build$1) {
+						build$1.onResolve({ filter: /^\.\.?\/.*functions/ }, async (args) => {
+							const resolvedPath = path.resolve(path.dirname(args.importer), args.path);
+							const possibleExtensions = [
+								".ts",
+								".js",
+								".tsx",
+								".jsx",
+								"/index.ts",
+								"/index.js"
+							];
+							for (const ext$1 of possibleExtensions) {
+								const fullPath = resolvedPath + ext$1;
+								if (fs.existsSync(fullPath)) return { path: fullPath };
+							}
+							return null;
+						});
+					}
+				}],
+				banner: { js: `// Rari Server Component Bundle
+// Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
+// Original file: ${path.relative(this.projectRoot, inputPath)}
+` }
+			});
+			if (result.outputFiles && result.outputFiles.length > 0) {
+				const outputFile = result.outputFiles[0];
+				const finalTransformedCode = this.createSelfRegisteringModule(outputFile.text, componentId);
+				await fs.promises.writeFile(outputPath, finalTransformedCode, "utf-8");
+			}
+			if (result.errors.length > 0) {
+				console.error("ESBuild errors:", result.errors);
+				throw new Error(`ESBuild compilation failed with ${result.errors.length} errors`);
+			}
+			if (result.warnings.length > 0) console.warn("ESBuild warnings:", result.warnings);
+		} catch (error) {
+			console.error(`ESBuild failed for ${inputPath}:`, error);
+			throw error;
+		}
+	}
+	createSelfRegisteringModule(code, componentId) {
+		if (code.includes("Self-registering Production Component")) return code;
+		let transformedCode = code;
+		let defaultExportName = null;
+		const namedExports = [];
+		transformedCode = transformedCode.replace(/^export\s+default\s+function\s+(\w+)/gm, (match, name) => {
+			defaultExportName = name;
+			return `function ${name}`;
+		});
+		transformedCode = transformedCode.replace(/^export\s+default\s+async\s+function\s+(\w+)/gm, (match, name) => {
+			defaultExportName = name;
+			return `async function ${name}`;
+		});
+		transformedCode = transformedCode.replace(/^export\s+default\s+(\w+);?\s*$/gm, (match, name) => {
+			defaultExportName = name;
+			return `// Default export: ${name}`;
+		});
+		transformedCode = transformedCode.replace(/^export\s*\{\s*(\w+)\s+as\s+default\s*\};?\s*$/gm, (match, name) => {
+			defaultExportName = name;
+			return `// Default export: ${name}`;
+		});
+		transformedCode = transformedCode.replace(/^export\s*\{([^}]+)\};?\s*$/gm, (match, exports) => {
+			const exportList = exports.split(",").map((exp) => exp.trim());
+			exportList.forEach((exp) => {
+				if (exp.includes("as default")) {
+					const actualName = exp.replace("as default", "").trim();
+					defaultExportName = actualName;
+				} else if (exp === "default") {
+					const possibleDefault = `${componentId}_default`;
+					if (transformedCode.includes(`var ${possibleDefault}`)) defaultExportName = possibleDefault;
+				} else namedExports.push(exp);
+			});
+			return `// Exports: ${exports}`;
+		});
+		transformedCode = transformedCode.replace(/^export\s+(?:async\s+)?function\s+(\w+)/gm, (match, name) => {
+			namedExports.push(name);
+			return match.replace("export ", "");
+		});
+		transformedCode = transformedCode.replace(/^export\s+(const|let|var)\s+(\w+)/gm, (match, keyword, name) => {
+			namedExports.push(name);
+			return `${keyword} ${name}`;
+		});
+		if (!defaultExportName) {
+			const possibleDefault = `${componentId}_default`;
+			if (transformedCode.includes(`var ${possibleDefault}`)) defaultExportName = possibleDefault;
+		}
+		const mainExport = defaultExportName || componentId;
+		const selfRegisteringCode = `// Self-registering Production Component: ${componentId}
+"use module";
+
+// Original component code with exports removed for self-registration
+${transformedCode}
+
+// Self-registration logic
+(function() {
+    try {
+        const moduleKey = "${componentId}";
+        const registrationKey = "Component_${Math.random().toString(36).substr(2, 8)}";
+        let mainExport = null;
+        let exportedFunctions = {};
+
+        globalThis.__rsc_functions = globalThis.__rsc_functions || {};
+
+        // Register named exports
+        ${namedExports.map((name) => `
+        if (typeof ${name} !== 'undefined') {
+            globalThis.${name} = ${name};
+            globalThis.__rsc_functions['${name}'] = ${name};
+            exportedFunctions['${name}'] = ${name};
+        }`).join("")}
+
+        // Set main export
+        if (typeof ${mainExport} !== 'undefined') {
+            mainExport = ${mainExport};
+        } else {
+            const potentialExports = {};
+            ${namedExports.map((name) => `if (typeof ${name} !== 'undefined') potentialExports.${name} = ${name};`).join("\n            ")}
+
+            if (Object.keys(potentialExports).length > 0) {
+                if (Object.keys(potentialExports).length === 1) {
+                    mainExport = potentialExports[Object.keys(potentialExports)[0]];
+                } else {
+                    mainExport = potentialExports;
+                }
+            }
+        }
+
+        if (mainExport !== null) {
+            if (!globalThis[moduleKey]) {
+                globalThis[moduleKey] = mainExport;
+            }
+
+            if (!globalThis[registrationKey]) {
+                globalThis[registrationKey] = mainExport;
+            }
+
+            if (typeof globalThis.RscModuleManager !== 'undefined' && globalThis.RscModuleManager.register) {
+                globalThis.RscModuleManager.register(moduleKey, mainExport, exportedFunctions);
+            }
+        }
+    } catch (error) {
+        console.error('Error in self-registration for ${componentId}:', error);
+    }
+})();`;
+		return selfRegisteringCode;
+	}
+	transformClientImports(code, inputPath) {
+		let transformedCode = code;
+		const importRegex = /import\s+(\w+)(?:\s*,\s*\{[^}]*\})?\s+from\s+['"]([./][^'"]+)['"];?\s*$/gm;
+		let match;
+		const replacements = [];
+		let hasClientComponents = false;
+		while (true) {
+			match = importRegex.exec(code);
+			if (match === null) break;
+			const [fullMatch, defaultImport, importPath] = match;
+			const resolvedPath = this.resolveImportPath(importPath, inputPath);
+			if (this.isClientComponent(resolvedPath)) {
+				hasClientComponents = true;
+				const componentName = defaultImport || "default";
+				const replacement = `const ${componentName} = registerClientReference(
+  null,
+  ${JSON.stringify(path.relative(this.projectRoot, resolvedPath))},
+  "default"
+);`;
+				replacements.push({
+					original: fullMatch,
+					replacement
+				});
+			}
+		}
+		if (hasClientComponents) {
+			const functionDefinition = `
+// registerClientReference function for client components
+function registerClientReference(clientReference, id, exportName) {
+  const key = id + '#' + exportName;
+
+  const clientProxy = {};
+
+  Object.defineProperty(clientProxy, '$$typeof', {
+    value: Symbol.for('react.client.reference'),
+    enumerable: false
+  });
+
+  Object.defineProperty(clientProxy, '$$id', {
+    value: key,
+    enumerable: false
+  });
+
+  Object.defineProperty(clientProxy, '$$async', {
+    value: false,
+    enumerable: false
+  });
+
+  try {
+    if (typeof globalThis.__rari_bridge !== 'undefined' &&
+        typeof globalThis.__rari_bridge.registerClientReference === 'function') {
+      globalThis.__rari_bridge.registerClientReference(key, id, exportName);
+    }
+  } catch (error) {
+    console.error('Failed to register client reference with Rust bridge:', error);
+  }
+
+  return clientProxy;
+}
+
+`;
+			transformedCode = functionDefinition + transformedCode;
+		}
+		for (const { original, replacement } of replacements) transformedCode = transformedCode.replace(original, replacement);
+		return transformedCode;
+	}
+	resolveImportPath(importPath, importerPath) {
+		const resolvedPath = path.resolve(path.dirname(importerPath), importPath);
+		const extensions = [
+			".tsx",
+			".jsx",
+			".ts",
+			".js"
+		];
+		for (const ext of extensions) {
+			const pathWithExt = `${resolvedPath}${ext}`;
+			if (fs.existsSync(pathWithExt)) return pathWithExt;
+		}
+		if (fs.existsSync(resolvedPath)) for (const ext of extensions) {
+			const indexPath = path.join(resolvedPath, `index${ext}`);
+			if (fs.existsSync(indexPath)) return indexPath;
+		}
+		return `${resolvedPath}.tsx`;
+	}
+	transformNodeImports(code) {
+		let transformedCode = code;
+		transformedCode = transformedCode.replace(/import\s+(\w+)\s+from\s+['"]node:process['"];?\s*$/gm, (match, importName) => {
+			return `const ${importName} = globalThis.process;`;
+		});
+		transformedCode = transformedCode.replace(/import\s+\{([^}]+)\}\s+from\s+['"]node:fs['"];?\s*$/gm, (match, imports) => {
+			const importList = imports.split(",").map((imp) => imp.trim());
+			return importList.map((imp) => {
+				const cleanImp = imp.replace(/\s+as\s+\w+/, "");
+				if (cleanImp === "existsSync") return `const ${cleanImp} = (path) => { try { if (globalThis.Deno?.statSync) { globalThis.Deno.statSync(path); return true; } return false; } catch (error) { return false; } };`;
+				if (cleanImp === "readFileSync") return `const ${cleanImp} = (path, encoding = 'utf8') => globalThis.Deno.readTextFileSync(path);`;
+				return `const ${cleanImp} = globalThis.Deno?.${cleanImp} || (() => { throw new Error('${cleanImp} not available'); });`;
+			}).join("\n");
+		});
+		transformedCode = transformedCode.replace(/import\s+\{([^}]+)\}\s+from\s+['"]node:path['"];?\s*$/gm, (match, imports) => {
+			const importList = imports.split(",").map((imp) => imp.trim());
+			return importList.map((imp) => {
+				const cleanImp = imp.replace(/\s+as\s+\w+/, "");
+				if (cleanImp === "join") return `const ${cleanImp} = (...paths) => paths.filter(Boolean).join('/').replace(/\\/+/g, '/');`;
+				return `const ${cleanImp} = globalThis.path?.${cleanImp} || (() => { throw new Error('${cleanImp} not available'); });`;
+			}).join("\n");
+		});
+		transformedCode = transformedCode.replace(/import\s+\{([^}]+)\}\s+from\s+['"]node:process['"];?\s*$/gm, (match, imports) => {
+			const importList = imports.split(",").map((imp) => imp.trim());
+			return importList.map((imp) => {
+				const cleanImp = imp.replace(/\s+as\s+\w+/, "");
+				if (cleanImp === "cwd") return `const ${cleanImp} = () => globalThis.Deno?.cwd?.() || '.';`;
+				return `const ${cleanImp} = globalThis.process?.${cleanImp} || (() => { throw new Error('${cleanImp} not available'); });`;
+			}).join("\n");
+		});
+		return transformedCode;
+	}
+	getComponentId(relativePath) {
+		return relativePath.replace(/\\/g, "/").replace(/\.(tsx?|jsx?)$/, "").replace(/[^\w/-]/g, "_").replace(/^src\//, "").replace(/^components\//, "");
+	}
+};
+function scanDirectory(dir, builder) {
+	const entries = fs.readdirSync(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const fullPath = path.join(dir, entry.name);
+		if (entry.isDirectory()) scanDirectory(fullPath, builder);
+		else if (entry.isFile() && /\.(?:tsx?|jsx?)$/.test(entry.name)) try {
+			if (builder.isServerComponent(fullPath)) builder.addServerComponent(fullPath);
+		} catch (error) {
+			console.warn(`[server-build] Error checking ${fullPath}:`, error instanceof Error ? error.message : error);
+		}
+	}
+}
+function createServerBuildPlugin(options = {}) {
+	let builder = null;
+	let projectRoot;
+	return {
+		name: "rari-server-build",
+		configResolved(config) {
+			projectRoot = config.root;
+			builder = new ServerComponentBuilder(projectRoot, options);
+		},
+		buildStart() {
+			if (!builder) return;
+			const srcDir = path.join(projectRoot, "src");
+			if (fs.existsSync(srcDir)) scanDirectory(srcDir, builder);
+		},
+		async closeBundle() {
+			if (builder) await builder.buildServerComponents();
+		}
+	};
+}
+
+//#endregion
+export { ServerComponentBuilder, createServerBuildPlugin, scanDirectory };

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+import { ErrorBoundaryProps, FileRouteInfo, HttpRuntimeClient, LayoutProps, Link, LinkProps, LoadingProps, Navigate, NavigationOptions, NavigationState, Outlet, PageComponent, PageProps, Route, RouteComponent, RouteGenerationOptions, RouteMatch, RouteMeta, RouteParams, RouterConfig, RouterContext, RouterProvider, RouterProviderProps, Routes, RuntimeClient, SearchParams, buildSearchString, buildUrl, createHttpRuntimeClient, extractParamNames, findMatchingRoute, getRoutePriority, isDynamicRoute, isPathActive, joinPaths, normalizePathname, parseSearchParams, parseUrl, useNavigation, useParams, usePathname, useRoute, useRouter, useSearchParams, withRouter } from "./runtime-client-BEWMJWMx.js";
+import { FileRouteGenerator, convertFilePatternToRoutePattern, createRouteManifest, defineRariConfig, generateFileRoutes, loadRouteManifest, rari, rariRouter, validateRoutes, watchFileRoutes } from "./server-MY0-nRif.js";
+export { ErrorBoundaryProps, FileRouteGenerator, FileRouteInfo, HttpRuntimeClient, LayoutProps, Link, LinkProps, LoadingProps, Navigate, NavigationOptions, NavigationState, Outlet, PageComponent, PageProps, RouteComponent as Route, RouteGenerationOptions, RouteMatch, RouteMeta, RouteParams, Route as RouteType, RouterConfig, RouterContext, RouterProvider, RouterProviderProps, Routes, RuntimeClient, SearchParams, buildSearchString, buildUrl, convertFilePatternToRoutePattern, createHttpRuntimeClient, createRouteManifest, defineRariConfig, extractParamNames, findMatchingRoute, generateFileRoutes, getRoutePriority, isDynamicRoute, isPathActive, joinPaths, loadRouteManifest, normalizePathname, parseSearchParams, parseUrl, rari, rariRouter, useNavigation, useParams, usePathname, useRoute, useRouter, useSearchParams, validateRoutes, watchFileRoutes, withRouter };