jac-client 0.2.6__py3-none-any.whl → 0.2.11__py3-none-any.whl

jac_client/plugin/src/impl/vite_bundler.impl.jac

@@ -1,11 +1,24 @@
-"""Create package.json from config.json during bundling."""
+"""Get the client build directory from project config."""
+impl ViteBundler._get_client_dir(self: ViteBundler) -> Path {
+    # Try to get from project config
+    try {
+        import from jaclang.project.config { get_config }
+        config = get_config();
+        if config is not None {
+            return config.get_client_dir();
+        }
+    } except ImportError { }
+    # Fallback to default
+    return self.project_dir / '.jac' / 'client';
+}
 
+"""Create package.json from config.json during bundling."""
 impl ViteBundler.create_package_json(
     self: ViteBundler, project_name: Optional[str] = None
 ) -> Path {
-    build_dir = self.project_dir / '.client-build';
-    build_dir.mkdir(exist_ok=True);
-    configs_dir = build_dir / '.jac-client.configs';
+    build_dir = self._get_client_dir();
+    build_dir.mkdir(parents=True, exist_ok=True);
+    configs_dir = build_dir / 'configs';
     configs_dir.mkdir(exist_ok=True);
     package_config = self.config_loader.get_package_config();
     package_json_path = configs_dir / 'package.json';
@@ -29,39 +42,16 @@ impl ViteBundler.create_package_json(
     if not name {
         name = self.project_dir.name or 'jac-app';
     }
-    # Default hardcoded dependencies (always included)
-    default_dependencies = {
-        'react': '^18.2.0',
-        'react-dom': '^18.2.0',
-        'react-router-dom': '^6.22.0'
-    };
-    default_dev_dependencies = {
-        'vite': '^6.4.1',
-        '@babel/cli': '^7.28.3',
-        '@babel/core': '^7.28.5',
-        '@babel/preset-env': '^7.28.5',
-        '@babel/preset-react': '^7.28.5',
-        '@vitejs/plugin-react': '^4.2.1',
-        'typescript': '^5.3.3',
-        '@types/react': '^18.2.0',
-        '@types/react-dom': '^18.2.0'
-    };
-    # Merge user dependencies from TOML with defaults (user can override)
-    user_dependencies = package_config.get('dependencies', {});
-    user_dev_dependencies = package_config.get('devDependencies', {});
-    dependencies = {** default_dependencies, ** user_dependencies};
-    dev_dependencies = {** default_dev_dependencies, ** user_dev_dependencies};
+    dependencies = package_config.get('dependencies', {});
+    dev_dependencies = package_config.get('devDependencies', {});
+    # Vite handles JSX/TSX transpilation natively with Bun - no Babel compile step needed
     scripts = {
-        'build': 'npm run compile && vite build --config .client-build/.jac-client.configs/vite.config.js',
-        'dev': 'vite dev --config .client-build/.jac-client.configs/vite.config.js',
-        'preview': 'vite preview --config .client-build/.jac-client.configs/vite.config.js',
-        'compile': 'babel compiled --out-dir build --extensions ".jsx,.js" --out-file-extension .js'
+        'build': 'vite build --config .jac/client/configs/vite.config.js',
+        'dev': 'vite dev --config .jac/client/configs/vite.config.js',
+        'preview': 'vite preview --config .jac/client/configs/vite.config.js'
     };
     user_scripts = package_config.get('scripts', {});
     scripts.update(user_scripts);
-    babel_config = {
-        'presets': [['@babel/preset-env', {'modules': False}], '@babel/preset-react']
-    };
     package_data = {
         'name': name,
         'version': package_config.get('version', '1.0.0'),
@@ -70,8 +60,7 @@ impl ViteBundler.create_package_json(
         'main': 'index.js',
         'scripts': scripts,
         'dependencies': dependencies,
-        'devDependencies': dev_dependencies,
-        'babel': babel_config
+        'devDependencies': dev_dependencies
     };
     for (key, value) in package_config.items() {
         if (
@@ -85,14 +74,16 @@ impl ViteBundler.create_package_json(
     }
     # Generate tsconfig.json during build time
     self.create_tsconfig();
+    # Generate config files (postcss, tailwind, etc.) from jac.toml
+    self.create_config_files();
     return package_json_path;
 }
 
 """Create tsconfig.json during build time, merging user config from jac.toml."""
 impl ViteBundler.create_tsconfig(self: ViteBundler) -> Path {
-    build_dir = self.project_dir / '.client-build';
-    build_dir.mkdir(exist_ok=True);
-    configs_dir = build_dir / '.jac-client.configs';
+    build_dir = self._get_client_dir();
+    build_dir.mkdir(parents=True, exist_ok=True);
+    configs_dir = build_dir / 'configs';
     configs_dir.mkdir(exist_ok=True);
     tsconfig_path = configs_dir / 'tsconfig.json';
     # Default tsconfig settings
@@ -114,7 +105,7 @@ impl ViteBundler.create_tsconfig(self: ViteBundler) -> Path {
         'noFallthroughCasesInSwitch': True
     };
     default_include = ['components/**/*'];
-    default_exclude = ['.client-build'];
+    default_exclude = ['.jac'];
     # Get user config from [plugins.client.ts] in jac.toml
     user_ts_config = self.config_loader.get_ts_config();
     user_compiler_options = user_ts_config.get('compilerOptions', {});
@@ -130,28 +121,28 @@ impl ViteBundler.create_tsconfig(self: ViteBundler) -> Path {
         'include': merged_include,
         'exclude': merged_exclude
     };
-    # Write the config to .client-build/.jac-client.configs/tsconfig.json (no root config file)
+    # Write the config to .jac/client/configs/tsconfig.json (no root config file)
     tsconfig_path.write_text(json.dumps(tsconfig_data, indent=2), encoding='utf-8');
     return tsconfig_path;
 }
 
 """
-Clean up root package.json and move package-lock.json to .jac-client.configs/.
+Clean up root package.json and move bun.lockb to configs/.
 
-        Remove root package.json and move package-lock.json to .jac-client.configs/.
+        Remove root package.json and move bun.lockb to configs/.
 """
 impl ViteBundler._cleanup_root_package_files(self: ViteBundler) -> None {
     root_package_json = self.project_dir / 'package.json';
-    root_package_lock = self.project_dir / 'package-lock.json';
-    build_dir = self.project_dir / '.client-build';
-    configs_dir = build_dir / '.jac-client.configs';
-    configs_package_lock = configs_dir / 'package-lock.json';
-    if root_package_lock.exists() {
+    root_bun_lockb = self.project_dir / 'bun.lockb';
+    build_dir = self._get_client_dir();
+    configs_dir = build_dir / 'configs';
+    configs_bun_lockb = configs_dir / 'bun.lockb';
+    if root_bun_lockb.exists() {
         configs_dir.mkdir(exist_ok=True);
-        if configs_package_lock.exists() {
-            configs_package_lock.unlink();
+        if configs_bun_lockb.exists() {
+            configs_bun_lockb.unlink();
         }
-        shutil.move(str(root_package_lock), str(configs_package_lock));
+        shutil.move(str(root_bun_lockb), str(configs_bun_lockb));
     }
     if root_package_json.exists() {
         root_package_json.unlink();
@@ -159,12 +150,12 @@ impl ViteBundler._cleanup_root_package_files(self: ViteBundler) -> None {
 }
 
 """
-Ensure root package.json exists temporarily for npm commands.
+Ensure root package.json exists temporarily for bun commands.
 
         Create root package.json temporarily if it doesn't exist.
 """
 impl ViteBundler._ensure_root_package_json(self: ViteBundler) -> None {
-    generated_package_json = self.project_dir / '.client-build' / '.jac-client.configs' / 'package.json';
+    generated_package_json = self._get_client_dir() / 'configs' / 'package.json';
     root_package_json = self.project_dir / 'package.json';
     if not generated_package_json.exists() {
         self.create_package_json();
@@ -235,51 +226,28 @@ impl ViteBundler._get_plugin_var_name(self: ViteBundler, plugin_name: str) -> st
 
 """Create vite.config.js from config.json during bundling."""
 impl ViteBundler.create_vite_config(self: ViteBundler, entry_file: Path) -> Path {
-    build_dir = self.project_dir / '.client-build';
-    build_dir.mkdir(exist_ok=True);
-    configs_dir = build_dir / '.jac-client.configs';
+    build_dir = self._get_client_dir();
+    build_dir.mkdir(parents=True, exist_ok=True);
+    configs_dir = build_dir / 'configs';
     configs_dir.mkdir(exist_ok=True);
     vite_config_data = self.config_loader.get_vite_config();
     config_path = configs_dir / 'vite.config.js';
     # TypeScript is always enabled by default
-    build_dir = self.project_dir / '.client-build';
     try {
-        # Entry file path relative to .client-build/ (not project root)
+        # Entry file path relative to client build dir (not project root)
         entry_relative = entry_file.relative_to(build_dir).as_posix();
     } except ValueError {
-        # Fallback: try relative to project_dir and strip .client-build/ prefix
-        try {
-            entry_relative_full = entry_file.relative_to(self.project_dir).as_posix();
-            prefix = '.client-build/';
-            if entry_relative_full.startswith(prefix) {
-                # Remove '.client-build/' prefix (15 characters)
-                entry_relative = entry_relative_full[15:];
-            } else {
-                entry_relative = entry_relative_full;
-            }
-        } except ValueError {
-            entry_relative = entry_file.as_posix();
-        }
+        # Fallback: use absolute path
+        entry_relative = entry_file.as_posix();
     }
     try {
-        # Output dir path relative to .client-build/ (not project root)
+        # Output dir path relative to client build dir (not project root)
         output_relative = self.output_dir.relative_to(build_dir).as_posix();
     } except ValueError {
-        # Fallback: try relative to project_dir and strip .client-build/ prefix
-        try {
-            output_relative_full = self.output_dir.relative_to(self.project_dir).as_posix();
-            prefix = '.client-build/';
-            if output_relative_full.startswith(prefix) {
-                # Remove '.client-build/' prefix (15 characters)
-                output_relative = output_relative_full[15:];
-            } else {
-                output_relative = output_relative_full;
-            }
-        } except ValueError {
-            output_relative = self.output_dir.as_posix();
-        }
+        # Fallback: use absolute path
+        output_relative = self.output_dir.as_posix();
     }
-    # Calculate compiled directory path for aliases (relative to .client-build/)
+    # Calculate compiled directory path for aliases (relative to client build dir)
     if entry_relative.endswith('/build/main.js') {
         compiled_utils_relative = entry_relative[:-13] + '/compiled/client_runtime.js';
         compiled_assets_relative = entry_relative[:-13] + '/compiled/assets';
@@ -331,11 +299,55 @@ impl ViteBundler.create_vite_config(self: ViteBundler, entry_file: Path) -> Path
     else '';
     config_content = f'''import {{ defineConfig }} from "vite";
 import path from "path";
+import fs from "fs";
 import {{ fileURLToPath }} from "url";
 {imports_section}const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// Config is in .jac-client.configs/ inside .client-build/, so go up one level to .client-build/, then up one more to project root
+// Config is in configs/ inside .jac/client/, so go up one level to .jac/client/, then up two more to project root
 const buildDir = path.resolve(__dirname, "..");
-const projectRoot = path.resolve(__dirname, "../..");
+const projectRoot = path.resolve(__dirname, "../../..");
+
+// Jac source mapper plugin - maps errors back to original .jac files
+function jacSourceMapper() {{
+  const sourceMap = new Map(); // compiled path -> original jac path
+
+  return {{
+    name: 'jac-source-mapper',
+    enforce: 'pre',
+
+    // Extract source mapping from compiled files
+    transform(code, id) {{
+      if (id.includes('/compiled/') && id.endsWith('.js')) {{
+        const match = code.match(/^\\/\\* Source: (.+?) \\*\\//);
+        if (match) {{
+          sourceMap.set(id, match[1]);
+        }}
+      }}
+      return null;
+    }},
+
+    // Enhance error messages with original source info
+    buildEnd() {{
+      // Store source map for error reporting
+      this._jacSourceMap = sourceMap;
+    }},
+
+    // Handle resolve errors to show original source
+    resolveId(source, importer) {{
+      if (importer && sourceMap.has(importer)) {{
+        const originalSource = sourceMap.get(importer);
+        // Check for common issues like double slashes
+        if (source.includes('//') && !source.startsWith('http')) {{
+          this.error({{
+            message: `Cannot resolve "${{source}}" - path contains invalid double slash. Check your import in the original Jac file.`,
+            id: originalSource,
+            loc: {{ line: 1, column: 0 }}
+          }});
+        }}
+      }}
+      return null;
+    }}
+  }};
+}}
 
 /**
  * Vite configuration generated from config.json (in project root)
@@ -343,14 +355,20 @@ const projectRoot = path.resolve(__dirname, "../..");
  */
 
 export default defineConfig({{
-  plugins: [{(newline + plugins_str + newline + '  ') if plugins_str else ''}],
-  root: buildDir, // base folder (.client-build/) so vite can find node_modules
+  plugins: [
+    jacSourceMapper(),{(newline + plugins_str + newline + '  ') if plugins_str else ''}],
+  root: buildDir, // base folder (.jac/client/) so vite can find node_modules
     build: {{
+    sourcemap: true, // Enable source maps for better error messages
     rollupOptions: {{
       input: path.resolve(buildDir, "{entry_relative}"), // your compiled entry file
       output: {{
         entryFileNames: "client.[hash].js", // name of the final js file
-        assetFileNames: "[name].[ext]",
+        assetFileNames: (assetInfo) => assetInfo.name?.endsWith('.css') ? 'styles.css' : '[name].[ext]',
+        sourcemapPathTransform: (relativeSourcePath) => {{
+          // Transform source map paths to point to original location
+          return relativeSourcePath;
+        }},
       }},
     }},
     outDir: path.resolve(buildDir, "{output_relative}"), // final bundled output
@@ -360,7 +378,7 @@ export default defineConfig({{
   publicDir: false,
 {server_section}  resolve: {{
       alias: {{
-        "@jac-client/utils": path.resolve(buildDir, "{compiled_utils_relative}"),
+        "@jac/runtime": path.resolve(buildDir, "{compiled_utils_relative}"),
         "@jac-client/assets": path.resolve(buildDir, "{compiled_assets_relative}"),
       }},
       extensions: [{extensions_str}],
@@ -391,14 +409,8 @@ impl ViteBundler.read_bundle(self: ViteBundler) -> tuple[str, str] {
 
 """Find the generated Vite CSS file."""
 impl ViteBundler.find_css(self: ViteBundler) -> Optional[Path] {
-    css_file = self.output_dir / 'main.css';
-    if css_file.exists() {
-        return css_file;
-    }
-    for file in self.output_dir.glob('*.css') {
-        return file;
-    }
-    return None;
+    css_file = self.output_dir / 'styles.css';
+    return css_file if css_file.exists() else None;
 }
 
 """Find the generated Vite bundle file."""
@@ -409,10 +421,18 @@ impl ViteBundler.find_bundle(self: ViteBundler) -> Optional[Path] {
     return None;
 }
 
-"""Run Vite build with generated config in .client-build/.jac-client.configs/."""
+"""Run Vite build with generated config in .jac/client/configs/."""
 impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) -> None {
+    import sys;
+    import time;
+    import shutil;
+    import from jac_client.plugin.utils { ensure_bun_available }
+    # Ensure bun is available before proceeding
+    if not ensure_bun_available() {
+        raise ClientBundleError('Bun is required. Install manually: https://bun.sh') from None ;
+    }
     self.output_dir.mkdir(parents=True, exist_ok=True);
-    generated_package_json = self.project_dir / '.client-build' / '.jac-client.configs' / 'package.json';
+    generated_package_json = self._get_client_dir() / 'configs' / 'package.json';
     if not generated_package_json.exists() {
         self.create_package_json();
     } else {
@@ -420,79 +440,89 @@ impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) ->
         self.create_tsconfig();
     }
     try {
-        build_dir = self.project_dir / '.client-build';
+        build_dir = self._get_client_dir();
         node_modules = build_dir / 'node_modules';
         if not node_modules.exists() {
-            # Temporarily copy package.json to .client-build/ for npm install
+            # Temporarily copy package.json to client build dir for bun install
             build_package_json = build_dir / 'package.json';
-            configs_package_json = build_dir / '.jac-client.configs' / 'package.json';
+            configs_package_json = build_dir / 'configs' / 'package.json';
             if configs_package_json.exists() and not build_package_json.exists() {
                 import shutil;
                 shutil.copy2(configs_package_json, build_package_json);
             }
             try {
-                # Install to .client-build/node_modules
-                subprocess.run(
-                    ['npm', 'install'],
-                    cwd=build_dir,
-                    check=True,
-                    capture_output=True,
-                    text=True
+                # Install to .jac/client/node_modules with progress feedback
+                print("\n  ⏳ Installing dependencies...\n", flush=True);
+                start_time = time.time();
+                result = subprocess.run(
+                    ['bun', 'install'], cwd=build_dir, check=False, text=True
                 );
-            } except subprocess.CalledProcessError as e {
-                raise e from ClientBundleError(
-                    f"Failed to install npm dependencies: {e.stderr}"
-                ) ;
+                elapsed = time.time() - start_time;
+                if result.returncode != 0 {
+                    print(
+                        f"\n  ✖ bun install failed after {elapsed:.1f}s",
+                        file=sys.stderr
+                    );
+                    raise ClientBundleError("Failed to install dependencies") ;
+                }
+                print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
             } except FileNotFoundError {
-                raise None from ClientBundleError(
-                    'npm command not found. Ensure Node.js and npm are installed.'
-                ) ;
+                # This shouldn't happen since we check for bun at the start
+                raise ClientBundleError(
+                    'Bun command not found. Install Bun: https://bun.sh'
+                ) from None ;
             }
         }
-        build_dir = self.project_dir / '.client-build';
         if self.config_path {
             # Make config path relative to build_dir (where vite runs from)
-            config_str = str(self.config_path);
-            if '.client-build' in config_str {
-                # Config is in .client-build/, make it relative to build_dir
+            try {
                 config_rel = self.config_path.relative_to(build_dir);
-                command = ['npx', 'vite', 'build', '--config', str(config_rel)];
-            } else {
-                # Config is outside .client-build/, use absolute path
-                command = ['npx', 'vite', 'build', '--config', str(self.config_path)];
+                command = ['bun', 'x', 'vite', 'build', '--config', str(config_rel)];
+            } except ValueError {
+                # Config is outside client build dir, use absolute path
+                command = [
+                    'bun',
+                    'x',
+                    'vite',
+                    'build',
+                    '--config',
+                    str(self.config_path)
+                ];
             }
         } elif entry_file {
             generated_config = self.create_vite_config(entry_file);
-            # Config is in .client-build/.jac-client.configs/, make it relative to build_dir
+            # Config is in configs/, make it relative to build_dir
             config_rel = generated_config.relative_to(build_dir);
-            command = ['npx', 'vite', 'build', '--config', str(config_rel)];
+            command = ['bun', 'x', 'vite', 'build', '--config', str(config_rel)];
         } else {
-            command = ['npm', 'run', 'build'];
+            command = ['bun', 'run', 'build'];
         }
-        # Run vite from .client-build/ directory so it can find node_modules
-        result = subprocess.run(
-            command, cwd=build_dir, check=False, capture_output=True, text=True
-        );
+        # Run vite from client build directory so it can find node_modules
+        print("\n  ⏳ Building client bundle...\n", flush=True);
+        start_time = time.time();
+        result = subprocess.run(command, cwd=build_dir, check=False, text=True);
+        elapsed = time.time() - start_time;
         if result.returncode != 0 {
-            error_msg = result.stderr or result.stdout or 'Unknown error';
+            print(f"\n  ✖ Vite build failed after {elapsed:.1f}s", file=sys.stderr);
             raise ClientBundleError(
-                f"Vite build failed:\n{error_msg}\nCommand: {' '.join(command)}"
+                f"Vite build failed (see output above)\nCommand: {' '.join(command)}"
             ) from None ;
         }
+        print(f"\n  ✔ Client bundle built ({elapsed:.1f}s)", flush=True);
     } finally {
-        # Clean up temporary package.json in .client-build/
+        # Clean up temporary package.json in client build dir
         build_package_json = build_dir / 'package.json';
         if build_package_json.exists() {
             build_package_json.unlink();
         }
-        # Move package-lock.json to .jac-client.configs/ if it exists
-        build_package_lock = build_dir / 'package-lock.json';
-        if build_package_lock.exists() {
-            configs_package_lock = build_dir / '.jac-client.configs' / 'package-lock.json';
-            if configs_package_lock.exists() {
-                configs_package_lock.unlink();
+        # Move bun.lockb to configs/ if it exists
+        build_bun_lockb = build_dir / 'bun.lockb';
+        if build_bun_lockb.exists() {
+            configs_bun_lockb = build_dir / 'configs' / 'bun.lockb';
+            if configs_bun_lockb.exists() {
+                configs_bun_lockb.unlink();
             }
-            build_package_lock.rename(configs_package_lock);
+            build_bun_lockb.rename(configs_bun_lockb);
         }
     }
 }
@@ -506,8 +536,218 @@ impl ViteBundler.init(
     config_path: Optional[Path] = None
 ) {
     self.project_dir = project_dir;
-    self.output_dir = output_dir or (project_dir / '.client-build' / 'dist');
     self.minify = minify;
     self.config_path = config_path;
     self.config_loader = JacClientConfig(project_dir);
+    # Set output_dir after config_loader is initialized so _get_client_dir works
+    self.output_dir = output_dir or (self._get_client_dir() / 'dist');
+}
+
+"""Create a dev-mode vite config with API proxy for HMR."""
+impl ViteBundler.create_dev_vite_config(
+    self: ViteBundler, entry_file: Path, api_port: int = 8000
+) -> Path {
+    build_dir = self._get_client_dir();
+    build_dir.mkdir(parents=True, exist_ok=True);
+    configs_dir = build_dir / 'configs';
+    configs_dir.mkdir(exist_ok=True);
+    config_path = configs_dir / 'vite.dev.config.js';
+    # Get entry file relative path
+    try {
+        entry_relative = entry_file.relative_to(build_dir).as_posix();
+    } except ValueError {
+        entry_relative = entry_file.as_posix();
+    }
+    # Calculate paths for aliases
+    if entry_relative.endswith('/build/main.js') {
+        compiled_utils_relative = entry_relative[:-13] + '/compiled/client_runtime.js';
+        compiled_assets_relative = entry_relative[:-13] + '/compiled/assets';
+    } elif entry_relative.endswith('build/main.js') {
+        compiled_utils_relative = 'compiled/client_runtime.js';
+        compiled_assets_relative = 'compiled/assets';
+    } else {
+        compiled_utils_relative = 'compiled/client_runtime.js';
+        compiled_assets_relative = 'compiled/assets';
+    }
+    # Extensions for TypeScript
+    extensions = ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'];
+    extensions_str = ', '.join(f'"{ext}"' for ext in extensions);
+    # Generate dev config with proxy for API routes
+    config_content = f'''import {{ defineConfig }} from "vite";
+import path from "path";
+import {{ fileURLToPath }} from "url";
+import react from "@vitejs/plugin-react";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const buildDir = path.resolve(__dirname, "..");
+const projectRoot = path.resolve(__dirname, "../../..");
+
+/**
+ * Vite DEV configuration for HMR mode
+ * Proxies API routes to Python server at localhost:{api_port}
+ */
+export default defineConfig({{
+  plugins: [react()],
+  root: buildDir,
+  publicDir: false,
+  build: {{
+    sourcemap: true, // Enable source maps for better error messages
+  }},
+  server: {{
+    watch: {{
+      usePolling: true,
+      interval: 100,
+    }},
+    proxy: {{
+      "/walker": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+      "/function": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+      "/user": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+      "/introspect": {{
+        target: "http://localhost:{api_port}",
+        changeOrigin: true,
+      }},
+    }},
+  }},
+  resolve: {{
+    alias: {{
+      "@jac/runtime": path.resolve(buildDir, "{compiled_utils_relative}"),
+      "@jac-client/assets": path.resolve(buildDir, "{compiled_assets_relative}"),
+    }},
+    extensions: [{extensions_str}],
+  }},
+}});
+''';
+    config_path.write_text(config_content, encoding='utf-8');
+    return config_path;
+}
+
+"""Create config files from jac.toml [plugins.client.configs].
+
+Generates JavaScript config files (e.g., postcss.config.js, tailwind.config.js)
+from TOML configuration. Each key in [plugins.client.configs] becomes a config file.
+
+Example jac.toml:
+    [plugins.client.configs.postcss]
+    plugins = ["tailwindcss", "autoprefixer"]
+
+    [plugins.client.configs.tailwind]
+    content = ["./src/**/*.{js,jsx}"]
+
+This generates:
+    - .jac/client/configs/postcss.config.js
+    - .jac/client/configs/tailwind.config.js
+"""
+impl ViteBundler.create_config_files(self: ViteBundler) -> list[Path] {
+    configs = self.config_loader.get_configs();
+    if not configs {
+        return [];
+    }
+    build_dir = self._get_client_dir();
+    configs_dir = build_dir / 'configs';
+    configs_dir.mkdir(parents=True, exist_ok=True);
+    created_files: list[Path] = [];
+    for (config_name, config_data) in configs.items() {
+        config_path = configs_dir / f'{config_name}.config.js';
+
+        # Convert the TOML config to JavaScript module.exports
+        js_content = _toml_config_to_js(config_name, config_data);
+        config_path.write_text(js_content, encoding='utf-8');
+        created_files.append(config_path);
+    }
+    return created_files;
+}
+
+"""Convert TOML config data to JavaScript config file content.
+
+Generates a generic module.exports with the config data as JSON.
+"""
+def _toml_config_to_js(config_name: str, config_data: dict) -> str {
+    return f"module.exports = {json.dumps(config_data, indent=2)};\n";
+}
+
+"""Start Vite dev server as a subprocess."""
+impl ViteBundler.start_dev_server(self: ViteBundler, port: int = 3000) -> Any {
+    import sys;
+    import time;
+    import from jac_client.plugin.utils { ensure_bun_available }
+    # Ensure bun is available before starting dev server
+    if not ensure_bun_available() {
+        raise ClientBundleError(
+            'Bun is required for dev server. Install manually: https://bun.sh'
+        ) from None ;
+    }
+    build_dir = self._get_client_dir();
+    node_modules = build_dir / 'node_modules';
+    # Create/update index.html for dev server (load from compiled/ for HMR)
+    index_html = build_dir / 'index.html';
+    index_content = '''<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Jac App (Dev)</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/compiled/_entry.js"></script>
+  </body>
+</html>
+''';
+    index_html.write_text(index_content, encoding='utf-8');
+    # Ensure dependencies are installed
+    if not node_modules.exists() {
+        generated_package_json = build_dir / 'configs' / 'package.json';
+        if not generated_package_json.exists() {
+            self.create_package_json();
+        }
+        # Temporarily copy package.json for bun install
+        build_package_json = build_dir / 'package.json';
+        if not build_package_json.exists() {
+            shutil.copy2(generated_package_json, build_package_json);
+        }
+        try {
+            print("\n  ⏳ Installing dependencies...\n", flush=True);
+            start_time = time.time();
+            result = subprocess.run(
+                ['bun', 'install'], cwd=build_dir, check=False, text=True
+            );
+            elapsed = time.time() - start_time;
+            if result.returncode != 0 {
+                print(
+                    f"\n  ✖ bun install failed after {elapsed:.1f}s", file=sys.stderr
+                );
+                raise ClientBundleError("Failed to install dependencies") ;
+            }
+            print(f"\n  ✔ Dependencies installed ({elapsed:.1f}s)", flush=True);
+        } finally {
+            # Clean up temp package.json
+            if build_package_json.exists() {
+                build_package_json.unlink();
+            }
+        }
+    }
+    # Find the dev config
+    dev_config = build_dir / 'configs' / 'vite.dev.config.js';
+    if not dev_config.exists() {
+        raise ClientBundleError(
+            "Dev config not found. Call create_dev_vite_config first."
+        ) ;
+    }
+    config_rel = dev_config.relative_to(build_dir);
+    logger.debug(f"Starting Vite dev server on port {port}");
+    # Start Vite in dev mode (let output go to terminal for HMR visibility)
+    process = subprocess.Popen(
+        ['bun', 'x', 'vite', '--config', str(config_rel), '--port', str(port)],
+        cwd=build_dir
+    );
+    return process;
 }