@donkeylabs/adapter-sveltekit 2.0.12 → 2.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/adapter-sveltekit",
-  "version": "2.0.12",
+  "version": "2.0.14",
   "type": "module",
   "description": "SvelteKit adapter for @donkeylabs/server - seamless SSR/browser API integration",
   "main": "./src/index.ts",

package/src/generator/index.ts

@@ -70,200 +70,250 @@ export function createApi(options?: ClientOptions) {
 };
 
 /**
- * Generate a fully-typed SvelteKit-compatible API client
+ * Namespace tree node for building nested client structure
  */
-function generateTypedSvelteKitClient(routes: RouteInfo[]): string {
-  const opts = svelteKitGeneratorOptions;
+interface NamespaceTreeNode {
+  methods: { methodDef: string; typeDef: string }[];
+  children: Map<string, NamespaceTreeNode>;
+}
 
-  // Check if all routes share a common prefix (e.g., "api.") - if so, strip it
-  let routesToProcess = routes;
-  let commonPrefix = "";
-  if (routes.length > 0) {
-    const firstPart = routes[0]?.name.split(".")[0];
-    const allSharePrefix = firstPart && routes.every(r => r.name.startsWith(firstPart + "."));
-    if (allSharePrefix && firstPart) {
-      commonPrefix = firstPart;
-      // Strip the common prefix from route names for client generation
-      routesToProcess = routes.map(r => ({
-        ...r,
-        name: r.name.slice(firstPart.length + 1), // Remove "api." prefix
-        prefix: r.prefix === firstPart ? "" : r.prefix.slice(firstPart.length + 1),
-      }));
-    }
-  }
+/**
+ * Build a nested tree structure from routes
+ * e.g., routes "api.counter.get", "api.cache.set" become:
+ * api -> { counter -> { get }, cache -> { set } }
+ */
+function buildRouteTree(routes: RouteInfo[], commonPrefix: string): Map<string, NamespaceTreeNode> {
+  const tree = new Map<string, NamespaceTreeNode>();
 
-  // Group routes by namespace
-  const groups = new Map<string, RouteInfo[]>();
-  for (const route of routesToProcess) {
+  for (const route of routes) {
+    // Get the path parts for nesting (e.g., "api.counter.get" -> ["api", "counter", "get"])
     const parts = route.name.split(".");
-    const namespace = parts.length > 1 ? parts[0]! : "_root";
-    if (!groups.has(namespace)) {
-      groups.set(namespace, []);
+    const methodName = parts[parts.length - 1]!; // Last part is the method
+    const namespaceParts = parts.slice(0, -1); // Everything before is namespace path
+
+    if (namespaceParts.length === 0) {
+      // Root level method
+      if (!tree.has("_root")) {
+        tree.set("_root", { methods: [], children: new Map() });
+      }
+      tree.get("_root")!.methods.push(generateMethodAndType(route, methodName, "Root", commonPrefix));
+      continue;
+    }
+
+    // Navigate/create the tree path
+    let current = tree;
+    for (let i = 0; i < namespaceParts.length; i++) {
+      const part = namespaceParts[i]!;
+      if (!current.has(part)) {
+        current.set(part, { methods: [], children: new Map() });
+      }
+
+      if (i === namespaceParts.length - 1) {
+        // At the final namespace level - add the method here
+        const pascalNs = toPascalCase(namespaceParts.join("."));
+        current.get(part)!.methods.push(generateMethodAndType(route, methodName, pascalNs, commonPrefix));
+      } else {
+        // Continue traversing
+        current = current.get(part)!.children;
+      }
     }
-    groups.get(namespace)!.push({
-      ...route,
-      routeName: parts.length > 1 ? parts.slice(1).join(".") : parts[0]!,
-    });
   }
 
-  // Generate type definitions
-  const typeBlocks: string[] = [];
-  const methodBlocks: string[] = [];
+  return tree;
+}
 
-  for (const [namespace, nsRoutes] of groups) {
-    const pascalNs = namespace === "_root" ? "Root" : toPascalCase(namespace);
-    const methodNs = namespace === "_root" ? "_root" : namespace;
-
-    // Generate types for this namespace (typed, stream, sse, formData, html routes have input types)
-    const typeEntries = nsRoutes
-      .filter(r => ["typed", "stream", "sse", "formData", "html"].includes(r.handler))
-      .map(r => {
-        const pascalRoute = toPascalCase(r.routeName);
-        // If inputSource starts with "z.", it's a Zod source string - convert it
-        // Otherwise it's already a TypeScript type string from getTypedMetadata()
-        const inputType = r.inputSource
-          ? (r.inputSource.trim().startsWith("z.") ? zodToTypeScript(r.inputSource) : r.inputSource)
-          : "Record<string, never>";
-
-        // Handlers that don't have typed output (return Response or string directly)
-        if (r.handler === "stream" || r.handler === "html") {
-          return `    export namespace ${pascalRoute} {
+/**
+ * Generate method definition and type definition for a route
+ */
+function generateMethodAndType(
+  route: RouteInfo,
+  methodName: string,
+  pascalNs: string,
+  commonPrefix: string
+): { methodDef: string; typeDef: string } {
+  const camelMethod = toCamelCase(methodName);
+  const pascalRoute = toPascalCase(methodName);
+  const fullRouteName = route.name; // Already includes full path
+
+  // Generate input type
+  const inputType = route.inputSource
+    ? (route.inputSource.trim().startsWith("z.") ? zodToTypeScript(route.inputSource) : route.inputSource)
+    : "Record<string, never>";
+
+  // Generate type definition
+  let typeDef = "";
+  let methodDef = "";
+
+  if (route.handler === "stream" || route.handler === "html") {
+    typeDef = `    export namespace ${pascalRoute} {
       export type Input = Expand<${inputType}>;
     }
     export type ${pascalRoute} = { Input: ${pascalRoute}.Input };`;
-        }
-
-        // SSE routes - include Events type if eventsSource is present
-        if (r.handler === "sse") {
-          const eventsEntries = r.eventsSource
-            ? Object.entries(r.eventsSource).map(([eventName, eventSchema]) => {
-                const eventType = eventSchema.trim().startsWith("z.")
-                  ? zodToTypeScript(eventSchema)
-                  : eventSchema;
-                return `        "${eventName}": Expand<${eventType}>;`;
-              })
-            : [];
-          const eventsType = eventsEntries.length > 0
-            ? `{\n${eventsEntries.join("\n")}\n      }`
-            : "Record<string, unknown>";
-          return `    export namespace ${pascalRoute} {
+
+    if (route.handler === "stream") {
+      methodDef = `${camelMethod}: {
+      /** POST request with JSON body (programmatic) */
+      fetch: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: RequestOptions): Promise<Response> => this.streamRequest("${fullRouteName}", input, options),
+      /** GET URL for browser src attributes (video, img, download links) */
+      url: (input: Routes.${pascalNs}.${pascalRoute}.Input): string => this.streamUrl("${fullRouteName}", input),
+      /** GET request with query params */
+      get: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: RequestOptions): Promise<Response> => this.streamGet("${fullRouteName}", input, options),
+    }`;
+    } else {
+      const hasInput = route.inputSource;
+      methodDef = `${camelMethod}: (${hasInput ? `input: Routes.${pascalNs}.${pascalRoute}.Input` : ""}): Promise<string> => this.htmlRequest("${fullRouteName}"${hasInput ? ", input" : ""})`;
+    }
+  } else if (route.handler === "sse") {
+    const eventsEntries = route.eventsSource
+      ? Object.entries(route.eventsSource).map(([eventName, eventSchema]) => {
+          const eventType = eventSchema.trim().startsWith("z.")
+            ? zodToTypeScript(eventSchema)
+            : eventSchema;
+          return `        "${eventName}": Expand<${eventType}>;`;
+        })
+      : [];
+    const eventsType = eventsEntries.length > 0
+      ? `{\n${eventsEntries.join("\n")}\n      }`
+      : "Record<string, unknown>";
+
+    typeDef = `    export namespace ${pascalRoute} {
       export type Input = Expand<${inputType}>;
       export type Events = ${eventsType};
     }
     export type ${pascalRoute} = { Input: ${pascalRoute}.Input; Events: ${pascalRoute}.Events };`;
-        }
 
-        // typed and formData have both Input and Output
-        const outputType = r.outputSource
-          ? (r.outputSource.trim().startsWith("z.") ? zodToTypeScript(r.outputSource) : r.outputSource)
-          : "unknown";
-        return `    export namespace ${pascalRoute} {
+    const hasInput = route.inputSource;
+    if (hasInput) {
+      methodDef = `${camelMethod}: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: SSEConnectionOptions): SSEConnection<Routes.${pascalNs}.${pascalRoute}.Events> => this.sseConnect("${fullRouteName}", input, options)`;
+    } else {
+      methodDef = `${camelMethod}: (options?: SSEConnectionOptions): SSEConnection<Routes.${pascalNs}.${pascalRoute}.Events> => this.sseConnect("${fullRouteName}", undefined, options)`;
+    }
+  } else if (route.handler === "raw") {
+    typeDef = ""; // Raw routes don't have types
+    methodDef = `${camelMethod}: (init?: RequestInit): Promise<Response> => this.rawRequest("${fullRouteName}", init)`;
+  } else if (route.handler === "formData") {
+    const outputType = route.outputSource
+      ? (route.outputSource.trim().startsWith("z.") ? zodToTypeScript(route.outputSource) : route.outputSource)
+      : "unknown";
+
+    typeDef = `    export namespace ${pascalRoute} {
       export type Input = Expand<${inputType}>;
       export type Output = Expand<${outputType}>;
     }
     export type ${pascalRoute} = { Input: ${pascalRoute}.Input; Output: ${pascalRoute}.Output };`;
-      });
 
-    if (typeEntries.length > 0) {
-      typeBlocks.push(`  export namespace ${pascalNs} {\n${typeEntries.join("\n\n")}\n  }`);
+    methodDef = `${camelMethod}: (fields: Routes.${pascalNs}.${pascalRoute}.Input, files: File[]): Promise<Routes.${pascalNs}.${pascalRoute}.Output> => this.formDataRequest("${fullRouteName}", fields, files)`;
+  } else {
+    // typed handler (default)
+    const outputType = route.outputSource
+      ? (route.outputSource.trim().startsWith("z.") ? zodToTypeScript(route.outputSource) : route.outputSource)
+      : "unknown";
+
+    typeDef = `    export namespace ${pascalRoute} {
+      export type Input = Expand<${inputType}>;
+      export type Output = Expand<${outputType}>;
     }
+    export type ${pascalRoute} = { Input: ${pascalRoute}.Input; Output: ${pascalRoute}.Output };`;
 
-    // Generate methods for this namespace
-    const methodEntries = nsRoutes
-      .filter(r => r.handler === "typed")
-      .map(r => {
-        const methodName = toCamelCase(r.routeName);
-        const pascalRoute = toPascalCase(r.routeName);
-        const inputType = `Routes.${pascalNs}.${pascalRoute}.Input`;
-        const outputType = `Routes.${pascalNs}.${pascalRoute}.Output`;
-        // Use original route name with prefix for the request
-        const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
-        return `    ${methodName}: (input: ${inputType}, options?: RequestOptions): Promise<${outputType}> => this.request("${fullRouteName}", input, options)`;
-      });
-
-    const rawMethodEntries = nsRoutes
-      .filter(r => r.handler === "raw")
-      .map(r => {
-        const methodName = toCamelCase(r.routeName);
-        const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
-        return `    ${methodName}: (init?: RequestInit): Promise<Response> => this.rawRequest("${fullRouteName}", init)`;
-      });
-
-    const streamMethodEntries = nsRoutes
-      .filter(r => r.handler === "stream")
-      .map(r => {
-        const methodName = toCamelCase(r.routeName);
-        const pascalRoute = toPascalCase(r.routeName);
-        const inputType = `Routes.${pascalNs}.${pascalRoute}.Input`;
-        const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
-        // Stream routes provide three methods:
-        // - fetch(input, options?): POST request (programmatic)
-        // - url(input): GET URL for browser (video src, img src, download links)
-        // - get(input, options?): GET fetch request
-        return `    ${methodName}: {
-      /** POST request with JSON body (programmatic) */
-      fetch: (input: ${inputType}, options?: RequestOptions): Promise<Response> => this.streamRequest("${fullRouteName}", input, options),
-      /** GET URL for browser src attributes (video, img, download links) */
-      url: (input: ${inputType}): string => this.streamUrl("${fullRouteName}", input),
-      /** GET request with query params */
-      get: (input: ${inputType}, options?: RequestOptions): Promise<Response> => this.streamGet("${fullRouteName}", input, options),
-    }`;
-      });
-
-    const sseMethodEntries = nsRoutes
-      .filter(r => r.handler === "sse")
-      .map(r => {
-        const methodName = toCamelCase(r.routeName);
-        const pascalRoute = toPascalCase(r.routeName);
-        const hasInput = r.inputSource;
-        const inputType = hasInput ? `Routes.${pascalNs}.${pascalRoute}.Input` : "Record<string, never>";
-        const eventsType = `Routes.${pascalNs}.${pascalRoute}.Events`;
-        const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
-        // SSE returns typed SSEConnection for type-safe event handling
-        // With input: (input, options?) => sseConnect(route, input, options)
-        // Without input: (options?) => sseConnect(route, undefined, options)
-        if (hasInput) {
-          return `    ${methodName}: (input: ${inputType}, options?: SSEConnectionOptions): SSEConnection<${eventsType}> => this.sseConnect("${fullRouteName}", input, options)`;
-        } else {
-          return `    ${methodName}: (options?: SSEConnectionOptions): SSEConnection<${eventsType}> => this.sseConnect("${fullRouteName}", undefined, options)`;
-        }
-      });
-
-    const formDataMethodEntries = nsRoutes
-      .filter(r => r.handler === "formData")
-      .map(r => {
-        const methodName = toCamelCase(r.routeName);
-        const pascalRoute = toPascalCase(r.routeName);
-        const inputType = r.inputSource ? `Routes.${pascalNs}.${pascalRoute}.Input` : "Record<string, any>";
-        const outputType = r.outputSource ? `Routes.${pascalNs}.${pascalRoute}.Output` : "unknown";
-        const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
-        return `    ${methodName}: (fields: ${inputType}, files: File[]): Promise<${outputType}> => this.formDataRequest("${fullRouteName}", fields, files)`;
-      });
-
-    const htmlMethodEntries = nsRoutes
-      .filter(r => r.handler === "html")
-      .map(r => {
-        const methodName = toCamelCase(r.routeName);
-        const pascalRoute = toPascalCase(r.routeName);
-        const hasInput = r.inputSource;
-        const inputType = hasInput ? `Routes.${pascalNs}.${pascalRoute}.Input` : "Record<string, never>";
-        const fullRouteName = commonPrefix ? `${commonPrefix}.${r.name}` : r.name;
-        return `    ${methodName}: (${hasInput ? `input: ${inputType}` : ""}): Promise<string> => this.htmlRequest("${fullRouteName}"${hasInput ? ", input" : ""})`;
-      });
-
-    const allMethods = [...methodEntries, ...rawMethodEntries, ...streamMethodEntries, ...sseMethodEntries, ...formDataMethodEntries, ...htmlMethodEntries];
-    if (allMethods.length > 0) {
-      if (namespace === "_root") {
-        // Root-level methods go directly on the class
-        for (const method of allMethods) {
-          methodBlocks.push(method.replace(/^    /, "  "));
-        }
-      } else {
-        methodBlocks.push(`  ${methodNs} = {\n${allMethods.join(",\n")}\n  };`);
+    methodDef = `${camelMethod}: (input: Routes.${pascalNs}.${pascalRoute}.Input, options?: RequestOptions): Promise<Routes.${pascalNs}.${pascalRoute}.Output> => this.request("${fullRouteName}", input, options)`;
+  }
+
+  return { methodDef, typeDef };
+}
+
+/**
+ * Generate nested object code from a tree node
+ */
+function generateNestedMethods(node: NamespaceTreeNode, indent: string = "    "): string {
+  const parts: string[] = [];
+
+  // Add methods at this level
+  for (const { methodDef } of node.methods) {
+    // Indent each line of the method definition
+    const indented = methodDef.split("\n").map((line, i) =>
+      i === 0 ? `${indent}${line}` : `${indent}${line}`
+    ).join("\n");
+    parts.push(indented);
+  }
+
+  // Add nested namespaces
+  for (const [childName, childNode] of node.children) {
+    const childContent = generateNestedMethods(childNode, indent + "  ");
+    parts.push(`${indent}${childName}: {\n${childContent}\n${indent}}`);
+  }
+
+  return parts.join(",\n");
+}
+
+/**
+ * Collect all type definitions from a tree
+ */
+function collectTypeDefs(tree: Map<string, NamespaceTreeNode>, prefix: string = ""): Map<string, string[]> {
+  const result = new Map<string, string[]>();
+
+  for (const [name, node] of tree) {
+    const nsPath = prefix ? `${prefix}.${name}` : name;
+    const pascalNs = name === "_root" ? "Root" : toPascalCase(nsPath);
+
+    // Collect types from this node's methods
+    const typeDefs = node.methods
+      .map(m => m.typeDef)
+      .filter(t => t.length > 0);
+
+    if (typeDefs.length > 0) {
+      if (!result.has(pascalNs)) {
+        result.set(pascalNs, []);
+      }
+      result.get(pascalNs)!.push(...typeDefs);
+    }
+
+    // Recursively collect from children
+    const childTypes = collectTypeDefs(node.children, nsPath);
+    for (const [childNs, childDefs] of childTypes) {
+      if (!result.has(childNs)) {
+        result.set(childNs, []);
       }
+      result.get(childNs)!.push(...childDefs);
     }
   }
 
+  return result;
+}
+
+/**
+ * Generate a fully-typed SvelteKit-compatible API client
+ */
+function generateTypedSvelteKitClient(routes: RouteInfo[]): string {
+  const opts = svelteKitGeneratorOptions;
+  const commonPrefix = ""; // We don't strip prefixes anymore - nested structure handles it
+
+  // Build nested tree structure from routes
+  const tree = buildRouteTree(routes, commonPrefix);
+
+  // Collect type definitions from tree
+  const typesByNamespace = collectTypeDefs(tree);
+  const typeBlocks: string[] = [];
+  for (const [nsName, typeDefs] of typesByNamespace) {
+    if (typeDefs.length > 0) {
+      typeBlocks.push(`  export namespace ${nsName} {\n${typeDefs.join("\n\n")}\n  }`);
+    }
+  }
+
+  // Generate method blocks from tree
+  const methodBlocks: string[] = [];
+  for (const [topLevel, node] of tree) {
+    if (topLevel === "_root") {
+      // Root level methods become direct class properties
+      for (const { methodDef } of node.methods) {
+        methodBlocks.push(`  ${methodDef};`);
+      }
+      continue;
+    }
+
+    const content = generateNestedMethods(node, "    ");
+    methodBlocks.push(`  ${topLevel} = {\n${content}\n  };`);
+  }
+
   return `// Auto-generated by donkeylabs generate
 // DO NOT EDIT MANUALLY
 

package/src/vite.ts

@@ -9,7 +9,7 @@
 import type { Plugin, ViteDevServer } from "vite";
 import { spawn, type ChildProcess, exec } from "node:child_process";
 import { resolve, join } from "node:path";
-import { watch, type FSWatcher } from "node:fs";
+import { watch, type FSWatcher, existsSync } from "node:fs";
 import { promisify } from "node:util";
 
 const execAsync = promisify(exec);
@@ -41,6 +41,19 @@ export interface DevPluginOptions {
    * @default "./src/server"
    */
   watchDir?: string;
+
+  /**
+   * Enable hot reload for route files (dev mode only).
+   * When a route file changes, the router will be reloaded without server restart.
+   * @default true
+   */
+  hotReloadRoutes?: boolean;
+
+  /**
+   * Glob patterns for route files to watch for hot reload.
+   * @default ["**\/routes\/**\/*.ts"]
+   */
+  routePatterns?: string[];
 }
 
 // Check if running with Bun runtime (bun --bun)
@@ -87,6 +100,8 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
     backendPort = 3001,
     watchTypes = true,
     watchDir = "./src/server",
+    hotReloadRoutes = true,
+    routePatterns = ["**/routes/**/*.ts", "**/routes/**/*.js"],
   } = options;
 
   // State for subprocess mode
@@ -96,6 +111,7 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
   // State for in-process mode
   let appServer: any = null;
   let serverReady = false;
+  let viteServer: ViteDevServer | null = null;
 
   // State for file watcher
   let fileWatcher: FSWatcher | null = null;
@@ -103,11 +119,82 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
   let lastGenerationTime = 0;
   let debounceTimer: ReturnType<typeof setTimeout> | null = null;
 
+  // State for hot reload
+  let hotReloadTimer: ReturnType<typeof setTimeout> | null = null;
+  const HOT_RELOAD_DEBOUNCE_MS = 100;
+
   const COOLDOWN_MS = 2000;
   const DEBOUNCE_MS = 500;
 
   // Patterns to ignore (generated files)
-  const IGNORED_PATTERNS = [/schema\.ts$/, /\.d\.ts$/];
+  const IGNORED_PATTERNS = [/schema\.ts$/, /\.d\.ts$/, /api\.ts$/];
+
+  // Check if a file matches route patterns
+  function isRouteFile(filename: string): boolean {
+    return routePatterns.some((pattern) => {
+      // Simple glob matching for common patterns
+      const regexPattern = pattern
+        .replace(/\*\*/g, ".*")
+        .replace(/\*/g, "[^/]*")
+        .replace(/\./g, "\\.");
+      return new RegExp(regexPattern).test(filename);
+    });
+  }
+
+  // Hot reload a route file
+  async function hotReloadRoute(filepath: string) {
+    if (!appServer || !serverReady || !viteServer || !hotReloadRoutes) return;
+
+    console.log("\x1b[36m[donkeylabs-dev]\x1b[0m Hot reloading route:", filepath);
+
+    try {
+      // Invalidate the module in Vite's cache
+      const mod = viteServer.moduleGraph.getModuleById(filepath);
+      if (mod) {
+        viteServer.moduleGraph.invalidateModule(mod);
+      }
+
+      // Re-import the module with cache busting
+      const timestamp = Date.now();
+      const moduleUrl = `${filepath}?t=${timestamp}`;
+
+      // Import the fresh module
+      const freshModule = await viteServer.ssrLoadModule(moduleUrl);
+
+      // Find the router export (could be named 'router', 'default', or end with 'Router')
+      let newRouter = freshModule.router || freshModule.default;
+      if (!newRouter) {
+        for (const key of Object.keys(freshModule)) {
+          if (key.endsWith("Router") && typeof freshModule[key]?.getRoutes === "function") {
+            newRouter = freshModule[key];
+            break;
+          }
+        }
+      }
+
+      if (newRouter && typeof newRouter.getRoutes === "function") {
+        // Get the router prefix
+        const prefix = newRouter.getPrefix?.() || "";
+        if (prefix) {
+          appServer.reloadRouter(prefix, newRouter);
+          console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Route hot reload complete:", prefix);
+        } else {
+          // If no prefix, rebuild all routes
+          appServer.rebuildRouteMap();
+          console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Route map rebuilt");
+        }
+      } else {
+        console.warn("\x1b[33m[donkeylabs-dev]\x1b[0m No router export found in:", filepath);
+      }
+    } catch (err: any) {
+      console.error("\x1b[31m[donkeylabs-dev]\x1b[0m Hot reload error:", err.message);
+    }
+  }
+
+  function debouncedHotReload(filepath: string) {
+    if (hotReloadTimer) clearTimeout(hotReloadTimer);
+    hotReloadTimer = setTimeout(() => hotReloadRoute(filepath), HOT_RELOAD_DEBOUNCE_MS);
+  }
 
   function shouldIgnoreFile(filename: string): boolean {
     return IGNORED_PATTERNS.some((pattern) => pattern.test(filename));
@@ -122,7 +209,7 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
     console.log("\x1b[36m[donkeylabs-dev]\x1b[0m Server files changed, regenerating types...");
 
     try {
-      await execAsync("bunx donkeylabs generate");
+      await execAsync("bun run gen:types");
       console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Types regenerated successfully");
     } catch (e: any) {
       console.error("\x1b[31m[donkeylabs-dev]\x1b[0m Error regenerating types:", e.message);
@@ -132,23 +219,65 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
     }
   }
 
+  async function ensureTypesGenerated() {
+    // Check if the client file exists (common locations)
+    const clientPaths = [
+      resolve(process.cwd(), "src/lib/api.ts"),
+      resolve(process.cwd(), "src/api.ts"),
+    ];
+
+    const clientExists = clientPaths.some((p) => existsSync(p));
+    if (clientExists) return;
+
+    console.log("\x1b[36m[donkeylabs-dev]\x1b[0m Generated client not found, running initial type generation...");
+    isGenerating = true;
+
+    try {
+      await execAsync("bun run gen:types");
+      console.log("\x1b[32m[donkeylabs-dev]\x1b[0m Initial types generated successfully");
+    } catch (e: any) {
+      console.warn("\x1b[33m[donkeylabs-dev]\x1b[0m Initial type generation failed:", e.message);
+      console.warn("\x1b[33m[donkeylabs-dev]\x1b[0m Run 'bun run gen:types' manually to generate types");
+    } finally {
+      isGenerating = false;
+      lastGenerationTime = Date.now();
+    }
+  }
+
   function debouncedRegenerate() {
     if (debounceTimer) clearTimeout(debounceTimer);
     debounceTimer = setTimeout(regenerateTypes, DEBOUNCE_MS);
   }
 
   function startFileWatcher() {
-    if (!watchTypes || fileWatcher) return;
+    if (fileWatcher) return;
+    if (!watchTypes && !hotReloadRoutes) return;
 
     const watchPath = resolve(process.cwd(), watchDir);
     try {
       fileWatcher = watch(watchPath, { recursive: true }, (_eventType, filename) => {
         if (!filename) return;
-        if (!filename.endsWith(".ts")) return;
+        if (!filename.endsWith(".ts") && !filename.endsWith(".js")) return;
         if (shouldIgnoreFile(filename)) return;
-        debouncedRegenerate();
+
+        const fullPath = join(watchPath, filename);
+
+        // Check if this is a route file for hot reload
+        if (hotReloadRoutes && isRouteFile(filename)) {
+          debouncedHotReload(fullPath);
+        }
+
+        // Also trigger type regeneration
+        if (watchTypes) {
+          debouncedRegenerate();
+        }
       });
-      console.log(`\x1b[36m[donkeylabs-dev]\x1b[0m Watching ${watchDir} for changes...`);
+
+      const features = [
+        watchTypes ? "type generation" : null,
+        hotReloadRoutes ? "hot reload" : null,
+      ].filter(Boolean).join(", ");
+      console.log(`\x1b[36m[donkeylabs-dev]\x1b[0m Watching ${watchDir} for ${features}...`);
     } catch (err) {
       console.warn(`\x1b[33m[donkeylabs-dev]\x1b[0m Could not watch ${watchDir}:`, err);
     }
@@ -156,6 +285,7 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
 
   function stopFileWatcher() {
     if (debounceTimer) clearTimeout(debounceTimer);
+    if (hotReloadTimer) clearTimeout(hotReloadTimer);
     if (fileWatcher) {
       fileWatcher.close();
       fileWatcher = null;
@@ -183,7 +313,13 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
     async configureServer(server: ViteDevServer) {
       const serverEntryResolved = resolve(process.cwd(), serverEntry);
 
-      // Start file watcher for auto type regeneration
+      // Store vite server reference for hot reload
+      viteServer = server;
+
+      // Ensure types are generated on first start (if client file doesn't exist)
+      await ensureTypesGenerated();
+
+      // Start file watcher for auto type regeneration and hot reload
       startFileWatcher();
 
       if (isBunRuntime) {
@@ -576,6 +712,7 @@ export function donkeylabsDev(options: DevPluginOptions = {}): Plugin {
 
     async closeBundle() {
       stopFileWatcher();
+      viteServer = null;
       if (backendProcess) {
         backendProcess.kill();
         backendProcess = null;