@zenithbuild/core 1.2.2 → 1.2.4

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,5 +1,5 @@
 /**
- * @zenith/cli - Dev Command
+ * @zenithbuild/cli - Dev Command
  * 
  * Development server with HMR support.
  * 
@@ -24,22 +24,24 @@ 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 '@zenithbuild/router'
-import { generateBundleJS } from '../../runtime/bundle-generator'
-import { loadZenithConfig } from '../../core/config/loader'
-import { PluginRegistry, createPluginContext, getPluginDataByNamespace } from '../../core/plugins/registry'
-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 '../../core/plugins/bridge'
+} from '@zenithbuild/compiler'
 
 export interface DevOptions {
     port?: number
@@ -56,53 +58,10 @@ 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()
@@ -208,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,
@@ -231,25 +251,21 @@ export async function dev(options: DevOptions = {}): Promise<void> {
      * It serializes blindly - never inspecting what's inside.
      */
     async function generateDevHTML(page: CompiledPage): Promise<string> {
-        // Collect runtime payloads from ALL plugins
-        // CLI doesn't know which plugins will respond - it just collects
-        const payloads = await collectHookReturns('cli:runtime:collect', hookCtx)
-
-        // Build envelope - CLI doesn't know what's inside
-        const envelope = buildRuntimeEnvelope(payloads)
-
-        // Escape </script> sequences in JSON to prevent breaking the script tag
-        const envelopeJson = JSON.stringify(envelope).replace(/<\//g, '<\\/')
-
-        // Single neutral injection point - NOT plugin-specific
-        const runtimeTag = `<script src="/runtime.js"></script>`
-        const pluginDataTag = `<script>window.__ZENITH_PLUGIN_DATA__ = ${envelopeJson};</script>`
+        // Single neutral injection point
+        const runtimeTag = `<script type="module" src="/runtime.js"></script>`
         const scriptTag = `<script type="module">\n${page.script}\n</script>`
-        const allScripts = `${runtimeTag}\n${pluginDataTag}\n${scriptTag}`
+        const allScripts = `${runtimeTag}\n${scriptTag}`
 
-        return page.html.includes('</body>')
+        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
     }
 
     // ============================================
@@ -327,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))

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
 }

package/core/components/ErrorPage.zen

@@ -0,0 +1,218 @@
+<script setup="ts">
+// ErrorPage.zen
+// A high-fidelity, magazine-style error page for Zenith developers.
+
+import { zenOnMount, zenSignal } from 'zenith:runtime';
+import gsap from 'gsap';
+
+interface ErrorProps {
+    file: string;
+    line: number;
+    column: number;
+    message: string;
+    errorType: string;
+    code: string;
+    guarantee?: string;
+    context?: string;
+    hints?: string[];
+    stack?: string;
+    isProd?: boolean;
+}
+
+const { 
+    file, 
+    line, 
+    column, 
+    message, 
+    errorType, 
+    code, 
+    guarantee, 
+    context, 
+    hints = [], 
+    stack,
+    isProd = false 
+} = zenProps<ErrorProps>();
+
+const showAdvanced = zenSignal(false);
+const errorRef = zenRef<HTMLElement>();
+
+zenOnMount(() => {
+    const ctx = gsap.context(() => {
+        // Fade in main container
+        gsap.from('.error-hero', {
+            opacity: 0,
+            y: 30,
+            duration: 0.8,
+            ease: 'expo.out'
+        });
+
+        // Stagger in details
+        gsap.from(['.error-meta', '.error-message', '.error-hints > div'], {
+            opacity: 0,
+            x: -20,
+            stagger: 0.1,
+            duration: 0.6,
+            delay: 0.4,
+            ease: 'power2.out'
+        });
+
+        // Fade in code/context
+        gsap.from('.error-context', {
+            opacity: 0,
+            scale: 0.98,
+            duration: 1,
+            delay: 0.6,
+            ease: 'expo.out'
+        });
+    }, errorRef.current);
+
+    return () => ctx.revert();
+});
+
+const toggleAdvanced = () => showAdvanced(!showAdvanced());
+
+</script>
+
+<div class="error-page-container min-h-screen bg-background text-foreground font-body overflow-hidden selection:bg-red-500/30" ref={errorRef}>
+    <!-- Sticky Header -->
+    <header class="p-6 md:p-10 flex justify-between items-center border-b border-border/50">
+        <div class="flex items-center gap-3">
+            <div class="w-2 h-2 rounded-full bg-red-500 animate-pulse"></div>
+            <span class="text-[10px] font-bold uppercase tracking-[0.2em] text-muted-foreground">Zenith Developer Environment</span>
+        </div>
+        <a href="/documentation" class="text-[10px] font-bold uppercase tracking-widest hover:text-red-500 transition-colors">Documentation</a>
+    </header>
+
+    <main class="max-w-[1400px] mx-auto px-8 md:px-16 py-16 md:py-24 grid grid-cols-1 lg:grid-cols-[1.2fr_0.8fr] gap-16 md:gap-24">
+        
+        <!-- Left Column: Primary Error Info -->
+        <section class="space-y-12">
+            <div class="error-hero space-y-6">
+                <div class="inline-block px-3 py-1 bg-red-500/10 border border-red-500/20 rounded-full">
+                    <span class="text-[10px] font-black uppercase text-red-500 tracking-tighter">{code}</span>
+                </div>
+                <h1 class="text-5xl md:text-7xl font-black tracking-tight leading-[0.9] uppercase">
+                    Something <br/> <span class="text-red-500">Went Wrong</span>
+                </h1>
+            </div>
+
+            <div class="error-meta flex flex-wrap gap-8 py-8 border-y border-border/30">
+                <div class="space-y-1">
+                    <span class="text-[9px] uppercase font-bold text-muted-foreground tracking-widest">Location</span>
+                    <p class="text-sm font-mono truncate max-w-[300px]">{file}:{line}:{column}</p>
+                </div>
+                <div class="space-y-1">
+                    <span class="text-[9px] uppercase font-bold text-muted-foreground tracking-widest">Type</span>
+                    <p class="text-sm font-mono">{errorType}</p>
+                </div>
+            </div>
+
+            <div class="error-message space-y-4">
+                <p class="text-2xl md:text-3xl font-medium leading-tight text-foreground/90">
+                    {message}
+                </p>
+                {guarantee && (
+                    <div class="p-6 bg-secondary/50 rounded-2xl border border-border/50">
+                        <span class="text-[9px] uppercase font-black text-primary tracking-widest block mb-2">Zenith Guarantee</span>
+                        <p class="text-sm italic opacity-80">{guarantee}</p>
+                    </div>
+                )}
+            </div>
+
+            {hints.length > 0 && (
+                <div class="error-hints space-y-4 pt-10">
+                    <h3 class="text-xs font-black uppercase tracking-[0.2em] text-muted-foreground mb-6">Suggestions</h3>
+                    {hints.map(hint => (
+                        <div key={hint} class="flex gap-4 items-start p-4 hover:bg-secondary/30 transition-colors rounded-xl border border-transparent hover:border-border/50">
+                            <span class="text-red-500 mt-1">→</span>
+                            <p class="text-sm">{hint}</p>
+                        </div>
+                    ))}
+                </div>
+            )}
+        </section>
+
+        <!-- Right Column: Context & Visuals -->
+        <section class="error-context space-y-8">
+            <div class="relative group">
+                <div class="absolute -inset-1 bg-gradient-to-tr from-red-500/20 to-transparent blur-2xl opacity-50"></div>
+                <div class="relative bg-zinc-950 rounded-3xl border border-white/10 overflow-hidden shadow-2xl">
+                    <div class="flex items-center justify-between px-6 py-4 border-b border-white/5 bg-zinc-900/50">
+                        <span class="text-[10px] font-bold uppercase tracking-widest text-zinc-500">Contextual Snippet</span>
+                        <div class="flex gap-1.5">
+                            <div class="w-2.5 h-2.5 rounded-full bg-white/10"></div>
+                            <div class="w-2.5 h-2.5 rounded-full bg-white/10"></div>
+                            <div class="w-2.5 h-2.5 rounded-full bg-white/10"></div>
+                        </div>
+                    </div>
+                    <div class="p-8 font-mono text-sm leading-relaxed overflow-x-auto text-zinc-300">
+                        {context ? (
+                            <pre><code>{context}</code></pre>
+                        ) : (
+                            <div class="py-12 text-center opacity-30 select-none">
+                                <p class="text-[10px] uppercase tracking-widest">No code snippet available</p>
+                            </div>
+                        )}
+                    </div>
+                </div>
+            </div>
+
+            <!-- Advanced Section -->
+            {!isProd && (
+                <div class="pt-8">
+                    <button 
+                        onClick={toggleAdvanced}
+                        class="flex items-center gap-2 text-[10px] font-black uppercase tracking-widest text-muted-foreground hover:text-foreground transition-colors group"
+                    >
+                        {showAdvanced() ? 'Collapse Details' : 'View Stack Trace'}
+                        <span class={`transition-transform duration-300 ${showAdvanced() ? 'rotate-180' : ''}`}>↓</span>
+                    </button>
+
+                    {showAdvanced() && (
+                        <div class="mt-8 space-y-6 animate-in fade-in slide-in-from-top-4 duration-500">
+                            {stack && (
+                                <div class="p-6 bg-zinc-950 rounded-2xl border border-white/5 overflow-x-auto">
+                                    <span class="text-[9px] uppercase font-bold text-zinc-500 tracking-widest block mb-4">Runtime Stack</span>
+                                    <pre class="text-[11px] font-mono text-zinc-500 leading-tight"><code>{stack}</code></pre>
+                                </div>
+                            )}
+                        </div>
+                    )}
+                </div>
+            )}
+        </section>
+    </main>
+
+    <!-- Footer Decoration -->
+    <div class="fixed bottom-0 left-0 w-full h-[30vh] pointer-events-none opacity-[0.03] select-none flex items-end justify-center overflow-hidden">
+        <span class="text-[25vw] font-black tracking-tighter leading-none translate-y-1/4 uppercase">ZENITH</span>
+    </div>
+</div>
+
+<style>
+.error-page-container {
+    --primary: #ef4444; /* red-500 */
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.4; }
+}
+
+.animate-pulse {
+    animation: pulse 2s cubic-bezier(0.4, 0, 0.6, 1) infinite;
+}
+
+/* Custom scrollbar for context box */
+.error-context ::-webkit-scrollbar {
+    height: 4px;
+    width: 4px;
+}
+.error-context ::-webkit-scrollbar-track {
+    background: transparent;
+}
+.error-context ::-webkit-scrollbar-thumb {
+    background: rgba(255, 255, 255, 0.1);
+    border-radius: 10px;
+}
+</style>

package/core/components/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Core Components
+ * 
+ * Reusable components provided by zenith-core.
+ */
+
+// Export path constants for component resolution
+export const CORE_COMPONENTS = {
+    ErrorPage: '@zenithbuild/core/components/ErrorPage.zen'
+} as const;
+
+// Component path resolver
+export function getCoreComponentPath(componentName: keyof typeof CORE_COMPONENTS): string {
+    return CORE_COMPONENTS[componentName];
+}

package/core/config.ts

@@ -0,0 +1 @@
+export * from '@zenithbuild/compiler/config';