raktajs 0.1.2 → 0.1.3

package/dist/cli/rakta.js

@@ -2,7 +2,7 @@
 // @bun
 
 // src/cli/rakta.ts
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // src/config/loadConfig.ts
 import { existsSync } from "fs";
@@ -474,18 +474,225 @@ function printInspectReport(report) {
 }
 
 // src/cli/build.ts
-import { isAbsolute, join as join5 } from "path";
+import { isAbsolute, join as join6 } from "path";
+
+// src/forge/build.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
+
+// src/forge/clientEntry.ts
+import { existsSync as existsSync5, mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join4, relative as relative2 } from "path";
+function toModuleSpecifier(fromFile, targetFile) {
+  const relativePath = relative2(dirname(fromFile), targetFile).replace(/\\/g, "/");
+  if (relativePath.startsWith(".")) {
+    return relativePath;
+  }
+  return `./${relativePath}`;
+}
+function toCssImportSpecifier(entryPath, projectRoot) {
+  const candidates = [
+    join4(projectRoot, "styles", "globals.css"),
+    join4(projectRoot, "styles", "globals.scss"),
+    join4(projectRoot, "styles", "globals.sass")
+  ];
+  const stylePath = candidates.find((candidate) => existsSync5(candidate));
+  if (!stylePath) {
+    return null;
+  }
+  return toModuleSpecifier(entryPath, stylePath);
+}
+function getPageRoutes(manifest) {
+  return manifest.routes.filter((route) => route.kind === "page");
+}
+function buildRouteImports(entryPath, appDir, pageRoutes) {
+  const routeEntries = pageRoutes.map((route) => {
+    const pagePath = join4(appDir, route.filePath);
+    return `  ${JSON.stringify(route.urlPattern)}: () => import("${toModuleSpecifier(entryPath, pagePath)}"),`;
+  }).join(`
+`);
+  return `const routeModules = {
+${routeEntries}
+} as const;`;
+}
+function buildRouteTable(pageRoutes) {
+  const routeEntries = pageRoutes.map((route) => `  ${JSON.stringify(route.urlPattern)}: routeModules[${JSON.stringify(route.urlPattern)}],`).join(`
+`);
+  return `const routes = {
+${routeEntries}
+} as const;`;
+}
+function findExistingModule(basePathWithoutExtension) {
+  const candidates = [".tsx", ".ts", ".jsx", ".js"].map((extension) => `${basePathWithoutExtension}${extension}`);
+  return candidates.find((candidate) => existsSync5(candidate));
+}
+function buildStarterGlobalLoaders(entryPath, appDir) {
+  const mascotPath = findExistingModule(join4(appDir, "components", "raktaShrimpMascot"));
+  const gamePath = findExistingModule(join4(appDir, "components", "shrimpRunGame"));
+  const loaders = [];
+  if (mascotPath !== undefined) {
+    loaders.push(`  const mascotModule = await import("${toModuleSpecifier(entryPath, mascotPath)}");
+  (globalThis as typeof globalThis & Record<string, unknown>).RaktaShrimpMascot = mascotModule.default;`);
+  }
+  if (gamePath !== undefined) {
+    loaders.push(`  const gameModule = await import("${toModuleSpecifier(entryPath, gamePath)}");
+  (globalThis as typeof globalThis & Record<string, unknown>).ShrimpRunGame = gameModule.default;`);
+  }
+  if (loaders.length === 0) {
+    return `async function loadRaktaGlobals(): Promise<void> {
+  return;
+}`;
+  }
+  return `async function loadRaktaGlobals(): Promise<void> {
+${loaders.join(`
+
+`)}
+}`;
+}
+function buildClientEntrySource(options, entryPath) {
+  const pageRoutes = getPageRoutes(options.manifest);
+  const routeModules = buildRouteImports(entryPath, options.appDir, pageRoutes);
+  const routeTable = buildRouteTable(pageRoutes);
+  const cssImportSpecifier = toCssImportSpecifier(entryPath, options.projectRoot);
+  const cssImport = cssImportSpecifier !== null ? `import "${cssImportSpecifier}";
+` : "";
+  const starterGlobalLoaders = buildStarterGlobalLoaders(entryPath, options.appDir);
+  return `import React, { useEffect, useState } from "react";
+import { createRoot } from "react-dom/client";
+import * as ReactHooks from "react";
+${cssImport}
+(globalThis as typeof globalThis & Record<string, unknown>).useCallback = ReactHooks.useCallback;
+(globalThis as typeof globalThis & Record<string, unknown>).useEffect = ReactHooks.useEffect;
+(globalThis as typeof globalThis & Record<string, unknown>).useRef = ReactHooks.useRef;
+(globalThis as typeof globalThis & Record<string, unknown>).useState = ReactHooks.useState;
+
+${starterGlobalLoaders}
+
+await loadRaktaGlobals();
+
+${routeModules}
+
+${routeTable}
+
+type RoutePath = keyof typeof routes;
+type PageModule = { default: React.ComponentType };
+
+function normalizePathname(pathname: string): string {
+  if (pathname.length > 1 && pathname.endsWith("/")) {
+    return pathname.slice(0, -1);
+  }
+
+  return pathname;
+}
+
+function resolveRouteLoader(pathname: string): () => Promise<PageModule> {
+  const normalizedPathname = normalizePathname(pathname) as RoutePath;
+
+  return routes[normalizedPathname] ?? routes["/"];
+}
+
+function navigate(to: string): void {
+  window.history.pushState({ source: "rakta-click", to }, "", to);
+  window.dispatchEvent(new PopStateEvent("popstate", { state: { to } }));
+}
+
+function App(): React.ReactElement {
+  const [pathname, setPathname] = useState(() => window.location.pathname);
+  const [Page, setPage] = useState<React.ComponentType | null>(null);
+
+  useEffect(() => {
+    function handlePopState(): void {
+      setPathname(window.location.pathname);
+    }
+
+    function handleClick(event: MouseEvent): void {
+      const target = event.target;
+
+      if (!(target instanceof Element)) {
+        return;
+      }
+
+      const clickElement = target.closest("click");
+
+      if (!clickElement) {
+        return;
+      }
+
+      const to = clickElement.getAttribute("to");
+
+      if (!to || to.startsWith("http://") || to.startsWith("https://")) {
+        return;
+      }
+
+      event.preventDefault();
+      navigate(to);
+      setPathname(window.location.pathname);
+    }
+
+    window.addEventListener("popstate", handlePopState);
+    document.addEventListener("click", handleClick);
+
+    return () => {
+      window.removeEventListener("popstate", handlePopState);
+      document.removeEventListener("click", handleClick);
+    };
+  }, []);
+
+  useEffect(() => {
+    let isCurrent = true;
+
+    resolveRouteLoader(pathname)().then((pageModule) => {
+      if (isCurrent) {
+        setPage(() => pageModule.default);
+      }
+    });
+
+    return () => {
+      isCurrent = false;
+    };
+  }, [pathname]);
+
+  if (!Page) {
+    return React.createElement("main", {
+      style: {
+        minHeight: "100vh",
+        display: "grid",
+        placeItems: "center",
+        background: "#050505",
+        color: "#f8fafc",
+        fontFamily: "ui-sans-serif, system-ui, sans-serif",
+      },
+    }, "Loading Rakta.js...");
+  }
+
+  return React.createElement(Page);
+}
+
+const rootElement = document.getElementById("rakta-root");
+
+if (!rootElement) {
+  throw new Error("Rakta.js root element #rakta-root was not found.");
+}
+
+createRoot(rootElement).render(React.createElement(App));
+`;
+}
+function writeClientEntry(options) {
+  mkdirSync(options.workDir, { recursive: true });
+  const entryPath = join4(options.workDir, "client-entry.tsx");
+  const entrySource = buildClientEntrySource(options, entryPath);
+  writeFileSync2(entryPath, entrySource, "utf-8");
+  return entryPath;
+}
 
 // src/forge/build.ts
-import { mkdirSync } from "fs";
-import { join as join4, resolve as resolve2 } from "path";
 async function buildProject(options) {
   const startMs = Date.now();
   const artifacts = [];
   const errors = [];
-  mkdirSync(resolve2(options.outDir), { recursive: true });
+  mkdirSync2(resolve2(options.outDir), { recursive: true });
   const manifest = generateManifest(options.appDir);
-  const manifestPath = join4(options.outDir, "route-manifest.json");
+  const manifestPath = join5(options.outDir, "route-manifest.json");
   writeManifest(manifest, manifestPath);
   const manifestContent = JSON.stringify(manifest);
   artifacts.push({
@@ -493,15 +700,21 @@ async function buildProject(options) {
     sizeBytes: new TextEncoder().encode(manifestContent).byteLength,
     kind: "manifest"
   });
+  const entryPoint = existsSync6(options.entryPoint) ? options.entryPoint : writeClientEntry({
+    projectRoot: options.projectRoot,
+    appDir: options.appDir,
+    workDir: join5(options.projectRoot, ".rakta"),
+    manifest
+  });
   const buildResult = await Bun.build({
-    entrypoints: [options.entryPoint],
+    entrypoints: [entryPoint],
     outdir: options.outDir,
     target: options.target,
     minify: options.minify,
     sourcemap: options.sourcemap ? "external" : "none",
     splitting: options.splitting,
     naming: {
-      entry: "[name].[ext]",
+      entry: "app.[ext]",
       chunk: "chunks/[name]-[hash].[ext]",
       asset: "assets/[name]-[hash].[ext]"
     }
@@ -539,7 +752,7 @@ function resolveProjectPath(cwd, pathValue) {
   if (isAbsolute(pathValue)) {
     return pathValue;
   }
-  return join5(cwd, pathValue);
+  return join6(cwd, pathValue);
 }
 async function buildCommand(cwd = process.cwd()) {
   const projectConfig = await loadConfig(cwd);
@@ -547,16 +760,17 @@ async function buildCommand(cwd = process.cwd()) {
   const publicDirectory = projectConfig.publicDir ?? "public";
   const outputDirectory = projectConfig.build.outDir ?? "dist";
   const entryFile = projectConfig.build.entryPoint ?? "entry.client.tsx";
-  const entryPoint = resolveProjectPath(join5(cwd, appDirectory), entryFile);
+  const entryPoint = resolveProjectPath(join6(cwd, appDirectory), entryFile);
   const outDir = resolveProjectPath(cwd, outputDirectory);
   console.log(`
   Building Rakta.js application...
 `);
   const buildResult = await buildProject({
+    projectRoot: cwd,
     entryPoint,
     outDir,
-    appDir: join5(cwd, appDirectory),
-    publicDir: join5(cwd, publicDirectory),
+    appDir: join6(cwd, appDirectory),
+    publicDir: join6(cwd, publicDirectory),
     appName: projectConfig.appName,
     sourcemap: projectConfig.build.sourcemap ?? false,
     minify: projectConfig.build.minify ?? true,
@@ -578,11 +792,11 @@ async function buildCommand(cwd = process.cwd()) {
 }
 
 // src/cli/dev.ts
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 
 // src/forge/devServer.ts
-import { existsSync as existsSync5, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync2, statSync as statSync3 } from "fs";
+import { join as join7 } from "path";
 
 // src/render/renderer.ts
 function buildHtmlShell(options) {
@@ -700,18 +914,55 @@ function resolveDevPort(port) {
   return port > 0 ? port : DEFAULT_DEV_PORT;
 }
 function isReadableFile(filePath) {
-  return existsSync5(filePath) && statSync3(filePath).isFile();
+  return existsSync7(filePath) && statSync3(filePath).isFile();
+}
+async function buildDevClientBundle(options, manifest) {
+  const workDir = join7(options.projectRoot, ".rakta");
+  const clientOutDir = join7(workDir, "dev");
+  const clientEntry = writeClientEntry({
+    projectRoot: options.projectRoot,
+    appDir: options.appDir,
+    workDir,
+    manifest
+  });
+  const buildResult = await Bun.build({
+    entrypoints: [clientEntry],
+    outdir: clientOutDir,
+    target: "browser",
+    sourcemap: "external",
+    naming: {
+      entry: "app.[ext]",
+      chunk: "chunks/[name]-[hash].[ext]",
+      asset: "assets/[name]-[hash].[ext]"
+    }
+  });
+  if (!buildResult.success) {
+    const buildErrors = buildResult.logs.map((buildLog) => buildLog.message).join(`
+`);
+    throw new Error(`Failed to build Rakta.js client bundle.
+${buildErrors}`);
+  }
+  return clientOutDir;
 }
-function startDevServer(options) {
+async function startDevServer(options) {
   const manifest = generateManifest(options.appDir);
   const resolvedPort = resolveDevPort(options.port);
+  const clientOutDir = await buildDevClientBundle(options, manifest);
   const server = Bun.serve({
     port: resolvedPort,
     hostname: options.host,
     async fetch(request) {
       const url = new URL(request.url);
       const { pathname } = url;
-      const publicPath = join6(options.publicDir, pathname);
+      if (clientOutDir.length > 0) {
+        const clientBundlePath = join7(clientOutDir, pathname);
+        if (isReadableFile(clientBundlePath)) {
+          return new Response(readFileSync2(clientBundlePath), {
+            headers: { "Content-Type": resolveMime(clientBundlePath) }
+          });
+        }
+      }
+      const publicPath = join7(options.publicDir, pathname);
       if (isReadableFile(publicPath)) {
         return new Response(readFileSync2(publicPath), {
           headers: { "Content-Type": resolveMime(pathname) }
@@ -719,7 +970,7 @@ function startDevServer(options) {
       }
       const apiMatch = matchRoute(pathname, manifest.routes.filter((route) => route.kind === "api"));
       if (apiMatch) {
-        const modulePath = join6(options.appDir, apiMatch.entry.filePath);
+        const modulePath = join7(options.appDir, apiMatch.entry.filePath);
         const routeModule = await import(modulePath);
         const method = request.method.toUpperCase();
         const handler = routeModule[method];
@@ -747,7 +998,7 @@ function startDevServer(options) {
       }, {
         appName: options.appName,
         scriptPath: "/app.js",
-        cssPath: "/globals.css",
+        cssPath: "/app.css",
         lang: "en"
       });
       if (result.kind === "failure") {
@@ -774,19 +1025,22 @@ async function devCommand(cwd = process.cwd()) {
   console.log(`
   Starting Rakta.js dev server...
 `);
-  startDevServer({
+  const server = await startDevServer({
+    projectRoot: cwd,
     port: config.port,
     host: config.server.hostname ?? "0.0.0.0",
-    appDir: join7(cwd, config.appDir),
-    publicDir: join7(cwd, config.publicDir),
+    appDir: join8(cwd, config.appDir),
+    publicDir: join8(cwd, config.publicDir),
     appName: config.appName,
     renderConfig: config.render
   });
+  console.log(`  Ready at ${server.url}
+`);
 }
 
 // src/cli/doctor.ts
-import { existsSync as existsSync6 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join9 } from "path";
 async function doctorCommand(cwd = process.cwd()) {
   const config = await loadConfig(cwd);
   const checks = [
@@ -797,31 +1051,31 @@ async function doctorCommand(cwd = process.cwd()) {
     },
     {
       label: "rakta.config.ts",
-      passed: existsSync6(join8(cwd, "rakta.config.ts")) || existsSync6(join8(cwd, "rakta.config.js"))
+      passed: existsSync8(join9(cwd, "rakta.config.ts")) || existsSync8(join9(cwd, "rakta.config.js"))
     },
     {
       label: `app/ directory (${config.appDir})`,
-      passed: existsSync6(join8(cwd, config.appDir))
+      passed: existsSync8(join9(cwd, config.appDir))
     },
     {
       label: "app/page.tsx (root page)",
-      passed: existsSync6(join8(cwd, config.appDir, "page.tsx"))
+      passed: existsSync8(join9(cwd, config.appDir, "page.tsx"))
     },
     {
       label: "app/layout.tsx (root layout)",
-      passed: existsSync6(join8(cwd, config.appDir, "layout.tsx"))
+      passed: existsSync8(join9(cwd, config.appDir, "layout.tsx"))
     },
     {
       label: `public/ directory (${config.publicDir})`,
-      passed: existsSync6(join8(cwd, config.publicDir))
+      passed: existsSync8(join9(cwd, config.publicDir))
     },
     {
       label: "package.json",
-      passed: existsSync6(join8(cwd, "package.json"))
+      passed: existsSync8(join9(cwd, "package.json"))
     },
     {
       label: "tsconfig.json",
-      passed: existsSync6(join8(cwd, "tsconfig.json"))
+      passed: existsSync8(join9(cwd, "tsconfig.json"))
     }
   ];
   const sep = "\u2500".repeat(52);
@@ -848,12 +1102,12 @@ async function doctorCommand(cwd = process.cwd()) {
 }
 
 // src/auto-import/generator.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join10 } from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join11 } from "path";
 
 // src/auto-import/scanner.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
-import { basename, extname, join as join9, relative as relative2 } from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync3 } from "fs";
+import { basename, extname, join as join10, relative as relative3 } from "path";
 var DEFAULT_EXTENSIONS = [
   ".ts",
   ".tsx",
@@ -884,12 +1138,12 @@ function toPascalCase(text) {
   return text.replace(/[-_.]/g, " ").replace(/\s+(.)/g, (_match, char) => char.toUpperCase()).replace(/^(.)/, (_match, char) => char.toUpperCase());
 }
 function deriveExportName(filePath, dirPath) {
-  const relativePath = relative2(dirPath, filePath).replace(/\\/g, "/");
+  const relativePath = relative3(dirPath, filePath).replace(/\\/g, "/");
   const withoutExtension = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/\/index$/, "");
   return toPascalCase(withoutExtension.replace(/\//g, "_"));
 }
 function walkDirectory(dirPath, extensions) {
-  if (!existsSync7(dirPath)) {
+  if (!existsSync9(dirPath)) {
     return [];
   }
   const collected = [];
@@ -901,7 +1155,7 @@ function walkDirectory(dirPath, extensions) {
       if (entry.name.startsWith(".") || entry.name === "node_modules") {
         continue;
       }
-      const fullPath = join9(currentPath, entry.name);
+      const fullPath = join10(currentPath, entry.name);
       if (entry.isDirectory()) {
         walk(fullPath);
         continue;
@@ -917,16 +1171,16 @@ function walkDirectory(dirPath, extensions) {
 function scanForExports(options) {
   const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
   const discovered = [];
-  const outputAbs = join9(options.frontendRoot, options.outputDirectory);
+  const outputAbs = join10(options.frontendRoot, options.outputDirectory);
   for (const directory of options.directories) {
-    const directoryAbs = join9(options.frontendRoot, directory);
+    const directoryAbs = join10(options.frontendRoot, directory);
     const files = walkDirectory(directoryAbs, extensions);
     for (const filePath of files) {
-      const relativeFromOutput = relative2(outputAbs, filePath).replace(/\\/g, "/").replace(/\.(ts|tsx)$/, "");
+      const relativeFromOutput = relative3(outputAbs, filePath).replace(/\\/g, "/").replace(/\.(ts|tsx)$/, "");
       const importPath = relativeFromOutput.startsWith(".") ? relativeFromOutput : `./${relativeFromOutput}`;
       discovered.push({
         name: deriveExportName(filePath, directoryAbs),
-        filePath: relative2(options.frontendRoot, filePath).replace(/\\/g, "/"),
+        filePath: relative3(options.frontendRoot, filePath).replace(/\\/g, "/"),
         importPath,
         kind: detectKind(filePath)
       });
@@ -959,17 +1213,17 @@ function generateAutoImports(options) {
       extensions: options.extensions
     } : {}
   });
-  const outputDir = join10(options.frontendRoot, options.outputDirectory);
-  mkdirSync2(outputDir, {
+  const outputDir = join11(options.frontendRoot, options.outputDirectory);
+  mkdirSync3(outputDir, {
     recursive: true
   });
   const tsContent = `${GENERATED_HEADER}
 ${buildImportLines(exports)}
 `;
-  writeFileSync2(join10(outputDir, "auto-imports.ts"), tsContent, "utf-8");
+  writeFileSync3(join11(outputDir, "auto-imports.ts"), tsContent, "utf-8");
   if (options.generateDts) {
     const dtsContent = tsContent.replace("// This file is auto-generated by: bun rakta imports:generate", "// Type declarations \u2014 auto-generated by: bun rakta imports:generate");
-    writeFileSync2(join10(outputDir, "auto-imports.d.ts"), dtsContent, "utf-8");
+    writeFileSync3(join11(outputDir, "auto-imports.d.ts"), dtsContent, "utf-8");
   }
   return {
     generatedAt: new Date().toISOString(),
@@ -1011,18 +1265,18 @@ async function importsGenerateCommand(cwd = process.cwd()) {
 }
 
 // src/cli/make.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { dirname, join as join11 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname2, join as join12 } from "path";
 function toPascalCase2(name) {
   return name.split(/[-_/]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
 }
 function writeIfNew(filePath, content) {
-  if (existsSync8(filePath)) {
+  if (existsSync10(filePath)) {
     console.warn(`  Already exists: ${filePath}`);
     return;
   }
-  mkdirSync3(dirname(filePath), { recursive: true });
-  writeFileSync3(filePath, content, "utf-8");
+  mkdirSync4(dirname2(filePath), { recursive: true });
+  writeFileSync4(filePath, content, "utf-8");
   console.log(`  Created: ${filePath}`);
 }
 function getRelativeFilePath(filePath, cwd) {
@@ -1030,11 +1284,11 @@ function getRelativeFilePath(filePath, cwd) {
 }
 async function makeCommand(target, name, cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const appDir = join11(cwd, config.appDir);
+  const appDir = join12(cwd, config.appDir);
   const componentName = toPascalCase2(name);
   switch (target) {
     case "page": {
-      const filePath = join11(appDir, name, "page.tsx");
+      const filePath = join12(appDir, name, "page.tsx");
       writeIfNew(filePath, `// ${getRelativeFilePath(filePath, cwd)}
 import React from "react";
 import type { Metadata } from "rakta/seo";
@@ -1054,7 +1308,7 @@ export default function ${componentName}Page() {
       break;
     }
     case "layout": {
-      const filePath = join11(appDir, name, "layout.tsx");
+      const filePath = join12(appDir, name, "layout.tsx");
       writeIfNew(filePath, `// ${getRelativeFilePath(filePath, cwd)}
 import React from "react";
 import type { LayoutProps } from "rakta/router";
@@ -1066,7 +1320,7 @@ export default function ${componentName}Layout({ children }: LayoutProps) {
       break;
     }
     case "component": {
-      const filePath = join11(cwd, "components", "ui", `${componentName}.tsx`);
+      const filePath = join12(cwd, "components", "ui", `${componentName}.tsx`);
       writeIfNew(filePath, `// components/ui/${componentName}.tsx
 import React from "react";
 
@@ -1084,7 +1338,7 @@ export default ${componentName};
       break;
     }
     case "api": {
-      const filePath = join11(appDir, "api", name, "route.ts");
+      const filePath = join12(appDir, "api", name, "route.ts");
       writeIfNew(filePath, `// ${getRelativeFilePath(filePath, cwd)}
 import type { RouteContext } from "rakta/router";
 
@@ -1098,23 +1352,23 @@ export async function GET(_request: Request, context: RouteContext): Promise<Res
 }
 
 // src/cli/routes.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 async function routesCommand(cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const appDir = join12(cwd, config.appDir);
+  const appDir = join13(cwd, config.appDir);
   const manifest = generateManifest(appDir);
   printManifest(manifest);
 }
 
 // src/cli/rpcTypes.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join13 } from "path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join14 } from "path";
 async function rpcTypesCommand(cwd = process.cwd()) {
-  const sharedTypesDir = join13(cwd, "..", "shared", "types");
-  if (!existsSync9(sharedTypesDir)) {
-    mkdirSync4(sharedTypesDir, { recursive: true });
+  const sharedTypesDir = join14(cwd, "..", "shared", "types");
+  if (!existsSync11(sharedTypesDir)) {
+    mkdirSync5(sharedTypesDir, { recursive: true });
   }
-  const outputPath = join13(sharedTypesDir, "rpc.ts");
+  const outputPath = join14(sharedTypesDir, "rpc.ts");
   const content = `// shared/types/rpc.ts
 // Auto-generated by: bun rakta rpc:types
 // Re-exports AppRouter type from the backend for type-safe frontend RPC calls.
@@ -1122,7 +1376,7 @@ async function rpcTypesCommand(cwd = process.cwd()) {
 
 export type { AppRouter } from "../../backend/src/rpc/router.js";
 `;
-  writeFileSync4(outputPath, content, "utf-8");
+  writeFileSync5(outputPath, content, "utf-8");
   console.log(`
   Generated: shared/types/rpc.ts
 `);
@@ -1132,16 +1386,16 @@ export type { AppRouter } from "../../backend/src/rpc/router.js";
 }
 
 // src/cli/seo.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync6, writeFileSync as writeFileSync6 } from "fs";
+import { join as join15 } from "path";
 async function seoGenerateCommand(cwd = process.cwd()) {
   const config = await loadConfig(cwd);
-  const appDir = join14(cwd, config.appDir);
-  const sitemapDir = join14(appDir, "api", "sitemap.xml");
-  const robotsDir = join14(appDir, "api", "robots.txt");
-  if (!existsSync10(sitemapDir)) {
-    mkdirSync5(sitemapDir, { recursive: true });
-    writeFileSync5(join14(sitemapDir, "route.ts"), `// app/api/sitemap.xml/route.ts \u2014 generated by: bun rakta seo:generate
+  const appDir = join15(cwd, config.appDir);
+  const sitemapDir = join15(appDir, "api", "sitemap.xml");
+  const robotsDir = join15(appDir, "api", "robots.txt");
+  if (!existsSync12(sitemapDir)) {
+    mkdirSync6(sitemapDir, { recursive: true });
+    writeFileSync6(join15(sitemapDir, "route.ts"), `// app/api/sitemap.xml/route.ts \u2014 generated by: bun rakta seo:generate
 import { createSitemapHandler } from "rakta/seo";
 
 export const GET = createSitemapHandler({
@@ -1156,9 +1410,9 @@ export const GET = createSitemapHandler({
   } else {
     console.warn("  Already exists: app/api/sitemap.xml/route.ts");
   }
-  if (!existsSync10(robotsDir)) {
-    mkdirSync5(robotsDir, { recursive: true });
-    writeFileSync5(join14(robotsDir, "route.ts"), `// app/api/robots.txt/route.ts \u2014 generated by: bun rakta seo:generate
+  if (!existsSync12(robotsDir)) {
+    mkdirSync6(robotsDir, { recursive: true });
+    writeFileSync6(join15(robotsDir, "route.ts"), `// app/api/robots.txt/route.ts \u2014 generated by: bun rakta seo:generate
 import { createRobotsHandler } from "rakta/seo";
 
 export const GET = createRobotsHandler({
@@ -1182,11 +1436,11 @@ export const GET = createRobotsHandler({
 }
 
 // src/cli/start.ts
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 
 // src/tide/adapter.ts
-import { existsSync as existsSync11, readFileSync as readFileSync3, statSync as statSync4 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync3, statSync as statSync4 } from "fs";
+import { join as join16 } from "path";
 // src/tide/runtime.ts
 function createRuntimeContext(request, url, params, resolvedMode) {
   const searchParams = {};
@@ -1257,7 +1511,7 @@ function normalizeStaticPath(pathname) {
   return "index.html";
 }
 function isReadableFile2(filePath) {
-  return existsSync11(filePath) && statSync4(filePath).isFile();
+  return existsSync13(filePath) && statSync4(filePath).isFile();
 }
 function isApiRouteExports(value) {
   if (typeof value !== "object" || value === null) {
@@ -1298,7 +1552,7 @@ function createBunAdapter(adapterConfig, renderConfig) {
     const { pathname } = url;
     const staticPathname = normalizeStaticPath(pathname);
     for (const searchDirectory of searchDirectories) {
-      const filePath = join15(searchDirectory, staticPathname);
+      const filePath = join16(searchDirectory, staticPathname);
       if (isReadableFile2(filePath)) {
         return new Response(readFileSync3(filePath), {
           headers: {
@@ -1311,7 +1565,7 @@ function createBunAdapter(adapterConfig, renderConfig) {
     const apiRoutes = manifest.routes.filter((route) => route.kind === "api");
     const apiMatch = matchRoute(pathname, apiRoutes);
     if (apiMatch) {
-      const modulePath = join15(adapterConfig.appDir, apiMatch.entry.filePath);
+      const modulePath = join16(adapterConfig.appDir, apiMatch.entry.filePath);
       const routeModule = await import(modulePath);
       if (!isApiRouteExports(routeModule)) {
         return new Response("Invalid API route module", {
@@ -1338,7 +1592,7 @@ function createBunAdapter(adapterConfig, renderConfig) {
     }, {
       appName: adapterConfig.appName,
       scriptPath: "/app.js",
-      cssPath: "/globals.css",
+      cssPath: "/app.css",
       lang: "en"
     });
     if (renderResult.kind === "failure") {
@@ -1378,9 +1632,9 @@ async function startCommand(cwd = process.cwd()) {
     port: projectConfig.port,
     host: projectConfig.server.hostname ?? "0.0.0.0",
     appName: projectConfig.appName,
-    appDir: join16(cwd, projectConfig.appDir),
-    publicDir: join16(cwd, projectConfig.publicDir),
-    outDir: join16(cwd, outputDirectory)
+    appDir: join17(cwd, projectConfig.appDir),
+    publicDir: join17(cwd, projectConfig.publicDir),
+    outDir: join17(cwd, outputDirectory)
   }, projectConfig.render);
   await serverAdapter.start();
 }
@@ -1446,7 +1700,7 @@ async function runForgeInspect() {
   const projectConfig = await loadConfig(cwd);
   const outputDirectory = projectConfig.build.outDir ?? "dist";
   const inspectReport = inspectBuild({
-    outDir: join17(cwd, outputDirectory),
+    outDir: join18(cwd, outputDirectory),
     renderConfig: projectConfig.render
   });
   printInspectReport(inspectReport);
@@ -1514,4 +1768,4 @@ ${BOLD}${RED}Rakta.js error:${RESET} ${errorMessage}
   process.exit(1);
 });
 
-//# debugId=E78251A4223C95A364756E2164756E21
+//# debugId=A7E4DE422B721CBF64756E2164756E21