rari 0.1.3

package/dist/render-BtA14L2P.js

@@ -0,0 +1,218 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import process from "node:process";
+import colors from "picocolors";
+
+//#region src/deployment/render.ts
+function logInfo(message) {
+	console.warn(`${colors.blue("info")} ${message}`);
+}
+function logSuccess(message) {
+	console.warn(`${colors.green("✓")} ${message}`);
+}
+function logError(message) {
+	console.error(`${colors.red("✗")} ${message}`);
+}
+function logWarning(message) {
+	console.warn(`${colors.yellow("⚠")} ${message}`);
+}
+async function createRenderDeployment() {
+	const cwd = process.cwd();
+	logInfo("Creating Render deployment configuration...");
+	const packageJsonPath = join(cwd, "package.json");
+	if (!existsSync(packageJsonPath)) {
+		logError("No package.json found. Please run this command from your project root.");
+		process.exit(1);
+	}
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+		packageJson.scripts = packageJson.scripts || {};
+		if (packageJson.scripts.start && packageJson.scripts.start !== "rari start") {
+			logWarning(`Existing start script found: "${packageJson.scripts.start}"`);
+			logWarning("Backing up to start:original and replacing with \"rari start\"");
+			packageJson.scripts["start:original"] = packageJson.scripts.start;
+		}
+		packageJson.scripts.start = "rari start";
+		packageJson.scripts["start:local"] = "rari start";
+		packageJson.scripts["deploy:render"] = "echo \"Push to GitHub and connect to Render to deploy\"";
+		packageJson.engines = packageJson.engines || {};
+		if (!packageJson.engines.node) packageJson.engines.node = ">=20.0.0";
+		if (!packageJson.dependencies || !packageJson.dependencies.rari) {
+			logInfo("Adding rari dependency...");
+			packageJson.dependencies = packageJson.dependencies || {};
+			packageJson.dependencies.rari = "^0.1.0";
+		}
+		writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+		logSuccess("Updated package.json for Render deployment");
+	} catch (error) {
+		logError(`Failed to update package.json: ${error instanceof Error ? error.message : "Unknown error"}`);
+		process.exit(1);
+	}
+	const renderConfig = `services:
+  - type: web
+    name: rari-app
+    runtime: node
+    env: node
+    plan: free
+    buildCommand: npm install
+    startCommand: npm start
+    healthCheckPath: /
+    envVars:
+      - key: NODE_ENV
+        value: production
+      - key: RUST_LOG
+        value: info
+`;
+	const renderYamlPath = join(cwd, "render.yaml");
+	if (existsSync(renderYamlPath)) {
+		logWarning("render.yaml already exists, backing up to render.yaml.backup");
+		const existingConfig = readFileSync(renderYamlPath, "utf-8");
+		writeFileSync(join(cwd, "render.yaml.backup"), existingConfig);
+	}
+	writeFileSync(renderYamlPath, renderConfig);
+	logSuccess("Created render.yaml configuration");
+	const gitignorePath = join(cwd, ".gitignore");
+	const renderGitignoreEntries = [
+		"",
+		"# Render",
+		".render/",
+		""
+	].join("\n");
+	if (existsSync(gitignorePath)) {
+		const gitignoreContent = readFileSync(gitignorePath, "utf-8");
+		if (!gitignoreContent.includes(".render/")) {
+			writeFileSync(gitignorePath, gitignoreContent + renderGitignoreEntries);
+			logSuccess("Updated .gitignore with Render entries");
+		}
+	} else {
+		const defaultGitignore = `# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build outputs
+.rari/
+dist/
+
+# Environment variables
+.env
+.env.local
+.env.production
+
+# Render
+.render/
+
+# Logs
+*.log
+npm-debug.log*
+pnpm-debug.log*
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Temporary files
+.tmp/
+tmp/
+`;
+		writeFileSync(gitignorePath, defaultGitignore);
+		logSuccess("Created .gitignore with Render entries");
+	}
+	const readmePath = join(cwd, "README.md");
+	const renderReadmeSection = `
+## 🎨 Deploy to Render
+
+This Rari application is configured for Render deployment.
+
+### Quick Deploy
+
+1. **Push to GitHub**:
+   \`\`\`bash
+   git add .
+   git commit -m "Add Render deployment"
+   git push origin main
+   \`\`\`
+
+2. **Deploy to Render**:
+   - Go to [render.com](https://render.com)
+   - Create new "Web Service"
+   - Connect your GitHub repository
+   - Render will auto-detect Node.js and use the configuration from \`render.yaml\`
+   - Click "Create Web Service"
+
+3. **Your app will be live!** 🎉
+   - Render provides a \`.onrender.com\` URL
+   - Optional: Add custom domain in Render dashboard
+
+### Local Development
+
+\`\`\`bash
+# Development server
+npm run start:local
+
+# Production simulation
+npm start
+\`\`\`
+
+### Environment Variables
+
+Render automatically provides:
+- \`PORT\` - Server port (Render assigns this)
+- \`NODE_ENV=production\` - Production mode (from render.yaml)
+- \`RUST_LOG=info\` - Rust logging level (from render.yaml)
+
+Optional variables you can add in Render dashboard:
+- \`RUST_LOG=debug\` - Enhanced logging
+
+---
+`;
+	if (existsSync(readmePath)) {
+		const readmeContent = readFileSync(readmePath, "utf-8");
+		if (!readmeContent.includes("Deploy to Render")) {
+			writeFileSync(readmePath, readmeContent + renderReadmeSection);
+			logSuccess("Updated README.md with Render deployment instructions");
+		}
+	} else {
+		const defaultReadme = `# My Rari App
+
+A high-performance React Server Components application powered by Rari.
+${renderReadmeSection}
+## Getting Started
+
+\`\`\`bash
+npm install
+npm start
+\`\`\`
+
+Visit [http://localhost:3000](http://localhost:3000) to see your app.
+`;
+		writeFileSync(readmePath, defaultReadme);
+		logSuccess("Created README.md with Render deployment instructions");
+	}
+	console.warn("");
+	logSuccess("Render deployment setup complete! 🎉");
+	console.warn("");
+	logInfo("Next steps:");
+	console.warn(`  1. ${colors.cyan("git add .")}`);
+	console.warn(`  2. ${colors.cyan("git commit -m \"Add Render deployment\"")}`);
+	console.warn(`  3. ${colors.cyan("git push origin main")}`);
+	console.warn(`  4. Go to ${colors.cyan("https://render.com")} and create a Web Service`);
+	console.warn("");
+	logInfo("Your Rari app will automatically:");
+	console.warn("  ✅ Detect Render environment");
+	console.warn("  ✅ Bind to 0.0.0.0 (Render requirement)");
+	console.warn("  ✅ Use Render's PORT environment variable");
+	console.warn("  ✅ Run in production mode");
+	console.warn("  ✅ Download platform-specific Rari binary");
+	console.warn("");
+	logSuccess("Ready for deployment! 🚀");
+}
+
+//#endregion
+export { createRenderDeployment };

package/dist/runtime-client-BEWMJWMx.d.ts

@@ -0,0 +1,283 @@
+import React$1, { ComponentType, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/router/types.d.ts
+interface Route {
+  path: string;
+  filePath: string;
+  component: ComponentType<any> | null;
+  isDynamic: boolean;
+  paramNames: string[];
+  children?: Route[];
+  parent?: Route;
+  isLayout?: boolean;
+  isIndex?: boolean;
+  meta?: RouteMeta;
+}
+interface RouteMeta {
+  title?: string;
+  description?: string;
+  requiresAuth?: boolean;
+  [key: string]: any;
+}
+interface RouteParams {
+  [key: string]: string | string[];
+}
+interface SearchParams {
+  [key: string]: string | string[];
+}
+interface RouteMatch {
+  route: Route;
+  params: RouteParams;
+  searchParams: SearchParams;
+  pathname: string;
+  search: string;
+  hash: string;
+  parentMatches?: RouteMatch[];
+  childMatch?: RouteMatch | null;
+  layouts?: Route[];
+}
+interface NavigationOptions {
+  replace?: boolean;
+  state?: any;
+  scroll?: boolean;
+  scrollPosition?: {
+    x: number;
+    y: number;
+  };
+}
+interface RouterConfig {
+  basePath?: string;
+  useHash?: boolean;
+  caseSensitive?: boolean;
+  notFoundComponent?: ComponentType<any>;
+  loadingComponent?: ComponentType<any>;
+  errorComponent?: ComponentType<{
+    error: Error;
+    retry: () => void;
+  }>;
+}
+interface PageProps {
+  params: RouteParams;
+  searchParams: SearchParams;
+  meta?: RouteMeta;
+}
+type PageComponent<P = Record<string, unknown>> = ComponentType<PageProps & P>;
+interface RouterContext {
+  currentRoute: RouteMatch | null;
+  routes: Route[];
+  navigate: (path: string, options?: NavigationOptions) => void;
+  back: () => void;
+  forward: () => void;
+  replace: (path: string, options?: Omit<NavigationOptions, 'replace'>) => void;
+  isActive: (path: string, exact?: boolean) => boolean;
+  config: RouterConfig;
+}
+interface NavigationState {
+  isNavigating: boolean;
+  destination?: string;
+  error?: Error;
+}
+interface RouteGenerationOptions {
+  pagesDir: string;
+  extensions: string[];
+  transforms?: RouteTransform[];
+}
+type RouteTransform = (route: Route) => Route;
+interface LinkProps {
+  to: string;
+  options?: NavigationOptions;
+  children: ReactNode;
+  className?: string;
+  activeClassName?: string;
+  exact?: boolean;
+  onClick?: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+  [key: string]: any;
+}
+interface RouterProviderProps {
+  config?: RouterConfig;
+  routes?: Route[];
+  children: ReactNode;
+}
+interface UseRouterReturn extends RouterContext {}
+interface UseNavigationReturn extends NavigationState {
+  navigate: RouterContext['navigate'];
+  back: RouterContext['back'];
+  forward: RouterContext['forward'];
+  replace: RouterContext['replace'];
+}
+interface UseRouteReturn {
+  route: RouteMatch | null;
+  params: RouteParams;
+  searchParams: SearchParams;
+  isLoading: boolean;
+  error: Error | null;
+}
+interface FileRouteInfo {
+  filePath: string;
+  routePath: string;
+  isDynamic: boolean;
+  paramNames: string[];
+  isIndex: boolean;
+  isLayout: boolean;
+  isNotFound: boolean;
+}
+interface LayoutProps {
+  children: ReactNode;
+  route: RouteMatch;
+}
+interface ErrorBoundaryProps {
+  error: Error;
+  retry: () => void;
+  route: RouteMatch;
+}
+interface LoadingProps {
+  route: Route;
+  progress?: number;
+}
+//#endregion
+//#region src/router/router.d.ts
+declare const RouterContext$1: React$1.Context<RouterContext | null>;
+declare function RouterProvider({
+  config,
+  routes,
+  children
+}: RouterProviderProps): react_jsx_runtime0.JSX.Element;
+declare function useRouter(): UseRouterReturn;
+declare function useNavigation(): UseNavigationReturn;
+declare function useRoute(): UseRouteReturn;
+declare function useParams(): RouteParams;
+declare function useSearchParams(): readonly [SearchParams, (params: Record<string, string | string[]> | ((prev: Record<string, string | string[]>) => Record<string, string | string[]>), options?: NavigationOptions) => void];
+declare function usePathname(): string;
+declare function withRouter<P extends object>(Component: ComponentType<P & {
+  router: RouterContext;
+}>): {
+  (props: P): react_jsx_runtime0.JSX.Element;
+  displayName: string;
+};
+declare function RouteComponent({
+  path,
+  component: Component,
+  exact,
+  render,
+  children
+}: {
+  path: string;
+  component?: ComponentType<any>;
+  exact?: boolean;
+  render?: (props: {
+    match: RouteMatch | null;
+  }) => ReactNode;
+  children?: ReactNode;
+}): string | number | bigint | boolean | react_jsx_runtime0.JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | React$1.ReactPortal | React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+declare function Routes({
+  children: _children
+}: {
+  children: ReactNode;
+}): react_jsx_runtime0.JSX.Element | null;
+declare function Outlet(): react_jsx_runtime0.JSX.Element | null;
+declare function Navigate({
+  to,
+  replace,
+  state
+}: {
+  to: string;
+  replace?: boolean;
+  state?: any;
+}): null;
+declare function Link({
+  to,
+  children,
+  className,
+  activeClassName,
+  exact,
+  onClick,
+  ...props
+}: {
+  to: string;
+  children: ReactNode;
+  className?: string;
+  activeClassName?: string;
+  exact?: boolean;
+  onClick?: (event: React$1.MouseEvent<HTMLAnchorElement>) => void;
+  [key: string]: any;
+}): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/router/utils.d.ts
+declare function extractParamNames(routePath: string): string[];
+declare function isDynamicRoute(routePath: string): boolean;
+declare function findMatchingRoute(pathname: string, routes: Route[]): RouteMatch | null;
+declare function parseSearchParams(search: string): SearchParams;
+declare function buildSearchString(params: SearchParams): string;
+declare function parseUrl(url: string): {
+  pathname: string;
+  search: string;
+  hash: string;
+  searchParams: SearchParams;
+};
+declare function buildUrl(pathname: string, searchParams?: SearchParams, hash?: string): string;
+declare function isPathActive(pathname: string, routePath: string, exact?: boolean): boolean;
+declare function normalizePathname(pathname: string): string;
+declare function joinPaths(...segments: string[]): string;
+declare function getRoutePriority(route: Route): number;
+//#endregion
+//#region src/runtime-client.d.ts
+interface RuntimeClient {
+  initialize: () => Promise<void>;
+  registerComponent: (componentId: string, componentCode: string) => Promise<void>;
+  renderToRscFormat: (componentId: string, props?: string) => Promise<string>;
+  renderToString: (componentId: string, props?: string) => Promise<string>;
+  renderToStreamCallbacks: (componentId: string, props?: string) => Promise<any>;
+  registerClientComponent: (componentId: string, filePath: string, exportName: string) => void;
+  registerClientReference: (referenceId: string, filePath: string, exportName: string) => void;
+  listComponents: () => string[];
+  shutdown: () => Promise<void>;
+}
+interface HealthResponse {
+  status: string;
+  timestamp: string;
+}
+interface StatusResponse {
+  status: string;
+  mode: string;
+  uptime_seconds: number;
+  request_count: number;
+  components_registered: number;
+  memory_usage?: number;
+}
+declare class HttpRuntimeClient implements RuntimeClient {
+  private baseUrl;
+  private timeout;
+  private components;
+  private initialized;
+  constructor(options?: {
+    host?: string;
+    port?: number;
+    timeout?: number;
+    ssl?: boolean;
+  });
+  private request;
+  initialize(): Promise<void>;
+  registerComponent(componentId: string, componentCode: string): Promise<void>;
+  renderToRscFormat(componentId: string, props?: string): Promise<string>;
+  renderToString(componentId: string, props?: string): Promise<string>;
+  renderToStreamCallbacks(componentId: string, props?: string): Promise<any>;
+  registerClientComponent(componentId: string, filePath: string, exportName: string): void;
+  private queueClientComponentRegistration;
+  registerClientReference(referenceId: string, filePath: string, exportName: string): void;
+  listComponents(): string[];
+  shutdown(): Promise<void>;
+  getServerStatus(): Promise<StatusResponse>;
+  checkHealth(): Promise<HealthResponse>;
+  refreshComponentList(): Promise<string[]>;
+  isInitialized(): boolean;
+  getBaseUrl(): string;
+}
+declare function createHttpRuntimeClient(options?: {
+  host?: string;
+  port?: number;
+  timeout?: number;
+  ssl?: boolean;
+}): RuntimeClient;
+//#endregion
+export { ErrorBoundaryProps, FileRouteInfo, HttpRuntimeClient, LayoutProps, Link, LinkProps, LoadingProps, Navigate, NavigationOptions, NavigationState, Outlet, PageComponent, PageProps, Route, RouteComponent, RouteGenerationOptions, RouteMatch, RouteMeta, RouteParams, RouterConfig, RouterContext$1 as 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 };