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

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

@@ -0,0 +1,513 @@
+"""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';
+    configs_dir.mkdir(exist_ok=True);
+    package_config = self.config_loader.get_package_config();
+    package_json_path = configs_dir / 'package.json';
+    name = package_config.get('name', '');
+    if (not name and project_name) {
+        name = project_name;
+    }
+    if not name {
+        existing_package = self.project_dir / 'package.json';
+        if existing_package.exists() {
+            try {
+                with existing_package.open() as f {
+                    existing_data = json.load(f);
+                    name = existing_data.get('name', '');
+                }
+            } except (json.JSONDecodeError, KeyError) {
+                ;
+            }
+        }
+    }
+    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};
+    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'
+    };
+    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'),
+        'description': package_config.get('description', f"Jac application: {name}"),
+        'type': 'module',
+        'main': 'index.js',
+        'scripts': scripts,
+        'dependencies': dependencies,
+        'devDependencies': dev_dependencies,
+        'babel': babel_config
+    };
+    for (key, value) in package_config.items() {
+        if (
+            key not in {'name','version','description','dependencies','devDependencies'}
+        ) {
+            package_data[key] = value;
+        }
+    }
+    with package_json_path.open('w', encoding='utf-8') as f {
+        json.dump(package_data, f, indent=2);
+    }
+    # Generate tsconfig.json during build time
+    self.create_tsconfig();
+    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';
+    configs_dir.mkdir(exist_ok=True);
+    tsconfig_path = configs_dir / 'tsconfig.json';
+    # Default tsconfig settings
+    default_compiler_options = {
+        'target': 'ES2020',
+        'useDefineForClassFields': True,
+        'lib': ['ES2020', 'DOM', 'DOM.Iterable'],
+        'module': 'ESNext',
+        'skipLibCheck': True,
+        'moduleResolution': 'bundler',
+        'allowImportingTsExtensions': True,
+        'resolveJsonModule': True,
+        'isolatedModules': True,
+        'noEmit': True,
+        'jsx': 'react-jsx',
+        'strict': True,
+        'noUnusedLocals': True,
+        'noUnusedParameters': True,
+        'noFallthroughCasesInSwitch': True
+    };
+    default_include = ['components/**/*'];
+    default_exclude = ['.client-build'];
+    # 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', {});
+    user_include = user_ts_config.get('include', []);
+    user_exclude = user_ts_config.get('exclude', []);
+    # Merge compiler options (user overrides defaults)
+    merged_compiler_options = {** default_compiler_options, ** user_compiler_options};
+    # For include/exclude, use user values if provided, otherwise defaults
+    merged_include = user_include or default_include;
+    merged_exclude = user_exclude or default_exclude;
+    tsconfig_data = {
+        'compilerOptions': merged_compiler_options,
+        'include': merged_include,
+        'exclude': merged_exclude
+    };
+    # Write the config to .client-build/.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/.
+
+        Remove root package.json and move package-lock.json to .jac-client.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() {
+        configs_dir.mkdir(exist_ok=True);
+        if configs_package_lock.exists() {
+            configs_package_lock.unlink();
+        }
+        shutil.move(str(root_package_lock), str(configs_package_lock));
+    }
+    if root_package_json.exists() {
+        root_package_json.unlink();
+    }
+}
+
+"""
+Ensure root package.json exists temporarily for npm 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';
+    root_package_json = self.project_dir / 'package.json';
+    if not generated_package_json.exists() {
+        self.create_package_json();
+    }
+    if not root_package_json.exists() {
+        shutil.copy2(generated_package_json, root_package_json);
+    }
+}
+
+"""Format config object as JavaScript object string."""
+impl ViteBundler._format_config_object(
+    self: ViteBundler, config: dict, indent: int = 0
+) -> str {
+    if not config {
+        return '';
+    }
+    indent_str = ' ' * indent;
+    items = [];
+    for (key, value) in config.items() {
+        if isinstance(value, str) {
+            items.append(f"{indent_str}  {key}: '{value}',");
+        } elif isinstance(value, bool) {
+            items.append(f"{indent_str}  {key}: {str(value).lower()},");
+        } elif isinstance(value, (int, float)) {
+            items.append(f"{indent_str}  {key}: {value},");
+        } elif isinstance(value, <>list) {
+            list_str = ', '.join(repr(v) for v in value);
+            items.append(f"{indent_str}  {key}: [{list_str}],");
+        } elif isinstance(value, <>dict) {
+            nested = self._format_config_object(value, (indent + 2));
+            items.append(f"{indent_str}  {key}: {{{nested}{indent_str}  }},");
+        } else {
+            items.append(f"{indent_str}  {key}: {repr(value)},");
+        }
+    }
+    return '\n'.join(items);
+}
+
+"""Format plugin options as JavaScript object string."""
+impl ViteBundler._format_plugin_options(self: ViteBundler, options: dict) -> str {
+    if not options {
+        return '';
+    }
+    items = [];
+    for (key, value) in options.items() {
+        if isinstance(value, str) {
+            items.append(f"{key}: '{value}'");
+        } elif isinstance(value, bool) {
+            items.append(f"{key}: {str(value).lower()}");
+        } elif isinstance(value, (int, float)) {
+            items.append(f"{key}: {value}");
+        } elif isinstance(value, <>list) {
+            items.append(f"{key}: [{', '.join(repr(v) for v in value)}]");
+        } else {
+            items.append(f"{key}: {repr(value)}");
+        }
+    }
+    return '{ ' + ', '.join(items) + ' }';
+}
+
+"""Get a valid JavaScript variable name from plugin module name."""
+impl ViteBundler._get_plugin_var_name(self: ViteBundler, plugin_name: str) -> str {
+    name = plugin_name.split('/')[-1];
+    name = name.replace('-', '_').replace('.', '_');
+    name = name.lstrip('@');
+    return name;
+}
+
+"""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';
+    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_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();
+        }
+    }
+    try {
+        # Output dir path relative to .client-build/ (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();
+        }
+    }
+    # Calculate compiled directory path for aliases (relative to .client-build/)
+    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';
+    }
+    plugins = [];
+    plugin_imports = [];
+    # TypeScript support is always enabled, so always include React plugin
+    plugin_imports.append('import react from "@vitejs/plugin-react";');
+    plugins.append('    react()');
+    lib_imports = vite_config_data.get('lib_imports', []);
+    for lib_import in lib_imports {
+        if (isinstance(lib_import, str) and lib_import.strip()) {
+            plugin_imports.append(lib_import);
+        }
+    }
+    custom_plugins = vite_config_data.get('plugins', []);
+    for plugin in custom_plugins {
+        if isinstance(plugin, str) {
+            plugins.append(f"    {plugin}");
+        }
+    }
+    plugins_str = ',\n'.join(plugins) if plugins else '';
+    imports_str = '\n'.join(plugin_imports) if plugin_imports else '';
+    # TypeScript extensions are always included
+    extensions = ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json'];
+    extensions_str = ', '.join(f'"{ext}"' for ext in extensions);
+    build_config = vite_config_data.get('build', {});
+    build_overrides_str = self._format_config_object(build_config, indent=4)
+    if (isinstance(build_config, <>dict) and build_config)
+    else '';
+    server_config = vite_config_data.get('server', {});
+    server_config_str = self._format_config_object(server_config, indent=2)
+    if (isinstance(server_config, <>dict) and server_config)
+    else '';
+    resolve_config = vite_config_data.get('resolve', {});
+    resolve_overrides_str = self._format_config_object(resolve_config, indent=6)
+    if (isinstance(resolve_config, <>dict) and resolve_config)
+    else '';
+    imports_section = f"{imports_str}\n" if imports_str else '';
+    newline = '\n';
+    server_section = f"  server: {{{newline}{server_config_str}{newline}  }},{newline}"
+    if server_config_str
+    else '';
+    config_content = f'''import {{ defineConfig }} from "vite";
+import path from "path";
+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
+const buildDir = path.resolve(__dirname, "..");
+const projectRoot = path.resolve(__dirname, "../..");
+
+/**
+ * Vite configuration generated from config.json (in project root)
+ * To customize, edit config.json instead of this file.
+ */
+
+export default defineConfig({{
+  plugins: [{(newline + plugins_str + newline + '  ') if plugins_str else ''}],
+  root: buildDir, // base folder (.client-build/) so vite can find node_modules
+    build: {{
+    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]",
+      }},
+    }},
+    outDir: path.resolve(buildDir, "{output_relative}"), // final bundled output
+    emptyOutDir: true,
+{build_overrides_str}
+  }},
+  publicDir: false,
+{server_section}  resolve: {{
+      alias: {{
+        "@jac-client/utils": path.resolve(buildDir, "{compiled_utils_relative}"),
+        "@jac-client/assets": path.resolve(buildDir, "{compiled_assets_relative}"),
+      }},
+      extensions: [{extensions_str}],
+{resolve_overrides_str}
+  }},
+}});
+''';
+    config_path.write_text(config_content, encoding='utf-8');
+    return config_path;
+}
+
+"""Check if the project has TypeScript support. TypeScript is now enabled by default."""
+impl ViteBundler._has_typescript_support(self: ViteBundler) -> bool {
+    # TypeScript is always enabled by default
+    return True;
+}
+
+"""Read the bundled code and compute its hash."""
+impl ViteBundler.read_bundle(self: ViteBundler) -> tuple[str, str] {
+    bundle_file = self.find_bundle();
+    if not bundle_file {
+        raise ClientBundleError('Vite build completed but no bundle file found') ;
+    }
+    bundle_code = bundle_file.read_text(encoding='utf-8');
+    bundle_hash = hashlib.sha256(bundle_code.encode('utf-8')).hexdigest();
+    return (bundle_code, bundle_hash);
+}
+
+"""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;
+}
+
+"""Find the generated Vite bundle file."""
+impl ViteBundler.find_bundle(self: ViteBundler) -> Optional[Path] {
+    for file in self.output_dir.glob('client.*.js') {
+        return file;
+    }
+    return None;
+}
+
+"""Run Vite build with generated config in .client-build/.jac-client.configs/."""
+impl ViteBundler.build(self: ViteBundler, entry_file: Optional[Path] = None) -> None {
+    self.output_dir.mkdir(parents=True, exist_ok=True);
+    generated_package_json = self.project_dir / '.client-build' / '.jac-client.configs' / 'package.json';
+    if not generated_package_json.exists() {
+        self.create_package_json();
+    } else {
+        # Ensure tsconfig.json exists even if package.json already exists
+        self.create_tsconfig();
+    }
+    try {
+        build_dir = self.project_dir / '.client-build';
+        node_modules = build_dir / 'node_modules';
+        if not node_modules.exists() {
+            # Temporarily copy package.json to .client-build/ for npm install
+            build_package_json = build_dir / 'package.json';
+            configs_package_json = build_dir / '.jac-client.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
+                );
+            } except subprocess.CalledProcessError as e {
+                raise e from ClientBundleError(
+                    f"Failed to install npm dependencies: {e.stderr}"
+                ) ;
+            } except FileNotFoundError {
+                raise None from ClientBundleError(
+                    'npm command not found. Ensure Node.js and npm are installed.'
+                ) ;
+            }
+        }
+        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
+                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)];
+            }
+        } 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_rel = generated_config.relative_to(build_dir);
+            command = ['npx', 'vite', 'build', '--config', str(config_rel)];
+        } else {
+            command = ['npm', '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
+        );
+        if result.returncode != 0 {
+            error_msg = result.stderr or result.stdout or 'Unknown error';
+            raise ClientBundleError(
+                f"Vite build failed:\n{error_msg}\nCommand: {' '.join(command)}"
+            ) from None ;
+        }
+    } finally {
+        # Clean up temporary package.json in .client-build/
+        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();
+            }
+            build_package_lock.rename(configs_package_lock);
+        }
+    }
+}
+
+"""Initialize the Vite bundler."""
+impl ViteBundler.init(
+    self: ViteBundler,
+    project_dir: Path,
+    output_dir: Optional[Path] = None,
+    minify: bool = False,
+    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);
+}

jac_client/plugin/src/import_processor.jac

@@ -0,0 +1,19 @@
+"""Import processing for Vite bundling."""
+import from pathlib { Path }
+import from typing { TYPE_CHECKING }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+
+with entry {
+    if TYPE_CHECKING {
+        import from jaclang.compiler.codeinfo { ClientManifest }
+    }
+}
+
+"""Processes client imports for Vite bundling."""
+class ImportProcessor {
+    def process_vite_imports(
+        self: ImportProcessor, manifest: (ClientManifest | None), module_path: Path
+    ) -> list[(Path | None)];
+
+    def should_process_import(self: ImportProcessor, import_path: Path) -> bool;
+}

jac_client/plugin/src/jac_to_js.jac

@@ -0,0 +1,35 @@
+"""Jac to JavaScript compilation module."""
+import from collections.abc { Callable }
+import from pathlib { Path }
+import from types { ModuleType }
+import from typing { TYPE_CHECKING, Any }
+
+with entry {
+    if TYPE_CHECKING {
+        import from jaclang.compiler.codeinfo { ClientManifest }
+    }
+}
+
+"""Handles compilation of Jac files to JavaScript."""
+class JacToJSCompiler {
+    def init(
+        self: JacToJSCompiler,
+        compile_to_js_func: Callable[([Path], tuple[(str, (ModuleType | None))])],
+        extract_exports_func: Callable[([Any], list[str])],
+        extract_globals_func: Callable[([Any, ModuleType], dict[(str, Any)])]
+    );
+
+    def compile_module(
+        self: JacToJSCompiler, module_path: Path
+    ) -> tuple[str, (ModuleType | None), (ClientManifest | None)];
+
+    def extract_exports(
+        self: JacToJSCompiler, manifest: (ClientManifest | None)
+    ) -> list[str];
+
+    def extract_globals(
+        self: JacToJSCompiler, manifest: (ClientManifest | None), module: ModuleType
+    ) -> dict[str, Any];
+
+    def add_runtime_imports(self: JacToJSCompiler, js_code: str) -> str;
+}

jac_client/plugin/src/package_installer.jac

@@ -0,0 +1,26 @@
+"""Package installer for managing npm dependencies in jac.toml."""
+
+import shutil;
+import subprocess;
+import from pathlib { Path }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+import from .config_loader { JacClientConfig }
+import from .vite_bundler { ViteBundler }
+
+class PackageInstaller {
+    def init(self: PackageInstaller, project_dir: Path);
+    def install_package(
+        self: PackageInstaller,
+        package_name: str,
+        version: (str | None) = None,
+        is_dev: bool = False
+    ) -> None;
+
+    def install_all(self: PackageInstaller) -> None;
+    def _regenerate_and_install(self: PackageInstaller) -> None;
+    def uninstall_package(
+        self: PackageInstaller, package_name: str, is_dev: bool = False
+    ) -> None;
+
+    def list_packages(self: PackageInstaller) -> dict[str, dict[str, str]];
+}

jac_client/plugin/src/vite_bundler.jac

@@ -0,0 +1,36 @@
+"""Vite bundling module."""
+import hashlib;
+import json;
+import shutil;
+import subprocess;
+import from pathlib { Path }
+import from typing { Optional }
+import from jaclang.runtimelib.client_bundle { ClientBundleError }
+import from .config_loader { JacClientConfig }
+"""Handles Vite bundling operations."""
+class ViteBundler {
+    def init(
+        self: ViteBundler,
+        project_dir: Path,
+        output_dir: Optional[Path] = None,
+        minify: bool = False,
+        config_path: Optional[Path] = None
+    );
+
+    def build(self: ViteBundler, entry_file: Optional[Path] = None) -> None;
+    def find_bundle(self: ViteBundler) -> Optional[Path];
+    def find_css(self: ViteBundler) -> Optional[Path];
+    def read_bundle(self: ViteBundler) -> tuple[str, str];
+    def _has_typescript_support(self: ViteBundler) -> bool;
+    def create_vite_config(self: ViteBundler, entry_file: Path) -> Path;
+    def _get_plugin_var_name(self: ViteBundler, plugin_name: str) -> str;
+    def _format_plugin_options(self: ViteBundler, options: dict) -> str;
+    def _format_config_object(self: ViteBundler, config: dict, indent: int = 0) -> str;
+    def _ensure_root_package_json(self: ViteBundler) -> None;
+    def _cleanup_root_package_files(self: ViteBundler) -> None;
+    def create_package_json(
+        self: ViteBundler, project_name: Optional[str] = None
+    ) -> Path;
+
+    def create_tsconfig(self: ViteBundler) -> Path;
+}

jac_client/plugin/vite_client_bundle.jac

@@ -0,0 +1,31 @@
+"""Vite-enhanced client bundle generation for Jac web front-ends."""
+import contextlib;
+import shutil;
+import from collections.abc { Callable }
+import from pathlib { Path }
+import from types { ModuleType }
+import from typing { cast }
+import from jaclang.runtimelib.client_bundle {
+    ClientBundle,
+    ClientBundleBuilder,
+    ClientBundleError
+}
+import from .src { ViteCompiler }
+
+"""Enhanced ClientBundleBuilder that uses Vite for optimized bundling."""
+class ViteClientBundleBuilder(ClientBundleBuilder) {
+    def init(
+        self: ViteClientBundleBuilder,
+        runtime_path: (Path | None) = None,
+        vite_output_dir: (Path | None) = None,
+        vite_package_json: (Path | None) = None,
+        vite_minify: bool = False
+    ) -> None;
+
+    def _get_compiler(self: ViteClientBundleBuilder) -> ViteCompiler;
+    def _compile_bundle(
+        self: ViteClientBundleBuilder, module: ModuleType, module_path: Path
+    ) -> ClientBundle;
+
+    def cleanup_temp_dir(self: ViteClientBundleBuilder) -> None;
+}