@zenithbuild/compiler 1.0.16 → 1.3.1

package/dist/bundler.js

@@ -1,86 +0,0 @@
-/**
- * @zenithbuild/core - Page Script Bundler
- *
- * COMPILER-FIRST ARCHITECTURE
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * This bundler performs ZERO inference. It executes exactly what the compiler specifies.
- *
- * Rules:
- * - If a BundlePlan is provided, bundling MUST occur
- * - If bundling fails, throw a hard error (no fallback)
- * - The bundler never inspects source code for intent
- * - No temp files, no heuristics, no recovery
- *
- * Bundler failure = compiler bug.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-import { rolldown } from 'rolldown';
-/**
- * Execute a compiler-emitted BundlePlan
- *
- * This is a PURE PLAN EXECUTOR. It does not:
- * - Inspect source code for imports
- * - Decide whether bundling is needed
- * - Fall back on failure
- * - Use temp files
- *
- * @param plan - Compiler-emitted BundlePlan (must exist; caller must not call if no plan)
- * @throws Error if bundling fails (no fallback, no recovery)
- */
-export async function bundlePageScript(plan) {
-    // Virtual entry module ID
-    const VIRTUAL_ENTRY = '\0zenith:entry';
-    // Build virtual modules map from plan
-    const virtualModules = new Map();
-    virtualModules.set(VIRTUAL_ENTRY, plan.entry);
-    for (const vm of plan.virtualModules) {
-        virtualModules.set(vm.id, vm.code);
-    }
-    // Execute Rolldown with plan-specified configuration
-    // No inference, no heuristics, no semantic analysis
-    const bundle = await rolldown({
-        input: VIRTUAL_ENTRY,
-        platform: plan.platform,
-        resolve: {
-            modules: plan.resolveRoots
-        },
-        plugins: [{
-                name: 'zenith-virtual',
-                resolveId(source) {
-                    // Virtual modules from plan
-                    if (virtualModules.has(source)) {
-                        return { id: source, moduleSideEffects: false };
-                    }
-                    // Special case: zenith:content namespace
-                    if (source === 'zenith:content') {
-                        return { id: '\0zenith:content', moduleSideEffects: false };
-                    }
-                    return null;
-                },
-                load(id) {
-                    return virtualModules.get(id) ?? null;
-                }
-            }],
-        // DETERMINISTIC OUTPUT: Disable all semantic optimizations
-        // Tree-shaking implies semantic analysis - bundler must not infer
-        treeshake: false,
-        // HARD FAILURE on unresolved imports - no silent external treatment
-        onLog(level, log) {
-            if (log.code === 'UNRESOLVED_IMPORT') {
-                throw new Error(`[Zenith Bundler] Unresolved import: ${log.message}. ` +
-                    `This is a compiler error - the BundlePlan references a module that cannot be resolved.`);
-            }
-        }
-    });
-    // Generate output with plan-specified format
-    const { output } = await bundle.generate({
-        format: plan.format
-    });
-    // Hard failure if no output - this is a compiler bug
-    if (!output[0]?.code) {
-        throw new Error('[Zenith Bundler] Rolldown produced no output. ' +
-            'This is a compiler error - the BundlePlan was invalid or Rolldown failed silently.');
-    }
-    return output[0].code;
-}

package/dist/core/components/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * Core Components
- *
- * Reusable components provided by zenith-core.
- */
-export declare const CORE_COMPONENTS: {
-    readonly ErrorPage: "@zenithbuild/core/components/ErrorPage.zen";
-};
-export declare function getCoreComponentPath(componentName: keyof typeof CORE_COMPONENTS): string;

package/dist/core/components/index.js

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

package/dist/core/config/index.d.ts

@@ -1,11 +0,0 @@
-/**
- * Zenith Config
- *
- * Public exports for zenith/config
- *
- * Core exports ONLY generic plugin infrastructure.
- * Plugin-specific types are owned by their respective plugins.
- */
-export { defineConfig } from './types';
-export type { ZenithConfig, ZenithPlugin, PluginContext, PluginData } from './types';
-export { loadZenithConfig, hasZenithConfig } from './loader';

package/dist/core/config/index.js

@@ -1,10 +0,0 @@
-/**
- * Zenith Config
- *
- * Public exports for zenith/config
- *
- * Core exports ONLY generic plugin infrastructure.
- * Plugin-specific types are owned by their respective plugins.
- */
-export { defineConfig } from './types';
-export { loadZenithConfig, hasZenithConfig } from './loader';

package/dist/core/config/loader.d.ts

@@ -1,17 +0,0 @@
-/**
- * Zenith Config Loader
- *
- * Loads zenith.config.ts from the project root
- */
-import type { ZenithConfig } from './types';
-/**
- * Load zenith.config.ts from the project root
- *
- * @param projectRoot - Absolute path to the project root
- * @returns Parsed ZenithConfig or empty config if not found
- */
-export declare function loadZenithConfig(projectRoot: string): Promise<ZenithConfig>;
-/**
- * Check if a zenith.config.ts exists in the project
- */
-export declare function hasZenithConfig(projectRoot: string): boolean;

package/dist/core/config/loader.js

@@ -1,60 +0,0 @@
-/**
- * Zenith Config Loader
- *
- * Loads zenith.config.ts from the project root
- */
-import fs from 'node:fs';
-import path from 'node:path';
-/**
- * Load zenith.config.ts from the project root
- *
- * @param projectRoot - Absolute path to the project root
- * @returns Parsed ZenithConfig or empty config if not found
- */
-export async function loadZenithConfig(projectRoot) {
-    // Check for TypeScript config first, then JavaScript
-    const configPaths = [
-        path.join(projectRoot, 'zenith.config.ts'),
-        path.join(projectRoot, 'zenith.config.js'),
-        path.join(projectRoot, 'zenith.config.mjs'),
-    ];
-    let configPath = null;
-    for (const p of configPaths) {
-        if (fs.existsSync(p)) {
-            configPath = p;
-            break;
-        }
-    }
-    if (!configPath) {
-        // No config file found, return empty config
-        return { plugins: [] };
-    }
-    try {
-        // Use dynamic import to load the config
-        // Bun supports importing TS files directly
-        const configModule = await import(configPath);
-        const config = configModule.default || configModule;
-        // Validate basic structure
-        if (typeof config !== 'object' || config === null) {
-            console.warn(`[Zenith] Invalid config format in ${configPath}`);
-            return { plugins: [] };
-        }
-        return config;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`[Zenith] Failed to load config from ${configPath}:`, message);
-        return { plugins: [] };
-    }
-}
-/**
- * Check if a zenith.config.ts exists in the project
- */
-export function hasZenithConfig(projectRoot) {
-    const configPaths = [
-        path.join(projectRoot, 'zenith.config.ts'),
-        path.join(projectRoot, 'zenith.config.js'),
-        path.join(projectRoot, 'zenith.config.mjs'),
-    ];
-    return configPaths.some(p => fs.existsSync(p));
-}

package/dist/core/config/types.d.ts

@@ -1,98 +0,0 @@
-/**
- * Zenith Config Types
- *
- * Configuration interfaces for zenith.config.ts
- *
- * ═══════════════════════════════════════════════════════════════════════════════
- * HOOK OWNERSHIP RULE (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * Core may ONLY define types that are universally valid in all Zenith applications.
- * Plugin-specific types MUST be owned by their respective plugins.
- *
- * ✅ ALLOWED in Core:
- *    - ZenithConfig, ZenithPlugin, PluginContext (generic plugin infrastructure)
- *    - Universal lifecycle hooks (onMount, onUnmount)
- *    - Reactivity primitives (signal, effect, etc.)
- *
- * ❌ PROHIBITED in Core:
- *    - Content plugin types (ContentItem, ContentSourceConfig, etc.)
- *    - Router plugin types (RouteState, NavigationGuard, etc.)
- *    - Documentation plugin types
- *    - Any type that exists only because a plugin exists
- *
- * If removing a plugin would make a type meaningless, that type belongs to the plugin.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-import type { CLIBridgeAPI } from '../plugins/bridge';
-/**
- * Generic data record for plugin data exchange
- * Plugins define their own specific types internally
- */
-export type PluginData = Record<string, unknown[]>;
-/**
- * Context passed to plugins during setup
- *
- * This is intentionally generic - plugins define their own data shapes.
- * Core provides the stage, plugins bring the actors.
- */
-export interface PluginContext {
-    /** Absolute path to project root */
-    projectRoot: string;
-    /**
-     * Set plugin data for the runtime
-     *
-     * Generic setter - plugins define their own data structures.
-     * The runtime stores this data and makes it available to components.
-     *
-     * @example
-     * // Content plugin uses it for content items
-     * ctx.setPluginData('content', contentItems);
-     *
-     * // Analytics plugin uses it for tracking config
-     * ctx.setPluginData('analytics', analyticsConfig);
-     */
-    setPluginData: (namespace: string, data: unknown[]) => void;
-    /** Additional options passed from config */
-    options?: Record<string, unknown>;
-}
-/**
- * A Zenith plugin definition
- *
- * Plugins are self-contained, removable extensions.
- * Core must build and run identically with or without any plugin installed.
- */
-export interface ZenithPlugin {
-    /** Unique plugin name */
-    name: string;
-    /** Setup function called during initialization */
-    setup: (ctx: PluginContext) => void | Promise<void>;
-    /** Plugin-specific configuration (preserved for reference) */
-    config?: unknown;
-    /**
-     * Optional CLI registration
-     *
-     * Plugin receives the CLI bridge API to register namespaced hooks.
-     * CLI lifecycle hooks: 'cli:*' (owned by CLI)
-     * Plugin hooks: '<namespace>:*' (owned by plugin)
-     *
-     * @example
-     * registerCLI(api) {
-     *   api.on('cli:runtime:collect', (ctx) => {
-     *     return { namespace: 'myPlugin', payload: ctx.getPluginData('myPlugin') }
-     *   })
-     * }
-     */
-    registerCLI?: (api: CLIBridgeAPI) => void;
-}
-/**
- * Zenith configuration object
- */
-export interface ZenithConfig {
-    /** List of plugins to load */
-    plugins?: ZenithPlugin[];
-}
-/**
- * Define a Zenith configuration with full type safety
- */
-export declare function defineConfig(config: ZenithConfig): ZenithConfig;

package/dist/core/config/types.js

@@ -1,32 +0,0 @@
-/**
- * Zenith Config Types
- *
- * Configuration interfaces for zenith.config.ts
- *
- * ═══════════════════════════════════════════════════════════════════════════════
- * HOOK OWNERSHIP RULE (CANONICAL)
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * Core may ONLY define types that are universally valid in all Zenith applications.
- * Plugin-specific types MUST be owned by their respective plugins.
- *
- * ✅ ALLOWED in Core:
- *    - ZenithConfig, ZenithPlugin, PluginContext (generic plugin infrastructure)
- *    - Universal lifecycle hooks (onMount, onUnmount)
- *    - Reactivity primitives (signal, effect, etc.)
- *
- * ❌ PROHIBITED in Core:
- *    - Content plugin types (ContentItem, ContentSourceConfig, etc.)
- *    - Router plugin types (RouteState, NavigationGuard, etc.)
- *    - Documentation plugin types
- *    - Any type that exists only because a plugin exists
- *
- * If removing a plugin would make a type meaningless, that type belongs to the plugin.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-/**
- * Define a Zenith configuration with full type safety
- */
-export function defineConfig(config) {
-    return config;
-}

package/dist/core/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Zenith Compiler Core Modules
- */
-export { loadZenithConfig } from './config/loader';
-export { PluginRegistry, createPluginContext, getPluginDataByNamespace } from './plugins/registry';
-export { createBridgeAPI, runPluginHooks, collectHookReturns, buildRuntimeEnvelope, clearHooks } from './plugins/bridge';
-export type { HookContext } from './plugins/bridge';

package/dist/core/index.js

@@ -1,6 +0,0 @@
-/**
- * Zenith Compiler Core Modules
- */
-export { loadZenithConfig } from './config/loader';
-export { PluginRegistry, createPluginContext, getPluginDataByNamespace } from './plugins/registry';
-export { createBridgeAPI, runPluginHooks, collectHookReturns, buildRuntimeEnvelope, clearHooks } from './plugins/bridge';

package/dist/core/lifecycle/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * Zenith Lifecycle Hooks
- *
- * This module exports lifecycle hooks for component mount/unmount events.
- * These are effect wrappers that integrate with the component lifecycle system.
- *
- * Exports both explicit `zen*` names (internal) and clean aliases (public DX).
- */
-import { zenOnMount as _zenOnMount, triggerMount, triggerUnmount, getIsMounted, resetMountState, type MountCallback } from './zen-mount';
-import { zenOnUnmount as _zenOnUnmount, executeUnmountCallbacks, getUnmountCallbackCount, resetUnmountState, type UnmountCallback } from './zen-unmount';
-export declare const zenOnMount: typeof _zenOnMount;
-export declare const zenOnUnmount: typeof _zenOnUnmount;
-export { triggerMount, triggerUnmount, getIsMounted, resetMountState, executeUnmountCallbacks, getUnmountCallbackCount, resetUnmountState };
-export type { MountCallback, UnmountCallback };
-export declare const onMount: typeof _zenOnMount;
-export declare const onUnmount: typeof _zenOnUnmount;

package/dist/core/lifecycle/index.js

@@ -1,19 +0,0 @@
-/**
- * Zenith Lifecycle Hooks
- *
- * This module exports lifecycle hooks for component mount/unmount events.
- * These are effect wrappers that integrate with the component lifecycle system.
- *
- * Exports both explicit `zen*` names (internal) and clean aliases (public DX).
- */
-// Import lifecycle hooks
-import { zenOnMount as _zenOnMount, triggerMount, triggerUnmount, getIsMounted, resetMountState } from './zen-mount';
-import { zenOnUnmount as _zenOnUnmount, executeUnmountCallbacks, getUnmountCallbackCount, resetUnmountState } from './zen-unmount';
-// Re-export with explicit names
-export const zenOnMount = _zenOnMount;
-export const zenOnUnmount = _zenOnUnmount;
-// Re-export utilities
-export { triggerMount, triggerUnmount, getIsMounted, resetMountState, executeUnmountCallbacks, getUnmountCallbackCount, resetUnmountState };
-// Public DX aliases - clean names
-export const onMount = _zenOnMount;
-export const onUnmount = _zenOnUnmount;

package/dist/core/lifecycle/zen-mount.d.ts

@@ -1,66 +0,0 @@
-/**
- * Zenith OnMount - Post-Mount Lifecycle Hook
- *
- * Registers a callback to run after a component's DOM is inserted.
- * This is an effect wrapper that defers execution until the mount phase.
- *
- * Features:
- * - Runs after DOM is available
- * - Only runs once per mount
- * - Supports cleanup function return
- * - Works with component lifecycle system
- *
- * @example
- * ```ts
- * zenOnMount(() => {
- *   console.log('Component mounted!')
- *   const el = document.querySelector('.my-element')
- *
- *   // Optional cleanup - runs on unmount
- *   return () => {
- *     console.log('Component will unmount')
- *   }
- * })
- * ```
- *
- * Note: This hook registers callbacks that will be executed by the
- * component lifecycle system. If no mount scheduler is active,
- * callbacks are queued for later execution.
- */
-/**
- * Mount callback type - can optionally return a cleanup function
- */
-export type MountCallback = () => void | (() => void);
-/**
- * Register a callback to run after component mount
- *
- * @param callback - Function to run after mount (can return cleanup function)
- * @returns Dispose function to cancel the mount callback
- */
-export declare function zenOnMount(callback: MountCallback): () => void;
-/**
- * Trigger mount phase - called by component lifecycle system
- * Executes all pending mount callbacks
- *
- * @internal
- */
-export declare function triggerMount(): void;
-/**
- * Trigger unmount phase - called by component lifecycle system
- * Runs cleanup functions for all active mount hooks
- *
- * @internal
- */
-export declare function triggerUnmount(): void;
-/**
- * Check if currently in mounted state
- *
- * @internal
- */
-export declare function getIsMounted(): boolean;
-/**
- * Reset mount state - for testing purposes
- *
- * @internal
- */
-export declare function resetMountState(): void;

package/dist/core/lifecycle/zen-mount.js

@@ -1,151 +0,0 @@
-/**
- * Zenith OnMount - Post-Mount Lifecycle Hook
- *
- * Registers a callback to run after a component's DOM is inserted.
- * This is an effect wrapper that defers execution until the mount phase.
- *
- * Features:
- * - Runs after DOM is available
- * - Only runs once per mount
- * - Supports cleanup function return
- * - Works with component lifecycle system
- *
- * @example
- * ```ts
- * zenOnMount(() => {
- *   console.log('Component mounted!')
- *   const el = document.querySelector('.my-element')
- *
- *   // Optional cleanup - runs on unmount
- *   return () => {
- *     console.log('Component will unmount')
- *   }
- * })
- * ```
- *
- * Note: This hook registers callbacks that will be executed by the
- * component lifecycle system. If no mount scheduler is active,
- * callbacks are queued for later execution.
- */
-/**
- * Queue of pending mount callbacks
- * These are registered but not yet executed because mount hasn't occurred
- */
-const pendingMountCallbacks = [];
-/**
- * Currently active mount hooks (for cleanup on unmount)
- */
-const activeMountHooks = new Set();
-/**
- * Flag indicating whether we're in a mounted state
- * This is controlled by the component lifecycle system
- */
-let isMounted = false;
-/**
- * Register a callback to run after component mount
- *
- * @param callback - Function to run after mount (can return cleanup function)
- * @returns Dispose function to cancel the mount callback
- */
-export function zenOnMount(callback) {
-    const state = {
-        callback,
-        cleanup: null,
-        mounted: false
-    };
-    if (isMounted) {
-        // Already mounted - run immediately
-        executeMountCallback(state);
-    }
-    else {
-        // Queue for later execution
-        pendingMountCallbacks.push(state);
-    }
-    activeMountHooks.add(state);
-    // Return dispose function
-    return () => {
-        // Remove from pending if not yet executed
-        const pendingIndex = pendingMountCallbacks.indexOf(state);
-        if (pendingIndex !== -1) {
-            pendingMountCallbacks.splice(pendingIndex, 1);
-        }
-        // Run cleanup if already mounted
-        if (state.mounted && state.cleanup) {
-            state.cleanup();
-            state.cleanup = null;
-        }
-        activeMountHooks.delete(state);
-    };
-}
-/**
- * Execute a mount callback
- */
-function executeMountCallback(state) {
-    if (state.mounted)
-        return;
-    state.mounted = true;
-    try {
-        const result = state.callback();
-        if (typeof result === 'function') {
-            state.cleanup = result;
-        }
-    }
-    catch (error) {
-        console.error('[Zenith] Error in onMount callback:', error);
-    }
-}
-/**
- * Trigger mount phase - called by component lifecycle system
- * Executes all pending mount callbacks
- *
- * @internal
- */
-export function triggerMount() {
-    isMounted = true;
-    // Execute all pending callbacks
-    const callbacks = [...pendingMountCallbacks];
-    pendingMountCallbacks.length = 0;
-    for (const state of callbacks) {
-        executeMountCallback(state);
-    }
-}
-/**
- * Trigger unmount phase - called by component lifecycle system
- * Runs cleanup functions for all active mount hooks
- *
- * @internal
- */
-export function triggerUnmount() {
-    isMounted = false;
-    // Run all cleanup functions
-    for (const state of activeMountHooks) {
-        if (state.cleanup) {
-            try {
-                state.cleanup();
-            }
-            catch (error) {
-                console.error('[Zenith] Error in onMount cleanup:', error);
-            }
-            state.cleanup = null;
-        }
-        state.mounted = false;
-    }
-}
-/**
- * Check if currently in mounted state
- *
- * @internal
- */
-export function getIsMounted() {
-    return isMounted;
-}
-/**
- * Reset mount state - for testing purposes
- *
- * @internal
- */
-export function resetMountState() {
-    isMounted = false;
-    pendingMountCallbacks.length = 0;
-    activeMountHooks.clear();
-}

package/dist/core/lifecycle/zen-unmount.d.ts

@@ -1,54 +0,0 @@
-/**
- * Zenith OnUnmount - Pre-Unmount Lifecycle Hook
- *
- * Registers a cleanup callback to run before a component is disposed.
- * Useful for cleaning up subscriptions, timers, event listeners, etc.
- *
- * Features:
- * - Runs before component is removed from DOM
- * - Can register multiple callbacks
- * - Callbacks run in registration order
- *
- * @example
- * ```ts
- * zenOnUnmount(() => {
- *   console.log('Cleaning up...')
- *   subscription.unsubscribe()
- *   clearInterval(timerId)
- * })
- * ```
- *
- * Note: This hook registers callbacks that will be executed by the
- * component lifecycle system when the component is disposed.
- */
-/**
- * Unmount callback type
- */
-export type UnmountCallback = () => void;
-/**
- * Register a callback to run before component unmount
- *
- * @param callback - Function to run before unmount
- * @returns Dispose function to cancel the unmount callback
- */
-export declare function zenOnUnmount(callback: UnmountCallback): () => void;
-/**
- * Execute all unmount callbacks
- * Called by the component lifecycle system before disposal
- *
- * @internal
- */
-export declare function executeUnmountCallbacks(): void;
-/**
- * Get count of registered unmount callbacks
- * Useful for testing
- *
- * @internal
- */
-export declare function getUnmountCallbackCount(): number;
-/**
- * Reset unmount state - for testing purposes
- *
- * @internal
- */
-export declare function resetUnmountState(): void;