@zenithbuild/core 0.6.2 → 1.0.1

package/README.md

@@ -1,37 +1,38 @@
 # @zenithbuild/core ⚡
 
-The heart of the Zenith framework. High-performance reactive runtime, compiler, and build primitives.
+The execution target and orchestrator for the Zenith framework. Contains the minimal reactive runtime and CLI tools.
 
 ## Overview
 
-Zenith is a modern reactive web framework designed for maximum performance and developer experience. The core package contains the essential building blocks:
-- **Compiler**: Transforms `.zen` files into optimized JavaScript.
-- **Runtime**: A lightweight, efficient reactive system for the browser.
-- **Router**: Lightweight client-side routing.
-- **Build Primitives**: Tools for dev servers and production builds.
+Zenith is a modern reactive web framework designed for maximum performance and developer experience. The core package serves as the **Execution Target**:
+- **Reactivity Engine**: Atomic signals and deep state with zero runtime abstraction.
+- **Lifecycle System**: Efficient `onMount`/`onUnmount` management.
+- **CLI Orchestrator**: Commands (`dev`, `build`, `preview`) that drive the native compiler.
 
 ## Key Components
 
-### 1. Compiler (`/compiler`)
-The Zenith compiler handles parsing and transforming Single File Components (`.zen`). It leverages `parse5` for robust HTML parsing and generates highly optimized render functions.
+### 1. Reactivity (`/core/reactivity`)
+The foundational reactive system. Pure, fast, and deterministic.
 
-### 2. Runtime (`/runtime`)
-Our runtime is designed to be minimal. It manages the reactive cycle, efficient DOM updates, and lifecycle management (like `zenOnMount`).
+### 2. Lifecycle (`/core/lifecycle`)
+Instance-based lifecycle management tied to the DOM.
 
-### 3. Server (`/bin/zen-dev`, `/bin/zen-build`)
-Low-level binaries for orchestrating development and production environments.
+### 3. CLI (`/cli`)
+The command-line interface that orchestrates the system build chain.
 
-## Architecture
+## Coordinated Architecture
 
-Zenith follows a "Compiler-First" philosophy. We shift as much work as possible to build time, keeping the client-side bundle lean and fast.
+Zenith follows a strict "Compiler-First" philosophy:
+- **@zenithbuild/compiler**: Owns all structures, wiring, and build-time guarantees.
+- **@zenithbuild/core**: Owns the minimal runtime execution needed to run compiled plans.
 
-## Usage (Internal)
-
-This package is typically consumed by the Zenith CLI and other ecosystem tools.
+## Usage
 
 ```typescript
-import { compile } from '@zenithbuild/core/compiler';
-// ... compile logic
+import { signal, effect, onMount } from '@zenithbuild/core';
+
+const count = signal(0);
+onMount(() => console.log('Ready'));
 ```
 
 ## License

package/cli/commands/add.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Add Command
+ * @zenithbuild/cli - Add Command
  * 
  * Registers a plugin in the project
  */
@@ -32,6 +32,6 @@ export async function add(pluginName: string, options: AddOptions = {}): Promise
     if (success) {
         logger.info(`Plugin "${pluginName}" has been registered.`)
         logger.info('Note: You may need to install the package manually:')
-        logger.log(`  bun add @zenith/plugin-${pluginName}`)
+        logger.log(`  bun add @zenithbuild/plugin-${pluginName}`)
     }
 }

package/cli/commands/build.ts

@@ -1,13 +1,12 @@
 /**
- * @zenith/cli - Build Command
+ * @zenithbuild/cli - Build Command
  * 
  * Builds the application for production using SSG.
  */
 
-import path from 'path'
 import { requireProject } from '../utils/project'
 import * as logger from '../utils/logger'
-import { buildSSG } from '../../compiler/ssg-build'
+import { buildSSG } from '@zenithbuild/compiler'
 
 export interface BuildOptions {
     outDir?: string

package/cli/commands/dev.ts

@@ -1,19 +1,47 @@
+/**
+ * @zenithbuild/cli - Dev Command
+ * 
+ * Development server with HMR support.
+ * 
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * CLI HARDENING: BLIND ORCHESTRATOR PATTERN
+ * ═══════════════════════════════════════════════════════════════════════════════
+ * 
+ * This file follows the CLI Hardening Plan:
+ * - NO plugin-specific branching (no `if (hasContentPlugin)`)
+ * - NO semantic helpers (no `getContentData()`)
+ * - NO plugin type imports or casts
+ * - ONLY opaque data forwarding via hooks
+ * 
+ * The CLI dispatches lifecycle hooks and collects payloads.
+ * It never understands what the data means.
+ * ═══════════════════════════════════════════════════════════════════════════════
+ */
+
 import path from 'path'
 import fs from 'fs'
 import { serve, type ServerWebSocket } from 'bun'
 import { requireProject } from '../utils/project'
 import * as logger from '../utils/logger'
 import * as brand from '../utils/branding'
-import { compileZenSource } from '../../compiler/index'
-import { discoverLayouts } from '../../compiler/discovery/layouts'
-import { processLayout } from '../../compiler/transform/layoutProcessor'
-import { generateRouteDefinition } from '../../router/manifest'
-import { generateBundleJS } from '../../runtime/bundle-generator'
-import { loadContent } from '../utils/content'
-import { loadZenithConfig } from '../../core/config/loader'
-import { PluginRegistry, createPluginContext } from '../../core/plugins/registry'
-import type { ContentItem } from '../../core/config/types'
-import { compileCssAsync, resolveGlobalsCss } from '../../compiler/css'
+import {
+    compileZenSource,
+    discoverLayouts,
+    processLayout,
+    generateBundleJS,
+    loadZenithConfig,
+    PluginRegistry,
+    createPluginContext,
+    getPluginDataByNamespace,
+    compileCssAsync,
+    resolveGlobalsCss,
+    createBridgeAPI,
+    runPluginHooks,
+    collectHookReturns,
+    buildRuntimeEnvelope,
+    clearHooks,
+    type HookContext
+} from '@zenithbuild/compiler'
 
 export interface DevOptions {
     port?: number
@@ -30,92 +58,58 @@ interface CompiledPage {
 const pageCache = new Map<string, CompiledPage>()
 
 /**
- * Bundle page script using Bun's bundler to resolve npm imports at compile time.
- * This allows ES module imports like `import { gsap } from 'gsap'` to work.
+ * Bundle page script using Rolldown to resolve npm imports at compile time.
+ * Only called when compiler emits a BundlePlan - bundler performs no inference.
  */
-async function bundlePageScript(script: string, projectRoot: string): Promise<string> {
-    // If no import statements, return as-is
-    if (!script.includes('import ')) {
-        return script
-    }
-
-    // Write temp file in PROJECT directory so Bun can find node_modules
-    const tempDir = path.join(projectRoot, '.zenith-cache')
-    if (!fs.existsSync(tempDir)) {
-        fs.mkdirSync(tempDir, { recursive: true })
-    }
-    const tempFile = path.join(tempDir, `bundle-${Date.now()}.js`)
-
-    try {
-        // Write script to temp file
-        fs.writeFileSync(tempFile, script, 'utf-8')
-
-        // Use Bun.build to bundle with npm resolution from project's node_modules
-        const result = await Bun.build({
-            entrypoints: [tempFile],
-            target: 'browser',
-            format: 'esm',
-            minify: false,
-            external: [], // Bundle everything
-        })
-
-        if (!result.success || !result.outputs[0]) {
-            console.error('[Zenith] Bundle errors:', result.logs)
-            return script // Fall back to original
-        }
-
-        // Get the bundled output
-        const bundledCode = await result.outputs[0].text()
-        return bundledCode
-    } catch (error: any) {
-        console.error('[Zenith] Failed to bundle page script:', error.message)
-        return script // Fall back to original
-    } finally {
-        // Clean up temp file
-        try {
-            fs.unlinkSync(tempFile)
-        } catch { }
-    }
-}
+import { bundlePageScript, type BundlePlan, generateRouteDefinition } from '@zenithbuild/compiler'
 
 export async function dev(options: DevOptions = {}): Promise<void> {
     const project = requireProject()
     const port = options.port || parseInt(process.env.PORT || '3000', 10)
     const pagesDir = project.pagesDir
     const rootDir = project.root
-    const contentDir = path.join(rootDir, 'content')
 
     // Load zenith.config.ts if present
     const config = await loadZenithConfig(rootDir)
     const registry = new PluginRegistry()
+    const bridgeAPI = createBridgeAPI()
+
+    // Clear any previously registered hooks (important for restarts)
+    clearHooks()
 
     console.log('[Zenith] Config plugins:', config.plugins?.length ?? 0)
 
-    // Register plugins from config
+    // ============================================
+    // Plugin Registration (Unconditional)
+    // ============================================
+    // CLI registers ALL plugins without checking which ones exist.
+    // Each plugin decides what hooks to register.
     for (const plugin of config.plugins || []) {
         console.log('[Zenith] Registering plugin:', plugin.name)
         registry.register(plugin)
+
+        // Let plugin register its CLI hooks (if it wants to)
+        // CLI does NOT check what the plugin is - it just offers the API
+        if (plugin.registerCLI) {
+            plugin.registerCLI(bridgeAPI)
+        }
     }
 
-    // Initialize content data
-    let contentData: Record<string, ContentItem[]> = {}
-
-    // Initialize plugins with context
-    const hasContentPlugin = registry.has('zenith-content')
-    console.log('[Zenith] Has zenith-content plugin:', hasContentPlugin)
-
-    if (hasContentPlugin) {
-        await registry.initAll(createPluginContext(rootDir, (data) => {
-            console.log('[Zenith] Content plugin set data, collections:', Object.keys(data))
-            contentData = data
-        }))
-    } else {
-        // Fallback to legacy content loading if no content plugin configured
-        console.log('[Zenith] Using legacy content loading from:', contentDir)
-        contentData = loadContent(contentDir)
+    // ============================================
+    // Plugin Initialization (Unconditional)
+    // ============================================
+    // Initialize ALL plugins unconditionally.
+    // If no plugins, this is a no-op. CLI doesn't branch on plugin presence.
+    await registry.initAll(createPluginContext(rootDir))
+
+    // Create hook context - CLI provides this but NEVER uses getPluginData itself
+    const hookCtx: HookContext = {
+        projectRoot: rootDir,
+        getPluginData: getPluginDataByNamespace
     }
 
-    console.log('[Zenith] Content collections loaded:', Object.keys(contentData))
+    // Dispatch lifecycle hook - plugins decide if they care
+    await runPluginHooks('cli:dev:start', hookCtx)
 
     // ============================================
     // CSS Compilation (Compiler-Owned)
@@ -173,8 +167,69 @@ export async function dev(options: DevOptions = {}): Promise<void> {
 
             const routeDef = generateRouteDefinition(pagePath, pagesDir)
 
-            // Bundle the script to resolve npm imports at compile time
-            const bundledScript = await bundlePageScript(result.finalized.js, rootDir)
+
+
+            // Safely strip imports from the top of the script
+            // This relies on the fact that duplicate imports (from Rust codegen)
+            // appear at the beginning of result.finalized.js
+            let jsLines = result.finalized.js.split('\n')
+
+            // Remove lines from top that are imports, whitespace, or comments
+            while (jsLines.length > 0 && jsLines[0] !== undefined) {
+                const line = jsLines[0].trim()
+                if (
+                    line.startsWith('import ') ||
+                    line === '' ||
+                    line.startsWith('//') ||
+                    line.startsWith('/*') ||
+                    line.startsWith('*')
+                ) {
+                    jsLines.shift()
+                } else {
+                    break
+                }
+            }
+
+            let jsWithoutImports = jsLines.join('\n')
+
+            // PATCH: Fix unquoted keys with dashes (Rust codegen bug in jsx_lowerer)
+            // e.g. stroke-width: "1.5" -> "stroke-width": "1.5"
+            // We only apply this to the JS portions (Script and Expressions)
+            // to avoid corrupting the Styles section.
+            const stylesMarker = '// 6. Styles injection'
+            const parts = jsWithoutImports.split(stylesMarker)
+
+            if (parts.length > 1) {
+                // Apply patch only to the JS part
+                parts[0] = parts[0]!.replace(
+                    /(^|[{,])\s*([a-zA-Z][a-zA-Z0-9-]*-[a-zA-Z0-9-]*)\s*:/gm,
+                    '$1"$2":'
+                )
+                jsWithoutImports = parts.join(stylesMarker)
+            } else {
+                // Fallback if marker not found
+                jsWithoutImports = jsWithoutImports.replace(
+                    /(^|[{,])\s*([a-zA-Z][a-zA-Z0-9-]*-[a-zA-Z0-9-]*)\s*:/gm,
+                    '$1"$2":'
+                )
+            }
+
+            // Combine: structured imports first, then cleaned script body
+            const fullScript = (result.finalized.npmImports || '') + '\n\n' + jsWithoutImports
+
+            console.log('[Dev] Page Imports:', result.finalized.npmImports ? result.finalized.npmImports.split('\n').length : 0, 'lines')
+
+            // Bundle ONLY if compiler emitted a BundlePlan (no inference)
+            let bundledScript = fullScript
+            if (result.finalized.bundlePlan) {
+                // Compiler decided bundling is needed - pass plan with proper resolve roots
+                const plan: BundlePlan = {
+                    ...result.finalized.bundlePlan,
+                    entry: fullScript,
+                    resolveRoots: [path.join(rootDir, 'node_modules'), 'node_modules']
+                }
+                bundledScript = await bundlePageScript(plan)
+            }
 
             return {
                 html: result.finalized.html,
@@ -189,10 +244,46 @@ export async function dev(options: DevOptions = {}): Promise<void> {
         }
     }
 
-    // Set up file watching for HMR
+    /**
+     * Generate dev HTML with plugin data envelope
+     * 
+     * CLI collects payloads from plugins via 'cli:runtime:collect' hook.
+     * It serializes blindly - never inspecting what's inside.
+     */
+    async function generateDevHTML(page: CompiledPage): Promise<string> {
+        // Single neutral injection point
+        const runtimeTag = `<script src="/runtime.js"></script>`
+        const scriptTag = `<script type="module">\n${page.script}\n</script>`
+        const allScripts = `${runtimeTag}\n${scriptTag}`
+
+        let html = page.html.includes('</body>')
+            ? page.html.replace('</body>', `${allScripts}\n</body>`)
+            : `${page.html}\n${allScripts}`
+
+        // Ensure DOCTYPE is present to prevent Quirks Mode (critical for SVG namespace)
+        if (!html.trimStart().toLowerCase().startsWith('<!doctype')) {
+            html = `<!DOCTYPE html>\n${html}`
+        }
+
+        return html
+    }
+
+    // ============================================
+    // File Watcher (Plugin-Agnostic)
+    // ============================================
+    // CLI watches files but delegates decisions to plugins via hooks.
+    // No branching on file types that are "content" vs "not content".
     const watcher = fs.watch(path.join(pagesDir, '..'), { recursive: true }, async (event, filename) => {
         if (!filename) return
 
+        // Dispatch file change hook to ALL plugins
+        // Each plugin decides if it cares about this file
+        await runPluginHooks('cli:dev:file-change', {
+            ...hookCtx,
+            filename,
+            event
+        })
+
         if (filename.endsWith('.zen')) {
             logger.hmr('Page', filename)
 
@@ -223,16 +314,13 @@ export async function dev(options: DevOptions = {}): Promise<void> {
             for (const client of clients) {
                 client.send(JSON.stringify({ type: 'style-update', url: '/assets/styles.css' }))
             }
-        } else if (filename.startsWith('content') || filename.includes('zenith-docs')) {
-            logger.hmr('Content', filename)
-            // Reinitialize content plugin to reload data
-            if (registry.has('zenith-content')) {
-                registry.initAll(createPluginContext(rootDir, (data) => {
-                    contentData = data
-                }))
-            } else {
-                contentData = loadContent(contentDir)
-            }
+        } else {
+            // For all other file changes, re-initialize plugins unconditionally
+            // Plugins decide internally whether they need to reload data
+            // CLI does NOT branch on "is this a content file"
+            await registry.initAll(createPluginContext(rootDir))
+
+            // Broadcast reload for any non-code file changes
             for (const client of clients) {
                 client.send(JSON.stringify({ type: 'reload' }))
             }
@@ -255,7 +343,11 @@ export async function dev(options: DevOptions = {}): Promise<void> {
 
             // Handle Zenith assets
             if (pathname === '/runtime.js') {
-                const response = new Response(generateBundleJS(), {
+                // Collect runtime payloads from ALL plugins
+                const payloads = await collectHookReturns('cli:runtime:collect', hookCtx)
+                const envelope = buildRuntimeEnvelope(payloads)
+
+                const response = new Response(generateBundleJS(envelope), {
                     headers: { 'Content-Type': 'application/javascript; charset=utf-8' }
                 })
                 logger.route('GET', pathname, 200, Math.round(performance.now() - startTime), 0, Math.round(performance.now() - startTime))
@@ -305,7 +397,7 @@ export async function dev(options: DevOptions = {}): Promise<void> {
 
                 if (cached) {
                     const renderStart = performance.now()
-                    const html = generateDevHTML(cached, contentData)
+                    const html = await generateDevHTML(cached)
                     const renderEnd = performance.now()
 
                     const totalTime = Math.round(performance.now() - startTime)
@@ -373,16 +465,3 @@ function findPageForRoute(route: string, pagesDir: string): string | null {
 
     return null
 }
-
-function generateDevHTML(page: CompiledPage, contentData: any = {}): string {
-    const runtimeTag = `<script src="/runtime.js"></script>`
-    // Escape </script> sequences in JSON content to prevent breaking the script tag
-    const contentJson = JSON.stringify(contentData).replace(/<\//g, '<\\/')
-    const contentTag = `<script>window.__ZENITH_CONTENT__ = ${contentJson};</script>`
-    // Use type="module" to support ES6 imports from npm packages
-    const scriptTag = `<script type="module">\n${page.script}\n</script>`
-    const allScripts = `${runtimeTag}\n${contentTag}\n${scriptTag}`
-    return page.html.includes('</body>')
-        ? page.html.replace('</body>', `${allScripts}\n</body>`)
-        : `${page.html}\n${allScripts}`
-}

package/cli/commands/index.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Command Registry
+ * @zenithbuild/cli - Command Registry
  * 
  * Central registry for all CLI commands
  */

package/cli/commands/preview.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Preview Command
+ * @zenithbuild/cli - Preview Command
  * 
  * Serves the production build from the distribution directory.
  */

package/cli/commands/remove.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Remove Command
+ * @zenithbuild/cli - Remove Command
  * 
  * Removes a plugin from the project registry
  */
@@ -28,6 +28,6 @@ export async function remove(pluginName: string): Promise<void> {
     if (success) {
         logger.info(`Plugin "${pluginName}" has been unregistered.`)
         logger.info('Note: You may want to remove the package manually:')
-        logger.log(`  bun remove @zenith/plugin-${pluginName}`)
+        logger.log(`  bun remove @zenithbuild/plugin-${pluginName}`)
     }
 }

package/cli/index.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli
+ * @zenithbuild/cli
  * 
  * CLI for Zenith framework - dev server, build tools, and plugin management
  */

package/cli/main.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Shared CLI Execution Logic
+ * @zenithbuild/cli - Shared CLI Execution Logic
  */
 
 import process from 'node:process'

package/cli/utils/logger.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Logger Utility
+ * @zenithbuild/cli - Logger Utility
  * 
  * Colored console output for CLI feedback
  */

package/cli/utils/plugin-manager.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Plugin Manager
+ * @zenithbuild/cli - Plugin Manager
  * 
  * Manages zenith.plugins.json for plugin registration
  */

package/cli/utils/project.ts

@@ -1,5 +1,5 @@
 /**
- * @zenith/cli - Project Utility
+ * @zenithbuild/cli - Project Utility
  * 
  * Detects Zenith project root and configuration
  */
@@ -28,8 +28,8 @@ export function findProjectRoot(startDir: string = process.cwd()): string | null
                 const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
                 const deps = { ...pkg.dependencies, ...pkg.devDependencies }
 
-                // Check for any @zenith/* or @zenithbuild/* dependency
-                const hasZenith = Object.keys(deps).some(d => d.startsWith('@zenith/') || d.startsWith('@zenithbuild/'))
+                // Check for any @zenithbuild/* or @zenithbuild/* dependency
+                const hasZenith = Object.keys(deps).some(d => d.startsWith('@zenithbuild/') || d.startsWith('@zenithbuild/'))
                 if (hasZenith) {
                     return current
                 }
@@ -71,7 +71,7 @@ export function getProject(cwd: string = process.cwd()): ZenithProject | null {
 export function requireProject(cwd: string = process.cwd()): ZenithProject {
     const project = getProject(cwd)
     if (!project) {
-        throw new Error('Not in a Zenith project. Run this command from a directory with @zenith/* dependencies.')
+        throw new Error('Not in a Zenith project. Run this command from a directory with @zenithbuild/* dependencies.')
     }
     return project
 }