rari 0.1.3 → 0.2.0

package/dist/index.js

@@ -1,5 +1,5 @@
 import { HttpRuntimeClient, Link, Navigate, Outlet, RouteComponent, Routes, buildSearchString, buildUrl, createHttpRuntimeClient, extractParamNames, findMatchingRoute, getRoutePriority, isDynamicRoute, isPathActive, joinPaths, normalizePathname, parseSearchParams, parseUrl, router_default, useNavigation, useParams, usePathname, useRoute, useRouter, useSearchParams, withRouter } from "./runtime-client-CC4YQweh.js";
-import { FileRouteGenerator, convertFilePatternToRoutePattern, createRouteManifest, defineRariConfig, generateFileRoutes, loadRouteManifest, rari, rariRouter, validateRoutes, watchFileRoutes } from "./server-BvGV8m79.js";
+import { FileRouteGenerator, convertFilePatternToRoutePattern, createRouteManifest, defineRariConfig, generateFileRoutes, loadRouteManifest, rari, rariRouter, validateRoutes, watchFileRoutes } from "./server-CpI87WFQ.js";
 import "./server-build-DaBgiV55.js";
 
 export { FileRouteGenerator, HttpRuntimeClient, Link, Navigate, Outlet, RouteComponent as Route, router_default as RouterProvider, Routes, 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 };

package/dist/{server-BvGV8m79.js → server-CpI87WFQ.js}

@@ -5683,14 +5683,33 @@ function rari(options = {}) {
 					}
 					if (node.specifiers) for (const specifier of node.specifiers) exportedNames.push(specifier.exported.name);
 					break;
+				case "ExportAllDeclaration":
+					if (node.exported && node.exported.type === "Identifier") exportedNames.push(node.exported.name);
+					break;
 			}
 			return exportedNames;
 		} catch {
 			return [];
 		}
 	}
+	function hasTopLevelDirective(code, directive) {
+		try {
+			const ast = acorn.parse(code, {
+				ecmaVersion: 2024,
+				sourceType: "module",
+				locations: false
+			});
+			for (const node of ast.body) {
+				if (node.type !== "ExpressionStatement" || !node.directive) break;
+				if (node.directive === directive) return true;
+			}
+			return false;
+		} catch {
+			return false;
+		}
+	}
 	function transformServerModule(code, id) {
-		if (!code.includes("use server")) return code;
+		if (!hasTopLevelDirective(code, "use server")) return code;
 		const exportedNames = parseExportedNames(code);
 		if (exportedNames.length === 0) return code;
 		let newCode = code;
@@ -5732,7 +5751,7 @@ if (import.meta.hot) {
 		return newCode;
 	}
 	function transformClientModule(code, id) {
-		if (code.includes("use server")) {
+		if (hasTopLevelDirective(code, "use server")) {
 			const exportedNames$1 = parseExportedNames(code);
 			if (exportedNames$1.length === 0) return "";
 			const relativePath = path.relative(process$1.cwd(), id);
@@ -5742,7 +5761,7 @@ if (import.meta.hot) {
 			else newCode$1 += `export const ${name} = createServerComponentWrapper("${componentId}_${name}", ${JSON.stringify(id)});\n`;
 			return newCode$1;
 		}
-		if (!code.includes("use client")) return code;
+		if (!hasTopLevelDirective(code, "use client")) return code;
 		const exportedNames = parseExportedNames(code);
 		if (exportedNames.length === 0) return "";
 		let newCode = "import {registerClientReference} from \"react-server-dom-rari/server\";\n";
@@ -5763,7 +5782,7 @@ if (import.meta.hot) {
 		return newCode;
 	}
 	function transformClientModuleForClient(code, id) {
-		if (!code.includes("use client")) return code;
+		if (!hasTopLevelDirective(code, "use client")) return code;
 		const exportedNames = parseExportedNames(code);
 		if (exportedNames.length === 0) return code;
 		let newCode = code.replace(/^['"]use client['"];?\s*$/gm, "");
@@ -5809,6 +5828,38 @@ if (import.meta.hot) {
 	const mainPlugin = {
 		name: "rari",
 		config(config, { command }) {
+			config.resolve = config.resolve || {};
+			const existingDedupe = Array.isArray(config.resolve.dedupe) ? config.resolve.dedupe : [];
+			const toAdd = ["react", "react-dom"];
+			config.resolve.dedupe = Array.from(new Set([...existingDedupe || [], ...toAdd]));
+			const existingAlias = Array.isArray(config.resolve.alias) ? config.resolve.alias : [];
+			const aliasFinds = new Set(existingAlias.map((a) => String(a.find)));
+			try {
+				const reactPath = __require.resolve("react");
+				const reactDomClientPath = __require.resolve("react-dom/client");
+				const reactJsxRuntimePath = __require.resolve("react/jsx-runtime");
+				const aliasesToAppend = [];
+				if (!aliasFinds.has("react/jsx-runtime")) aliasesToAppend.push({
+					find: "react/jsx-runtime",
+					replacement: reactJsxRuntimePath
+				});
+				try {
+					const reactJsxDevRuntimePath = __require.resolve("react/jsx-dev-runtime");
+					if (!aliasFinds.has("react/jsx-dev-runtime")) aliasesToAppend.push({
+						find: "react/jsx-dev-runtime",
+						replacement: reactJsxDevRuntimePath
+					});
+				} catch {}
+				if (!aliasFinds.has("react")) aliasesToAppend.push({
+					find: "react",
+					replacement: reactPath
+				});
+				if (!aliasFinds.has("react-dom/client")) aliasesToAppend.push({
+					find: "react-dom/client",
+					replacement: reactDomClientPath
+				});
+				if (aliasesToAppend.length > 0) config.resolve.alias = [...existingAlias, ...aliasesToAppend];
+			} catch {}
 			config.environments = config.environments || {};
 			config.environments.rsc = {
 				resolve: { conditions: [
@@ -5875,19 +5926,19 @@ if (import.meta.hot) {
 		transform(code, id) {
 			if (!/\.(?:tsx?|jsx?)$/.test(id)) return null;
 			const environment = this.environment;
-			if (code.includes("'use client'") || code.includes("\"use client\"")) {
+			if (hasTopLevelDirective(code, "use client")) {
 				componentTypeCache.set(id, "client");
 				clientComponents.add(id);
 				if (environment && (environment.name === "rsc" || environment.name === "ssr")) return transformClientModule(code, id);
 				else return transformClientModuleForClient(code, id);
 			}
-			if (code.includes("'use server'") || code.includes("\"use server\"")) {
+			if (hasTopLevelDirective(code, "use server")) {
 				componentTypeCache.set(id, "server");
 				serverComponents.add(id);
 				if (environment && (environment.name === "rsc" || environment.name === "ssr")) return transformServerModule(code, id);
 				else {
 					let clientTransformedCode = transformClientModule(code, id);
-					if (code.includes("'use server'") || code.includes("\"use server\"")) clientTransformedCode = `// HMR acceptance for server component
+					if (hasTopLevelDirective(code, "use server")) clientTransformedCode = `// HMR acceptance for server component
 if (import.meta.hot) {
   import.meta.hot.accept();
 }
@@ -6455,11 +6506,24 @@ async function loadRscClient() {
 
   rscClientLoadPromise = (async () => {
     try {
-      const rscModule = await import('react-dom/server');
+      const rscModule = await import('react-dom/client');
       createFromFetch = rscModule.createFromFetch;
       createFromReadableStream = rscModule.createFromReadableStream;
+
+      if (typeof createFromReadableStream !== 'function') {
+        console.warn('createFromReadableStream is not available in react-dom/client');
+        createFromReadableStream = null;
+      }
+      if (typeof createFromFetch !== 'function') {
+        console.warn('createFromFetch is not available in react-dom/client');
+        createFromFetch = null;
+      }
+
       return rscModule;
     } catch (error) {
+      console.warn('Failed to load react-dom/client RSC functions:', error);
+      createFromFetch = null;
+      createFromReadableStream = null;
       return null;
     }
   })()
@@ -6471,8 +6535,9 @@ class RscClient {
   constructor() {
     this.componentCache = new Map();
     this.moduleCache = new Map();
+    this.inflightRequests = new Map();
     this.config = {
-      enableStreaming: false,
+      enableStreaming: true,
       maxRetries: 5,
       retryDelay: 500,
       timeout: 10000,
@@ -6495,48 +6560,394 @@ class RscClient {
       return this.componentCache.get(cacheKey);
     }
 
-    const encodedProps = encodeURIComponent(JSON.stringify(props));
-    // Add cache-busting parameter to prevent browser caching issues
-    const cacheBuster = Date.now();
-    const fetchUrl = '/rsc/render/' + componentId + '?props=' + encodedProps + '&_t=' + cacheBuster;
+    if (this.inflightRequests.has(cacheKey)) {
+      return this.inflightRequests.get(cacheKey);
+    }
 
+    let requestPromise;
+    if (this.config.enableStreaming) {
+      requestPromise = this.fetchServerComponentStreamV2(componentId, props);
+    } else {
+      requestPromise = (async () => {
+        const encodedProps = encodeURIComponent(JSON.stringify(props));
+        const cacheBuster = Date.now();
+        const fetchUrl = '/rsc/render/' + componentId + '?props=' + encodedProps + '&_t=' + cacheBuster;
+        await this.waitForServerReady();
+        const response = await this.fetchWithTimeout(fetchUrl, {
+          method: 'GET',
+          headers: {
+            ...this.buildRequestHeaders(),
+            'Cache-Control': 'no-cache, no-store, must-revalidate',
+            'Pragma': 'no-cache',
+            'Expires': '0'
+          },
+        });
+        if (!response.ok) {
+          throw new Error('Server responded with ' + response.status + ': ' + response.statusText);
+        }
+        try {
+          return await this.processRscResponseManually(response);
+        } catch (manualError) {
+          const fallback = await this.processRscResponse(response);
+          return fallback;
+        }
+      })();
+    }
+
+    this.inflightRequests.set(cacheKey, requestPromise);
     try {
-      await this.waitForServerReady();
-
-      const response = await this.fetchWithTimeout(fetchUrl, {
-        method: 'GET',
-        headers: {
-          ...this.buildRequestHeaders(),
-          'Cache-Control': 'no-cache, no-store, must-revalidate',
-          'Pragma': 'no-cache',
-          'Expires': '0'
-        },
-      });
+      const result = await requestPromise;
+      this.componentCache.set(cacheKey, result);
+      return result;
+    } finally {
+      this.inflightRequests.delete(cacheKey);
+    }
 
-      if (!response.ok) {
-        throw new Error('Server responded with ' + response.status + ': ' + response.statusText);
-      }
+  }
 
-      let result;
+  async fetchServerComponentStreamV2(componentId, props = {}) {
+    await loadRscClient();
 
-      try {
-        result = await this.processRscResponseManually(response);
-      } catch (manualError) {
+    const endpoints = (() => {
+      const list = [
+        'http://127.0.0.1:3000/api/rsc/stream',
+        'http://localhost:3000/api/rsc/stream',
+        '/api/rsc/stream',
+      ];
+      return list;
+    })();
+    let response = null;
+    let lastError = null;
+    const attempt = async () => {
+      for (const url of endpoints) {
         try {
-          result = await this.processRscResponse(response);
-        } catch (error) {
-          console.error('Both RSC parsing methods failed:', { manualError, error });
-          throw new Error('Failed to parse RSC response: ' + manualError.message);
+          const r = await this.fetchWithTimeout(url, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              ...this.buildRequestHeaders(),
+            },
+            body: JSON.stringify({ component_id: componentId, props }),
+          });
+          if (r.ok) {
+            return r;
+          }
+          lastError = new Error('HTTP ' + r.status + ': ' + (await r.text()));
+        } catch (e) {
+          lastError = e;
         }
       }
+      return null;
+    };
 
-      this.componentCache.set(cacheKey, result);
-      return result;
-    } catch (error) {
-      throw new Error('Failed to fetch server component ' + componentId + ': ' + error.message);
+    const abortController = new AbortController();
+    const abortTimeout = setTimeout(() => abortController.abort(), this.config.timeout);
+
+    response = await attempt();
+    if (!response) {
+      await new Promise(r => setTimeout(r, 150));
+      response = await attempt();
+    }
+    if (!response) {
+      throw lastError || new Error('Failed to reach stream endpoint');
+    }
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error('Server responded with ' + response.status + ': ' + errorText);
     }
+
+    const stream = response.body;
+    if (!stream) {
+      throw new Error('No ReadableStream from stream response');
+    }
+
+    if (false && createFromReadableStream) {
+      try {
+        const rscPromise = createFromReadableStream(stream);
+        return {
+          _isRscResponse: true,
+          _rscPromise: rscPromise,
+          readRoot() {
+            return rscPromise;
+          }
+        };
+      } catch (error) {
+        console.warn('Failed to use createFromReadableStream:', error);
+      }
+    }
+
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let content = '';
+    const modules = new Map();
+    const boundaryRowMap = new Map();
+
+    const convertRscToReact = (element) => {
+      if (!React) {
+        console.warn('React not available for RSC conversion');
+        return null;
+      }
+
+      if (!element) {
+        return null;
+      }
+
+      if (typeof element === 'string' || typeof element === 'number' || typeof element === 'boolean') {
+        return element;
+      }
+
+      if (Array.isArray(element)) {
+        if (element.length >= 3 && element[0] === '$') {
+          const [, type, key, props] = element;
+
+          if (type === 'react.suspense' || type === 'suspense') {
+
+            const suspenseWrapper = React.createElement('div',
+              {
+                'data-boundary-id': props?.boundaryId,
+                boundaryId: props?.boundaryId,
+                'data-suspense-boundary': true
+              },
+              convertRscToReact(props?.fallback || props?.children)
+            );
+
+            return suspenseWrapper;
+          }
+
+          let processedProps = props ? { ...props } : {};
+          if (props?.children) {
+            const child = convertRscToReact(props.children);
+            if (Array.isArray(child)) {
+              processedProps.children = child.map((c, i) => React.isValidElement(c) ? React.cloneElement(c, { key: (c.key ?? i) }) : c);
+            } else {
+              processedProps.children = child;
+            }
+          }
+
+           if (typeof type === 'string') {
+            if (type.startsWith('$L')) {
+              const mod = modules.get(type);
+              if (mod) {
+                const clientKey = mod.id + '#' + (mod.name || 'default');
+                const clientComponent = getClientComponent(clientKey);
+                if (clientComponent) {
+                  const reactElement = React.createElement(clientComponent, key ? { ...processedProps, key } : processedProps);
+                  return reactElement;
+                }
+              }
+              return processedProps && processedProps.children ? processedProps.children : null;
+            }
+            if (type.includes('.tsx#') || type.includes('.jsx#')) {
+              const clientComponent = getClientComponent(type);
+              if (clientComponent) {
+                const reactElement = React.createElement(clientComponent, key ? { ...processedProps, key } : processedProps);
+                return reactElement;
+              } else {
+                console.warn('Failed to resolve client component:', type);
+                return null;
+              }
+            } else {
+              if (processedProps && Object.prototype.hasOwnProperty.call(processedProps, 'boundaryId')) {
+                const { boundaryId, ...rest } = processedProps;
+                processedProps = rest;
+              }
+              const reactElement = React.createElement(type, key ? { ...processedProps, key } : processedProps);
+              return reactElement;
+            }
+          } else {
+            console.warn('Unknown RSC element type:', type);
+          }
+        }
+
+        return element.map((child, index) => {
+          const converted = convertRscToReact(child);
+          return converted;
+        });
+      }
+
+      if (typeof element === 'object') {
+        console.warn('Unexpected object in RSC conversion:', element);
+        return null;
+      }
+
+      return element;
+    };
+
+    let initialContent = null;
+    let boundaryUpdates = new Map();
+    let isComplete = false;
+    let buffered = '';
+
+    const processStream = async () => {
+      const newlineChar = String.fromCharCode(10);
+
+      try {
+        while (true) {
+          const { value, done } = await reader.read();
+          if (done) {
+            isComplete = true;
+            break;
+          }
+
+          const chunk = decoder.decode(value, { stream: true });
+          buffered += chunk;
+
+          const lines = buffered.split(newlineChar);
+          const completeLines = lines.slice(0, -1);
+          buffered = lines[lines.length - 1];
+
+          for (const line of completeLines) {
+            if (!line.trim()) continue;
+
+            try {
+              const colonIndex = line.indexOf(':');
+              if (colonIndex === -1) continue;
+
+              const rowId = line.substring(0, colonIndex);
+              const content = line.substring(colonIndex + 1);
+
+              if (content.includes('STREAM_COMPLETE')) {
+                isComplete = true;
+              } else if (content.startsWith('I[')) {
+                try {
+                  const importData = JSON.parse(content.substring(1));
+                  if (Array.isArray(importData) && importData.length >= 3) {
+                    const [path, chunks, exportName] = importData;
+                    modules.set('$L' + rowId, {
+                      id: path,
+                      chunks: Array.isArray(chunks) ? chunks : [chunks],
+                      name: exportName || 'default'
+                    });
+                  }
+                } catch (e) {
+                  console.warn('Failed to parse import row:', content, e);
+                }
+              } else if (content.startsWith('E{')) {
+                try {
+                  const err = JSON.parse(content.substring(1));
+                  console.error('RSC stream error:', err);
+                } catch (e) {
+                  console.error('Failed to parse error row:', content, e);
+                }
+              } else if (content.startsWith('Symbol.for(')) {
+                continue;
+              } else if (content.startsWith('[')) {
+                const parsed = JSON.parse(content);
+                if (Array.isArray(parsed) && parsed.length >= 4) {
+                  const [marker, selector, key, props] = parsed;
+                   if (marker === '$' && (selector === 'react.suspense' || selector === 'suspense') && props && props.boundaryId) {
+                    boundaryRowMap.set('$L' + rowId, props.boundaryId);
+                  }
+                  if (marker === '$' && props && Object.prototype.hasOwnProperty.call(props, 'children')) {
+                    if (typeof selector === 'string' && selector.startsWith('$L')) {
+                      const target = boundaryRowMap.get(selector) || null;
+                      if (target) {
+                        const resolvedContent = convertRscToReact(props.children);
+                        boundaryUpdates.set(target, resolvedContent);
+                        if (streamingComponent) {
+                          streamingComponent.updateBoundary(target, resolvedContent);
+                        }
+                        continue;
+                      }
+                    }
+                  }
+                }
+                if (!initialContent) {
+                  let canUseAsRoot = true;
+                  if (Array.isArray(parsed) && parsed.length >= 4 && parsed[0] === '$') {
+                    const sel = parsed[1];
+                    const p = parsed[3];
+                     if (typeof sel === 'string' && (sel === 'react.suspense' || sel === 'suspense') && p && p.boundaryId) {
+                      canUseAsRoot = false;
+                    }
+                  }
+                  if (canUseAsRoot) {
+                    initialContent = convertRscToReact(parsed);
+                    if (streamingComponent && typeof streamingComponent.updateRoot === 'function') {
+                      streamingComponent.updateRoot();
+                    }
+                  }
+                }
+              }
+            } catch (e) {
+              console.warn('Failed to parse stream line:', line, e);
+            }
+          }
+        }
+      } catch (error) {
+        console.error('Error processing stream:', error);
+        isComplete = true;
+      }
+    };
+
+    let streamingComponent = null;
+
+    const StreamingWrapper = () => {
+      const [renderTrigger, setRenderTrigger] = React.useState(0);
+
+      React.useEffect(() => {
+        streamingComponent = {
+          updateBoundary: (boundaryId, resolvedContent) => {
+            boundaryUpdates.set(boundaryId, resolvedContent);
+            setRenderTrigger(prev => prev + 1);
+          },
+          updateRoot: () => {
+            setRenderTrigger(prev => prev + 1);
+          }
+        };
+
+        return () => {
+          streamingComponent = null;
+        };
+      }, []);
+
+      const renderWithBoundaryUpdates = (element) => {
+        if (!element) return null;
+
+        if (React.isValidElement(element)) {
+          if (element.props && element.props.boundaryId) {
+            const boundaryId = element.props.boundaryId;
+            const resolvedContent = boundaryUpdates.get(boundaryId);
+            if (resolvedContent) {
+              return resolvedContent;
+            }
+          }
+
+          if (element.props && element.props.children) {
+            const updatedChildren = renderWithBoundaryUpdates(element.props.children);
+            if (updatedChildren !== element.props.children) {
+              return React.cloneElement(element, { ...element.props, children: updatedChildren });
+            }
+          }
+
+          return element;
+        }
+
+        if (Array.isArray(element)) {
+          return element.map((child, index) => renderWithBoundaryUpdates(child));
+        }
+
+        return element;
+      };
+
+      const renderedContent = renderWithBoundaryUpdates(initialContent);
+      return renderedContent;
+    };
+
+    processStream();
+
+    return {
+      _isRscResponse: true,
+      _rscPromise: Promise.resolve(React.createElement(StreamingWrapper)),
+      readRoot() {
+        return Promise.resolve(React.createElement(StreamingWrapper));
+      }
+    };
   }
 
+
+
   buildRequestHeaders() {
     const headers = {
       'Accept': 'text/x-component',
@@ -6645,11 +7056,14 @@ class RscClient {
 
     let rootElement = null;
 
-    const elementKeys = Array.from(elements.keys()).sort((a, b) => parseInt(b) - parseInt(a));
-
+    const elementKeys = Array.from(elements.keys()).sort((a, b) => parseInt(a) - parseInt(b));
     for (const key of elementKeys) {
       const element = elements.get(key);
-      if (Array.isArray(element) && element[0] === '$') {
+      if (Array.isArray(element) && element.length >= 2 && element[0] === '$') {
+        const [, type, , props] = element;
+        if (type === 'react.suspense' && props && props.boundaryId) {
+          continue;
+        }
         rootElement = element;
         break;
       }
@@ -6678,7 +7092,30 @@ class RscClient {
 
         let actualType = type;
 
-        if (typeof type === 'string' && type.startsWith('$L')) {
+        if (typeof type === 'string' && type.includes('#')) {
+          const clientComponent = getClientComponent(type);
+          if (clientComponent) {
+            actualType = clientComponent;
+          } else {
+            actualType = ({ children, ...restProps }) => React.createElement(
+              'div',
+              {
+                ...restProps,
+                'data-client-component': type,
+                style: {
+                  border: '2px dashed #f00',
+                  padding: '8px',
+                  margin: '4px',
+                  backgroundColor: '#fff0f0'
+                }
+              },
+              React.createElement('small', { style: { color: '#c00' } },
+                'Missing Client Component: ' + type
+              ),
+              children
+            );
+          }
+        } else if (typeof type === 'string' && type.startsWith('$L')) {
           if (modules.has(type)) {
             const moduleData = modules.get(type);
             const clientComponentKey = moduleData.id + '#' + moduleData.name;
@@ -6856,9 +7293,7 @@ function ServerComponentWrapper({
   }, [componentId, JSON.stringify(props)]);
 
   if (loading) {
-    return fallback || React.createElement('div', { className: 'rsc-loading' },
-      'Loading ' + componentId + '...'
-    );
+    return fallback || null;
   }
 
   if (error) {
@@ -6871,7 +7306,7 @@ function ServerComponentWrapper({
     if (data) {
     if (data._isRscResponse) {
       return React.createElement(Suspense,
-        { fallback: fallback || React.createElement('div', null, 'Loading...') },
+        { fallback: fallback || null },
         data.readRoot()
       );
     } else if (data) {
@@ -6919,11 +7354,12 @@ function createServerComponentWrapper(componentName, importPath) {
     }, []);
 
     return React.createElement(Suspense, {
-      fallback: React.createElement('div', null, 'Loading ' + componentName + '...')
+      fallback: null
     }, React.createElement(ServerComponentWrapper, {
       key: componentName + '-' + mountKey, // Force re-mount with key change
       componentId: componentName,
-      props: props
+      props: props,
+      fallback: null
     }));
   };
 

package/dist/server.js

@@ -1,5 +1,5 @@
 import { HttpRuntimeClient, Link, Navigate, Outlet, RouteComponent, Routes, buildSearchString, buildUrl, createHttpRuntimeClient, extractParamNames, findMatchingRoute, getRoutePriority, isDynamicRoute, isPathActive, joinPaths, normalizePathname, parseSearchParams, parseUrl, router_default, useNavigation, useParams, usePathname, useRoute, useRouter, useSearchParams, withRouter } from "./runtime-client-CC4YQweh.js";
-import { FileRouteGenerator, convertFilePatternToRoutePattern, createRouteManifest, defineRariConfig, generateFileRoutes, loadRouteManifest, rari, rariRouter, validateRoutes, watchFileRoutes } from "./server-BvGV8m79.js";
+import { FileRouteGenerator, convertFilePatternToRoutePattern, createRouteManifest, defineRariConfig, generateFileRoutes, loadRouteManifest, rari, rariRouter, validateRoutes, watchFileRoutes } from "./server-CpI87WFQ.js";
 import "./server-build-DaBgiV55.js";
 
 export { FileRouteGenerator, HttpRuntimeClient, Link, Navigate, Outlet, RouteComponent as Route, router_default as RouterProvider, Routes, 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 };