@zenithbuild/bundler 1.3.1

package/Cargo.toml

@@ -0,0 +1,65 @@
+[package]
+name = "zenith-bundler"
+version = "0.1.0"
+edition = "2021"
+description = "Rolldown Plugin for the Zenith Framework - Zero-Cost Abstraction Bundler"
+license = "MIT"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+napi = []
+
+[dependencies]
+# CSS Optimization & Pruning
+lightningcss = "1.0.0-alpha.70"
+
+# Serialization
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+# Zenith Compiler (local crate)
+compiler-native = { path = "../zenith-compiler/native/compiler-native", default-features = false }
+
+# Node.js FFI (for TypeScript interface)
+napi = { version = "2.16.0", features = ["async", "serde-json"] }
+napi-derive = "2.16.0"
+
+# Async runtime
+tokio = { version = "1.0", features = ["fs", "macros", "rt-multi-thread"] }
+
+# Concurrent collections for CSS buffering
+dashmap = "5.5"
+
+# ArcStr for Rolldown compatibility
+arcstr = "1.2"
+
+# Error handling
+anyhow = "1.0"
+
+# Regex for CSS class extraction
+regex = "1.10"
+
+# Rolldown from git (latest compatible version)
+# Note: Using git source because crates.io version 0.1.0 has broken oxc_resolver compat
+[dependencies.rolldown]
+git = "https://github.com/rolldown/rolldown"
+branch = "main"
+default-features = false
+
+[dependencies.rolldown_plugin]
+git = "https://github.com/rolldown/rolldown"
+branch = "main"
+default-features = false
+
+[dependencies.rolldown_common]
+git = "https://github.com/rolldown/rolldown"
+branch = "main"
+default-features = false
+
+[build-dependencies]
+napi-build = "2.1.0"
+
+[dev-dependencies]
+pretty_assertions = "1.4"

package/README.md

@@ -0,0 +1,135 @@
+# Zenith Bundler
+
+Zero-Cost Abstraction Bundler for the Zenith Framework.
+
+## Overview
+
+The Zenith Bundler provides capability-based runtime chunking, CSS pruning, and deferred hydration for optimal production builds. Instead of shipping a monolithic runtime, it selectively includes only the capabilities used by each page.
+
+## Architecture
+
+```
+Compiler (ZenIR) → Manifest → Bundler → Optimized Output
+```
+
+### Runtime Slices
+
+| Slice | Size | When Included |
+|-------|------|---------------|
+| **Core** | ~2KB | Always required |
+| **Reactivity** | ~8KB | If `{value}` expressions or state used |
+| **Hydration** | ~5KB | If page is interactive |
+
+## Installation
+
+```bash
+# Rust crate
+cargo add zenith-bundler
+
+# TypeScript package
+bun add @zenithbuild/bundler
+```
+
+## Usage
+
+### Rust
+
+```rust
+use zenith_bundler::{bundle, analyze_manifest, ZenManifest};
+
+let manifest = ZenManifest::new("src/pages/index.zen".to_string());
+let analysis = analyze_manifest(&manifest);
+
+println!("Required slices: {:?}", analysis.required_slices);
+println!("Is static: {}", analysis.is_static);
+```
+
+### TypeScript
+
+```typescript
+import { bundle, generateRuntime } from '@zenithbuild/bundler'
+
+// Full production bundle
+const result = bundle(manifest, { 
+  minifyJs: true,
+  minifyCss: true,
+  basePath: '/assets/'
+})
+
+// Dev server (HMR)
+const { code, slices } = generateRuntime(manifest, true)
+```
+
+## API
+
+### `bundle(manifest, options?)`
+
+Generates complete HTML/JS/CSS output.
+
+**Options:**
+- `minifyJs` - Minify JavaScript (default: true)
+- `minifyCss` - Minify CSS (default: true)
+- `inlineCriticalCss` - Inline critical CSS (default: true)
+- `sourceMaps` - Generate source maps (default: false)
+- `devMode` - Skip optimizations (default: false)
+- `basePath` - Asset base path (default: "/")
+- `lazyLoad` - Lazy load non-critical chunks (default: true)
+- `maxChunkSize` - Max chunk size in bytes (default: 50000)
+
+### `generateRuntime(manifest, devMode?)`
+
+Generates only the runtime code (for HMR/dev server).
+
+### `analyzeManifest(manifest)`
+
+Analyzes a manifest and returns required slices.
+
+## Bundle Size Budgets
+
+| Page Type | Budget |
+|-----------|--------|
+| Static | < 5KB |
+| Interactive | < 20KB |
+| Complex | < 50KB |
+
+Run size gate: `bun run js/scripts/size-gate.ts`
+
+## Testing
+
+```bash
+# Rust tests
+cargo test
+
+# TypeScript tests
+cd js && bun test
+
+# Size gate
+cd js && bun run scripts/size-gate.ts
+```
+
+## Project Structure
+
+```
+zenith-bundler/
+├── src/
+│   ├── lib.rs           # Main exports
+│   ├── analysis.rs      # Manifest analysis
+│   ├── chunking/        # Chunk computation
+│   ├── codegen/         # Runtime generation
+│   ├── css/             # CSS optimization
+│   └── manifest/        # Types & capabilities
+├── tests/
+│   └── integration.rs   # Integration tests
+└── js/
+    ├── src/
+    │   ├── index.ts     # TypeScript API
+    │   ├── types.ts     # TypeScript types
+    │   └── index.test.ts
+    └── scripts/
+        └── size-gate.ts # Bundle size CI gate
+```
+
+## License
+
+MIT
+# zenith-bundler

package/build.rs

@@ -0,0 +1,5 @@
+extern crate napi_build;
+
+fn main() {
+    napi_build::setup();
+}

package/dev-server.js

@@ -0,0 +1,117 @@
+const express = require('express');
+const { ZenithDevController } = require('./index.node'); // Assuming built target via napi
+const path = require('path');
+const chokidar = require('chokidar');
+const { WebSocketServer } = require('ws');
+const http = require('http');
+
+const app = express();
+const port = 3000;
+
+// Initialize Controller (Points to current project root)
+// Default to parent directory (assuming zenith-bundler is inside project or sibling)
+// Adjust this based on where you run the server.
+const start = async (projectRoot = process.env.PROJECT_ROOT || path.resolve(__dirname, '..')) => {
+    console.log(`[DevServer] Starting Zenith for: ${projectRoot}`);
+
+    let controller;
+    try {
+        controller = new ZenithDevController(projectRoot);
+    } catch (e) {
+        console.error("Failed to initialize ZenithDevController:", e);
+        console.error("Ensure you have built the native module: 'napi build --platform'");
+        process.exit(1);
+    }
+
+    // Create HTTP and WS Server
+    const server = http.createServer(app);
+    const wss = new WebSocketServer({ server });
+
+    wss.on('connection', (ws) => {
+        // console.log('[HMR] Client connected');
+    });
+
+    function notifyHMR() {
+        // console.log('[HMR] Broadcasting update signal...');
+        wss.clients.forEach((client) => {
+            if (client.readyState === 1) { // OPEN
+                client.send(JSON.stringify({ type: 'update' }));
+            }
+        });
+    }
+
+    // Watcher Integration (Tactical Fix)
+    const watchPath = path.join(projectRoot, 'src/**/*.zen');
+    console.log(`[Watcher] Watching ${watchPath}`);
+    const watcher = chokidar.watch(watchPath, {
+        ignoreInitial: true
+    });
+
+    watcher.on('change', async (filePath) => {
+        // console.log(`[Watcher] File changed: ${filePath}`);
+        try {
+            // 1. Tell Rust to re-compile (updates the AssetStore in RAM)
+            console.time('Rebuild');
+            await controller.rebuild();
+            console.timeEnd('Rebuild');
+
+            // 2. Tell the Browser to fetch the new assets
+            notifyHMR();
+        } catch (e) {
+            console.error("Rebuild failed:", e);
+        }
+    });
+
+    // Serve Assets
+    app.use(async (req, res, next) => {
+        // 1. Try to serve from memory store
+        const asset = controller.getAsset(req.path);
+
+        if (asset) {
+            if (req.path.endsWith('.js')) {
+                res.setHeader('Content-Type', 'application/javascript');
+            } else if (req.path.endsWith('.css')) {
+                res.setHeader('Content-Type', 'text/css');
+            }
+            return res.send(asset);
+        }
+
+        // 2. SPA / HTML Fallback
+        if (req.path === '/' || !path.extname(req.path)) {
+            res.send(`
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Zenith Dev</title>
+    <script type="module" src="/index.js"></script>
+    <link rel="stylesheet" href="/zenith.css">
+    <script>
+    // HMR Client
+    const ws = new WebSocket('ws://' + location.host);
+    ws.onmessage = (event) => {
+        const msg = JSON.parse(event.data);
+        if (msg.type === 'update') {
+            console.log('[HMR] Update received. Reloading...');
+            location.reload(); 
+        }
+    };
+    ws.onopen = () => console.log("[Zenith] HMR Connected");
+    </script>
+</head>
+<body>
+    <div id="app"></div>
+</body>
+</html>
+        `);
+            return;
+        }
+
+        next();
+    });
+
+    server.listen(port, () => {
+        console.log(`Zenith Dev Server running at http://localhost:${port}`);
+    });
+};
+
+module.exports = { start };

package/index.js

@@ -0,0 +1,18 @@
+const devServer = require('./dev-server.js');
+
+function createZenithBundler() {
+    return {
+        async dev(options) {
+            console.log("Starting Zenith Bundler (Dev)...");
+            // Assuming options has root or fallback
+            const root = options?.root || process.cwd();
+            await devServer.start(root);
+        },
+        async build(options) {
+            console.log("Zenith Bundler Build: Not yet implemented in Phase 6.");
+            // Placeholder for production build integration
+        }
+    };
+}
+
+module.exports = { createZenithBundler };

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@zenithbuild/bundler",
+  "version": "1.3.1",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "index.js"
+}

package/src/bundler.rs

@@ -0,0 +1,81 @@
+//! Zenith Bundler Configuration
+//!
+//! Provides helper functions to create a pre-configured Rolldown bundler
+//! with Zenith's required settings (capability splitting, plugin injection, etc).
+
+use rolldown::{Bundler, BundlerBuilder, BundlerOptions, InputItem};
+use std::sync::Arc;
+
+use crate::plugin::ZenithPlugin;
+
+/// Create a configured Rolldown bundler for a Zenith project
+pub fn create_zenith_bundler(entry_point: &str, components_dir: Option<&str>) -> Bundler {
+    // 1. Initialize the Zenith Plugin
+    let mut plugin = ZenithPlugin::new(entry_point);
+    if let Some(dir) = components_dir {
+        plugin = plugin.with_components_dir(dir);
+    }
+
+    // 2. Configure Bundler Options
+    // Note: manual_chunks is currently experimental in Rolldown Rust API,
+    // we'll need to verify the exact API surface.
+    // For now, we rely on the plugin's dynamic imports to drive chunking naturally,
+    // and we can enhance this with explicit manual_chunks if the API allows.
+
+    let options = BundlerOptions {
+        input: Some(vec![InputItem {
+            name: Some("index".into()),
+            import: "virtual:zenith-entry".into(), // Start with our Hydration Controller
+        }]),
+        // Enable code splitting
+        format: Some(rolldown_common::OutputFormat::Esm),
+        // Ensure we target browser environment
+        platform: Some(rolldown_common::Platform::Browser),
+        // Capability-Based Chunking:
+        // GSAP should be handled as a separate chunk (capability: "anim").
+        // We rely on dynamic imports (import('gsap')) in the user's code to automatically split it.
+        // Explicit manual_chunks can be added here if stricter control is needed.
+        // Capability-based chunking configuration will go here once verified
+        ..Default::default()
+    };
+
+    let builder = BundlerBuilder::default()
+        .with_options(options)
+        .with_plugins(vec![Arc::new(plugin)]);
+
+    builder.build().expect("Failed to build bundler")
+}
+
+/// Create a configured Rolldown bundler for Dev Mode (Watch + HMR + InMemory)
+pub fn create_dev_bundler(
+    entry_point: &str,
+    components_dir: Option<&str>,
+    store: std::sync::Arc<crate::store::AssetStore>,
+) -> Bundler {
+    // 1. Initialize the Zenith Plugin with Store and Dev Mode
+    let mut plugin = ZenithPlugin::new(entry_point)
+        .with_store(store)
+        .with_dev_mode(true);
+
+    if let Some(dir) = components_dir {
+        plugin = plugin.with_components_dir(dir);
+    }
+
+    // 2. Configure Bundler Options (Dev Optimized)
+    let options = BundlerOptions {
+        input: Some(vec![InputItem {
+            name: Some("index".into()),
+            import: "virtual:zenith-entry".into(),
+        }]),
+        format: Some(rolldown_common::OutputFormat::Esm),
+        platform: Some(rolldown_common::Platform::Browser),
+        sourcemap: Some(rolldown_common::SourceMapType::File), // Enable sourcemaps for dev
+        ..Default::default()
+    };
+
+    let builder = BundlerBuilder::default()
+        .with_options(options)
+        .with_plugins(vec![Arc::new(plugin)]);
+
+    builder.build().expect("Failed to build dev bundler")
+}