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

jac_client/plugin/plugin_config.jac

@@ -5,10 +5,13 @@ configuration system, registering:
 - Plugin metadata (name, version)
 - Config schema for [plugins.client] section
 - npm dependency type for [dependencies.npm] section
+- Project templates (client, fullstack)
 """
 
+import os;
 import subprocess;
 import sys;
+import json;
 import from pathlib { Path }
 import from typing { Any }
 import from jaclang.pycore.runtime { hookimpl }
@@ -68,6 +71,11 @@ class JacClientPluginConfig {
                     "type": "dict",
                     "default": {},
                     "description": "TypeScript configuration overrides"
+                },
+                "configs": {
+                    "type": "dict",
+                    "default": {},
+                    "description": "Generate config files for npm packages. Keys are config names (e.g., 'postcss', 'tailwind'), values are the config objects to export."
                 }
             }
         };
@@ -79,15 +87,194 @@ class JacClientPluginConfig {
         return {
             "name": "npm",
             "dev_name": "npm.dev",
-            "cli_flag": "--cl",
-            "install_dir": ".client-build/.jac-client.configs",
+            "cli_flag": "--npm",
+            "install_dir": ".jac/client/configs",
             "install_handler": _npm_install_handler,
             "install_all_handler": _npm_install_all_handler,
             "remove_handler": _npm_remove_handler
         };
     }
+
+    """Register the client and fullstack project templates."""
+    @hookimpl
+    static def register_project_template -> list[dict[str, Any]] {
+        templates: list[dict[str, Any]] = [];
+
+        # Load templates from bundled JSON files
+        for template_name in ["client", "fullstack"] {
+            template = _load_template(template_name);
+            if template {
+                templates.append(template);
+            }
+        }
+
+        return templates;
+    }
+}
+
+# ===============================================================================
+# Template Loader
+# ===============================================================================
+"""Load a template from bundled JSON file."""
+def _load_template(template_name: str) -> dict[str, Any] | None {
+    # Find the template JSON file relative to this module
+    # plugin_config.jac is in jac_client/plugin/, so .parent.parent = jac_client/
+    module_dir = Path(__file__).parent.parent;  # jac_client directory
+    template_path = module_dir / "templates" / f"{template_name}.jacpack";
+
+    if not template_path.exists() {
+        # Fallback: look in installed package location
+        import from importlib.resources { files }
+        try {
+            package_files = files("jac_client");
+            template_path = Path(str(package_files)) / "templates" / f"{template_name}.jacpack";
+        } except Exception {
+            return None;
+        }
+    }
+
+    if not template_path.exists() {
+        return None;
+    }
+
+    try {
+        with open(template_path, "r") as f {
+            data = json.load(f);
+        }
+
+        # Attach the post_create hook
+        data["post_create"] = _post_create_client;
+
+        return data;
+    } except Exception as e {
+        print(
+            f"Warning: Could not load {template_name} template: {e}", file=sys.stderr
+        );
+        return None;
+    }
 }
 
+# ===============================================================================
+# Post-create Hook for Client Template
+# ===============================================================================
+"""Post-create hook to ensure Bun is installed and optionally install packages."""
+def _post_create_client(project_path: Path, project_name: str) -> None {
+    import from jac_client.plugin.src.vite_bundler { ViteBundler }
+    import from jaclang.cli.console { console }
+    import from jac_client.plugin.utils { ensure_bun_available }
+
+    # First, ensure Bun is installed (prompt to install if not)
+    console.print();
+    if not ensure_bun_available() {
+        console.warning("Bun is required for client development");
+        console.print("  After installing Bun, run: jac add --cl\n", style="muted");
+        return;
+    }
+
+    console.print("  ✔ Bun is installed", style="success");
+
+    # Check if package installation should be skipped
+    if os.environ.get("JAC_CLIENT_SKIP_NPM_INSTALL") {
+        console.print(
+            "\n  ⏭ Skipping package installation (JAC_CLIENT_SKIP_NPM_INSTALL is set)",
+            style="muted"
+        );
+        console.print(
+            "  Run 'jac add --npm' when ready to install packages.\n", style="muted"
+        );
+        return;
+    }
+
+    console.print();
+
+    try {
+        # Verify jac.toml exists
+        toml_path = project_path / "jac.toml";
+        if not toml_path.exists() {
+            print(
+                "Warning: jac.toml not found, skipping package installation",
+                file=sys.stderr
+            );
+            return;
+        }
+
+        # Create ViteBundler instance
+        bundler = ViteBundler(project_path);
+
+        # Generate package.json with default packages
+        bundler.create_package_json(project_name=project_name);
+
+        # Ensure .jac/client directory exists
+        client_dir = bundler._get_client_dir();
+        client_dir.mkdir(parents=True, exist_ok=True);
+
+        # Copy package.json to .jac/client/ for bun install
+        configs_package_json = client_dir / 'configs' / 'package.json';
+        build_package_json = client_dir / 'package.json';
+
+        if not configs_package_json.exists() {
+            print(
+                "Warning: package.json was not generated, skipping package installation",
+                file=sys.stderr
+            );
+            return;
+        }
+
+        shutil.copy2(configs_package_json, build_package_json);
+
+        # Run bun install (ensure bun is available first)
+        import from jac_client.plugin.utils { ensure_bun_available }
+        if not ensure_bun_available() {
+            console.warning("Bun is required. Install manually: https://bun.sh");
+            console.print(
+                "  💡 You can install packages later with: jac add --cl\n",
+                style="muted"
+            );
+            # Clean up temporary package.json
+            if build_package_json.exists() {
+                build_package_json.unlink();
+            }
+            return;
+        }
+
+        try {
+            console.print("\n  ⏳ Installing packages...\n", style="cyan");
+            subprocess.run(['bun', 'install'], cwd=client_dir, check=True, timeout=300);
+
+            # Move bun.lockb to configs/ if it was created
+            build_bun_lockb = client_dir / 'bun.lockb';
+            configs_bun_lockb = client_dir / 'configs' / 'bun.lockb';
+            if build_bun_lockb.exists() {
+                if configs_bun_lockb.exists() {
+                    configs_bun_lockb.unlink();
+                }
+                shutil.move(str(build_bun_lockb), str(configs_bun_lockb));
+            }
+
+            console.print("  ✔ Packages installed", style="success");
+        } except subprocess.CalledProcessError as e {
+            console.warning(f"Failed to install packages: {e}");
+            console.print(
+                "  💡 You can install packages later with: jac add --cl\n",
+                style="muted"
+            );
+        } finally {
+            # Clean up temporary package.json
+            if build_package_json.exists() {
+                build_package_json.unlink();
+            }
+        }
+    } except Exception as e {
+        console.warning(f"Could not install default packages: {e}");
+        console.print(
+            "  💡 You can install packages later with: jac add --cl\n", style="muted"
+        );
+    }
+}
+
+# ===============================================================================
+# NPM Dependency Handlers
+# ===============================================================================
 """Install an npm package."""
 def _npm_install_handler(
     config: JacConfig,
@@ -101,15 +288,13 @@ def _npm_install_handler(
         raise RuntimeError("No project root found") ;
     }
 
-    project_dir = config.project_root;
-
     # Add to config (core JacConfig handles this)
-    package_version = version or "latest";
+    package_version: str = version or "latest";
     config.add_dependency(package_name, package_version, dev=is_dev, dep_type="npm");
     config.save();
 
     # Generate package.json and run npm install
-    _regenerate_and_install(project_dir);
+    _regenerate_and_install(Path(str(config.project_root)));
 }
 
 """Install all npm packages from jac.toml."""
@@ -118,7 +303,7 @@ def _npm_install_all_handler(config: JacConfig) -> None {
         raise RuntimeError("No project root found") ;
     }
 
-    _regenerate_and_install(config.project_root);
+    _regenerate_and_install(Path(str(config.project_root)));
 }
 
 """Remove an npm package."""
@@ -129,7 +314,7 @@ def _npm_remove_handler(
         raise RuntimeError("No project root found") ;
     }
 
-    project_dir = config.project_root;
+    project_dir: Path = Path(str(config.project_root));
 
     # Remove from config (core JacConfig handles this)
     result = config.remove_dependency(package_name, dev=is_dev, dep_type="npm");
@@ -144,52 +329,49 @@ def _npm_remove_handler(
     _regenerate_and_install(project_dir);
 }
 
-"""Regenerate package.json from jac.toml and run npm install."""
+"""Regenerate package.json from jac.toml and run bun install."""
 def _regenerate_and_install(project_dir: Path) -> None {
     import from jac_client.plugin.src.vite_bundler { ViteBundler }
+    import from jac_client.plugin.utils { ensure_bun_available }
     import shutil;
 
+    # Ensure Bun is installed before proceeding (prompt to install if not)
+    if not ensure_bun_available() {
+        raise RuntimeError("Bun is required. Install manually: https://bun.sh") from None ;
+    }
+
     bundler = ViteBundler(project_dir);
     bundler.create_package_json();
 
-    # Install to .client-build/ directory where babel processor expects it
-    build_dir = project_dir / '.client-build';
-    build_dir.mkdir(exist_ok=True);
+    # Install to .jac/client/ directory
+    client_dir = bundler._get_client_dir();
+    client_dir.mkdir(parents=True, exist_ok=True);
 
-    # Copy package.json to .client-build/ for npm install
-    configs_package_json = build_dir / '.jac-client.configs' / 'package.json';
-    build_package_json = build_dir / 'package.json';
+    # Copy package.json to .jac/client/ for bun install
+    configs_package_json = client_dir / 'configs' / 'package.json';
+    build_package_json = client_dir / 'package.json';
     if configs_package_json.exists() {
         shutil.copy2(configs_package_json, build_package_json);
     }
 
     try {
-        subprocess.run(
-            ["npm", "install"],
-            cwd=build_dir,
-            check=True,
-            capture_output=True,
-            text=True
-        );
+        # Run bun install
+        subprocess.run(['bun', 'install'], cwd=client_dir, check=True, timeout=300);
     } except subprocess.CalledProcessError as e {
-        raise RuntimeError(f"Failed to install npm packages: {e.stderr}") from e ;
-    } except FileNotFoundError {
-        raise RuntimeError(
-            "npm command not found. Ensure Node.js and npm are installed."
-        ) from None ;
+        raise RuntimeError(f"Failed to install packages: {e}") from e ;
     } finally {
         # Clean up temporary 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 = client_dir / 'bun.lockb';
+        if build_bun_lockb.exists() {
+            configs_bun_lockb = client_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);
         }
     }
 }

jac_client/plugin/src/__init__.jac

@@ -1,6 +1,5 @@
 """Vite client bundle processing modules."""
 import from jac_client.plugin.src.asset_processor { AssetProcessor }
-import from jac_client.plugin.src.babel_processor { BabelProcessor }
 import from jac_client.plugin.src.compiler { ViteCompiler }
 import from jac_client.plugin.src.config_loader { JacClientConfig }
 import from jac_client.plugin.src.import_processor { ImportProcessor }
@@ -10,7 +9,6 @@ import from jac_client.plugin.src.vite_bundler { ViteBundler }
 
 glob __all__ = [
          'AssetProcessor',
-         'BabelProcessor',
          'ViteCompiler',
          'JacClientConfig',
          'ImportProcessor',

jac_client/plugin/src/compiler.jac

@@ -6,7 +6,6 @@ import from types { ModuleType }
 import from typing { TYPE_CHECKING, Any }
 import from jaclang.runtimelib.client_bundle { ClientBundleError }
 import from .asset_processor { AssetProcessor }
-import from .babel_processor { BabelProcessor }
 import from .import_processor { ImportProcessor }
 import from .jac_to_js { JacToJSCompiler }
 import from .vite_bundler { ViteBundler }
@@ -52,6 +51,7 @@ class ViteCompiler {
         source_root: (Path | None) = None
     ) -> None;
 
+    def _get_client_dir(self: ViteCompiler) -> Path;
     def _copy_js_file(self: ViteCompiler, js_path: Path, source_root: Path) -> None;
     def _copy_ts_file(self: ViteCompiler, ts_path: Path, source_root: Path) -> None;
     def _copy_asset_file(
@@ -59,7 +59,7 @@ class ViteCompiler {
     ) -> None;
 
     def copy_root_assets(self: ViteCompiler) -> None;
-    def create_entry_file(self: ViteCompiler) -> None;
+    def create_entry_file(self: ViteCompiler, module_path: Path) -> None;
     def compile_and_bundle(
         self: ViteCompiler, module: ModuleType, module_path: Path
     ) -> tuple[str, str, list[str], list[str]];

jac_client/plugin/src/config_loader.jac

@@ -21,6 +21,7 @@ class JacClientConfig(PluginConfigBase) {
     def save(self: JacClientConfig) -> None;
     def get_vite_config(self: JacClientConfig) -> dict[str, Any];
     def get_ts_config(self: JacClientConfig) -> dict[str, Any];
+    def get_configs(self: JacClientConfig) -> dict[str, Any];
     def get_package_config(self: JacClientConfig) -> dict[str, Any];
     def add_dependency(
         self: JacClientConfig, name: str, version: str, is_dev: bool = False

jac_client/plugin/src/desktop_config.jac

@@ -0,0 +1,31 @@
+"""Configuration loader for Desktop target (Tauri).
+
+This module provides configuration access for the desktop target.
+Configuration is loaded from jac.toml under [desktop] section.
+
+Similar to JacClientConfig but loads [desktop] directly (not under [plugins]).
+"""
+import from pathlib { Path }
+import from typing { Any }
+import from jaclang.project.config { JacConfig, get_config }
+
+"""Desktop target configuration loader.
+
+Provides access to desktop/Tauri configuration
+from the [desktop] section of jac.toml.
+"""
+class DesktopConfig {
+    has project_dir: Path | None = None,
+        _config: dict[str, Any] | None = None,
+        _jac_config: JacConfig | None = None;
+
+    def init(self: DesktopConfig, project_dir: Path | None = None) -> None;
+    def load(self: DesktopConfig) -> dict[str, Any];
+    def get_desktop_config(self: DesktopConfig) -> dict[str, Any];
+    def get_window_config(self: DesktopConfig) -> dict[str, Any];
+    def get_platforms_config(self: DesktopConfig) -> dict[str, Any];
+    def get_features_config(self: DesktopConfig) -> dict[str, Any];
+    def validate(self: DesktopConfig) -> None;
+    def get_default_config(self: DesktopConfig) -> dict[str, Any];
+    # def _get_jac_config(self: DesktopConfig) -> JacConfig;
+}

jac_client/plugin/src/impl/compiler.impl.jac

@@ -1,9 +1,21 @@
-"""Compile module and dependencies, then bundle with Vite."""
+"""Get the client build directory from project config."""
+impl ViteCompiler._get_client_dir(self: ViteCompiler) -> 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';
+}
 
+"""Compile module and dependencies, then bundle with Vite."""
 impl ViteCompiler.compile_and_bundle(
     self: ViteCompiler, module: ModuleType, module_path: Path
 ) -> tuple[str, str, list[str], list[str]] {
-    self.compile_runtime_utils();
     (module_js, mod, module_manifest) = self.jac_compiler.compile_module(module_path);
     collected_exports: set[str] = set(
         self.jac_compiler.extract_exports(module_manifest)
@@ -15,15 +27,14 @@ impl ViteCompiler.compile_and_bundle(
         collected_exports=collected_exports,
         collected_globals=collected_globals
     );
+    # Compile runtime AFTER dependencies so it overwrites any dependency-compiled
+    # version of client_runtime.js with the proper ES module exports
+    self.compile_runtime_utils();
     self.copy_root_assets();
-    self.create_entry_file();
-    self.babel_processor.compile();
-    self.babel_processor.copy_assets_after_compile(
-        self.compiled_dir,
-        (self.project_dir / '.client-build' / 'build'),
-        self.asset_processor
-    );
-    entry_file = self.project_dir / '.client-build' / 'build' / 'main.js';
+    self.create_entry_file(module_path);
+    # Vite handles JSX/TSX transpilation natively with Bun - no Babel needed
+    # Vite builds directly from compiled/ directory
+    entry_file = self.compiled_dir / '_entry.js';
     self.vite_bundler.build(entry_file=entry_file);
     (bundle_code, bundle_hash) = self.vite_bundler.read_bundle();
     client_exports = sorted(collected_exports);
@@ -32,9 +43,12 @@ impl ViteCompiler.compile_and_bundle(
 }
 
 """Create the main entry file for Vite bundling."""
-impl ViteCompiler.create_entry_file(self: ViteCompiler) -> None {
-    entry_file = self.compiled_dir / 'main.js';
-    entry_content = 'import React from "react";\nimport { createRoot } from "react-dom/client";\nimport { app as App } from "./app.js";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(<App />);\n';
+impl ViteCompiler.create_entry_file(self: ViteCompiler, module_path: Path) -> None {
+    # Use _entry.js to avoid conflict with compiled modules that may be named main.js
+    entry_file = self.compiled_dir / '_entry.js';
+    # Derive the app module filename from the entry point (e.g., main.jac -> main.js, app.jac -> app.js)
+    app_module_name = module_path.stem;
+    entry_content = f'import React from "react";\nimport {{ createRoot }} from "react-dom/client";\nimport {{ app as App }} from "./{app_module_name}.js";\nimport {{ JacClientErrorBoundary, ErrorFallback }} from "@jac/runtime";\n\nconst root = createRoot(document.getElementById("root"));\nroot.render(\n\tReact.createElement(\n\t\tJacClientErrorBoundary,{{ FallbackComponent: ErrorFallback }},\n\t\tReact.createElement(App, null)\n\t)\n);\n';
     entry_file.write_text(entry_content, encoding='utf-8');
 }
 
@@ -44,11 +58,10 @@ impl ViteCompiler.copy_root_assets(self: ViteCompiler) -> None {
     compiled_assets_dir = self.compiled_dir / 'assets';
     if (root_assets_dir.exists() and root_assets_dir.is_dir()) {
         self.asset_processor.copy_assets(root_assets_dir, compiled_assets_dir);
-    }
-    # Copy configured_asset files from root assets/ to build assets/ (bypassing compiled)
-    build_assets_dir = self.project_dir / '.client-build' / 'build' / 'assets';
-    if (root_assets_dir.exists() and root_assets_dir.is_dir()) {
-        self.asset_processor.copy_custom_asset_types(root_assets_dir, build_assets_dir);
+        # Copy configured custom asset types to compiled/assets/
+        self.asset_processor.copy_custom_asset_types(
+            root_assets_dir, compiled_assets_dir
+        );
     }
 }
 
@@ -149,12 +162,46 @@ impl ViteCompiler.compile_dependencies_recursively(
     combined_js = self.jac_compiler.add_runtime_imports(module_js);
     try {
         relative_path = module_path.relative_to(source_root);
-        output_path = self.compiled_dir / relative_path.with_suffix('.js');
+        # Handle compound extensions like .cl.jac, .impl.jac -> .js
+        rel_str = str(relative_path);
+        for compound_ext in ['.cl.jac', '.impl.jac', '.test.jac'] {
+            if rel_str.endswith(compound_ext) {
+                rel_str = rel_str[:-len(compound_ext)] + '.js';
+                break;
+            }
+        } else {
+            rel_str = str(relative_path.with_suffix('.js'));
+        }
+        output_path = self.compiled_dir / rel_str;
     } except ValueError {
-        output_path = self.compiled_dir / f"{module_path.stem}.js";
+        # Handle compound extensions in filename
+        name = module_path.name;
+        for compound_ext in ['.cl.jac', '.impl.jac', '.test.jac'] {
+            if name.endswith(compound_ext) {
+                name = name[:-len(compound_ext)] + '.js';
+                break;
+            }
+        } else {
+            name = module_path.stem + '.js';
+        }
+        output_path = self.compiled_dir / name;
     }
     output_path.parent.mkdir(parents=True, exist_ok=True);
-    output_path.write_text(combined_js, encoding='utf-8');
+    # Add source file header comment for better error messages
+    source_header = f"/* Source: {module_path} */\n";
+    # Add ES module exports so Vite can resolve named imports between modules
+    module_export_names = sorted(set(exports_list + list(non_root_globals.keys())));
+    if module_export_names {
+        import re;
+        # Strip any existing export declarations to avoid duplicates
+        clean_combined_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', combined_js);
+        clean_combined_js = re.sub(
+            r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_combined_js
+        );
+        export_stmt = f"\nexport {{ {', '.join(module_export_names)} }};\n";
+        combined_js = clean_combined_js + export_stmt;
+    }
+    output_path.write_text(source_header + combined_js, encoding='utf-8');
     if (not manifest or not manifest.imports) {
         return;
     }
@@ -193,8 +240,29 @@ impl ViteCompiler.compile_runtime_utils(self: ViteCompiler) -> tuple[str, list[s
     runtimeutils_exports_list = self.jac_compiler.extract_exports(
         runtimeutils_manifest
     );
-    all_exports = sorted(set((runtimeutils_exports_list + self.ROUTER_EXPORTS)));
-    combined_runtime_utils_js = runtimeutils_js;
+    # Include both function exports and glob exports (e.g., useState, useEffect)
+    glob_names = list(runtimeutils_manifest.globals) if runtimeutils_manifest else [];
+    all_exports = sorted(
+        set(runtimeutils_exports_list + self.ROUTER_EXPORTS + glob_names)
+    );
+    # Strip all existing export statements from compiled JS to avoid duplicates.
+    # The codegen produces `export let`, `export function`, `export class`, and
+    # `export { ... }` forms. We remove the export keyword from declarations and
+    # remove export blocks entirely, then add one comprehensive export at the end.
+    import re;
+    clean_js = re.sub(r'\nexport\s*\{[^}]*\}\s*;?\s*', '\n', runtimeutils_js);
+    clean_js = re.sub(r'\bexport\s+(let|const|var|function|class)\b', r'\1', clean_js);
+    # Append single comprehensive ES module export for Vite to resolve @jac/runtime
+    export_names = [
+        e
+        for e in all_exports
+        if not e.startswith('_')
+    ];
+    # Also include internal names that are imported by compiled modules
+    internal_exports = ['__jacJsx', '__jacSpawn', '__jacCallFunction'];
+    all_export_names = sorted(set(export_names + internal_exports));
+    export_stmt = f"\nexport {{ {', '.join(all_export_names)} }};\n";
+    combined_runtime_utils_js = clean_js + export_stmt;
     self.compiled_dir.mkdir(parents=True, exist_ok=True);
     (self.compiled_dir / 'client_runtime.js').write_text(
         combined_runtime_utils_js, encoding='utf-8'
@@ -228,24 +296,25 @@ impl ViteCompiler.init(
         ) ;
     }
     self.vite_package_json = vite_package_json;
-    # If package.json is in .client-build/.jac-client.configs/, go up two levels to get project root
+    # Detect project root: package.json may be in .jac/client/configs/ or project root
     if (
-        vite_package_json.parent.name == '.jac-client.configs'
-        and vite_package_json.parent.parent.name == '.client-build'
+        vite_package_json.parent.name == 'configs'
+        and vite_package_json.parent.parent.name == 'client'
+        and vite_package_json.parent.parent.parent.name == '.jac'
     ) {
-        self.project_dir = vite_package_json.parent.parent.parent;
-    } elif (vite_package_json.parent.name == '.jac-client.configs') {
+        # .jac/client/configs/package.json -> go up 3 levels to project root
+        self.project_dir = vite_package_json.parent.parent.parent.parent;
+    } elif (vite_package_json.parent.name == 'configs') {
         self.project_dir = vite_package_json.parent.parent;
     } else {
         self.project_dir = vite_package_json.parent;
     }
     self.runtime_path = runtime_path;
-    self.compiled_dir = self.project_dir / '.client-build' / 'compiled';
+    self.compiled_dir = self._get_client_dir() / 'compiled';
     self.jac_compiler = JacToJSCompiler(
         compile_to_js_func, extract_exports_func, extract_globals_func
     );
     self.import_processor = ImportProcessor();
     self.asset_processor = AssetProcessor();
-    self.babel_processor = BabelProcessor(self.project_dir);
     self.vite_bundler = ViteBundler(self.project_dir, vite_output_dir, vite_minify);
 }

jac_client/plugin/src/impl/config_loader.impl.jac

@@ -27,6 +27,7 @@ impl JacClientConfig.get_default_config(self: JacClientConfig) -> dict[str, Any]
             'resolve': {}
         },
         'ts': {'compilerOptions': {}, 'include': [], 'exclude': []},
+        'configs': {},  # Generic config file generation: { "postcss": {...}, "tailwind": {...} }
         'package': {
             'name': '',
             'version': '1.0.0',
@@ -61,6 +62,7 @@ impl JacClientConfig.load(self: JacClientConfig) -> dict[str, Any] {
     user_config: dict[str, Any] = {
         'vite': client_config.get('vite', {}),
         'ts': client_config.get('ts', {}),
+        'configs': client_config.get('configs', {}),
         'package': {
             'name': jac_config.project.name,
             'version': jac_config.project.version,
@@ -91,6 +93,12 @@ impl JacClientConfig.get_ts_config(self: JacClientConfig) -> dict[str, Any] {
     return config.get('ts', {});
 }
 
+"""Get generic config files to generate (postcss, tailwind, etc.)."""
+impl JacClientConfig.get_configs(self: JacClientConfig) -> dict[str, Any] {
+    config = self.load();
+    return config.get('configs', {});
+}
+
 """Save configuration back to jac.toml using core JacConfig."""
 impl JacClientConfig.save(self: JacClientConfig) -> None {
     jac_config = self.get_jac_config();