@zenithbuild/compiler 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zenith Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @zenithbuild/compiler 🏗️
+
+The Iron Heart of the Zenith framework. High-performance native compiler and build-time architect.
+
+## Overview
+
+@zenithbuild/compiler owns everything related to structure, wiring, and validation. It is a coordinated companion to `@zenithbuild/core`.
+
+### Core Responsibilities
+- **Parsing**: Native AST parsing of `.zen` files (Rust).
+- **Transformation**: Lowering templates to optimized execution plans.
+- **Dependency Management**: Compile-time resolution of imports and reactive graphs.
+- **CSS Engine**: High-speed CSS compilation and Tailwind integration.
+- **Bundle Generation**: Composing the thin client runtime for the browser.
+
+## Coordinated System
+
+Zenith is built as a coordinated system. The compiler produces artifacts that the Core runtime consumes blindly.
+- **No runtime decisions**: If it can be known at compile time, the compiler decides it.
+- **Tight Coupling**: Versioned and released in lockstep with `@zenithbuild/core`.
+
+## Internal Structure
+
+- `native/`: The Rust-powered core compiler.
+- `src/parse/`: TypeScript wrappers for the native parser.
+- `src/runtime/`: logic for generating the `bundle.js` target.
+
+## License
+
+MIT

package/dist/build-analyzer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Zenith Build Analyzer
+ *
+ * Analyzes .zen page source to determine build strategy:
+ * - Static: Pure HTML+CSS, no JS needed
+ * - Hydration: Has state/events/hooks, needs page-specific JS
+ * - SSR: Uses useFetchServer, needs server rendering
+ * - SPA: Uses ZenLink with passHref, needs client router
+ */
+export interface PageAnalysis {
+    /** Page has state declarations that need hydration */
+    hasState: boolean;
+    /** Page has event handlers (onclick, etc.) */
+    hasEventHandlers: boolean;
+    /** Page uses lifecycle hooks (zenOnMount, zenOnUnmount) */
+    hasLifecycleHooks: boolean;
+    /** Page uses useFetchServer (requires SSR) */
+    usesServerFetch: boolean;
+    /** Page uses useFetchClient (client-side data) */
+    usesClientFetch: boolean;
+    /** Page uses ZenLink with passHref (SPA navigation) */
+    usesZenLink: boolean;
+    /** Page uses reactive expressions in templates */
+    hasReactiveExpressions: boolean;
+    /** Computed: page needs any JavaScript */
+    needsHydration: boolean;
+    /** Computed: page is purely static (no JS) */
+    isStatic: boolean;
+    /** Computed: page needs SSR */
+    needsSSR: boolean;
+}
+/**
+ * Analyze a .zen page source to determine build requirements
+ */
+export declare function analyzePageSource(source: string): PageAnalysis;
+/**
+ * Get a human-readable summary of the page analysis
+ */
+export declare function getAnalysisSummary(analysis: PageAnalysis): string;
+/**
+ * Determine build output type for a page
+ */
+export type BuildOutputType = 'static' | 'hydrated' | 'ssr';
+export declare function getBuildOutputType(analysis: PageAnalysis): BuildOutputType;

package/dist/build-analyzer.js

@@ -0,0 +1,87 @@
+/**
+ * Zenith Build Analyzer
+ *
+ * Analyzes .zen page source to determine build strategy:
+ * - Static: Pure HTML+CSS, no JS needed
+ * - Hydration: Has state/events/hooks, needs page-specific JS
+ * - SSR: Uses useFetchServer, needs server rendering
+ * - SPA: Uses ZenLink with passHref, needs client router
+ */
+/**
+ * Analyze a .zen page source to determine build requirements
+ */
+export function analyzePageSource(source) {
+    // Extract script content for analysis
+    const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
+    const scriptContent = scriptMatch?.[1] || '';
+    // Extract template content (everything outside script/style)
+    const templateContent = source
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+    // Check for state declarations: "state varName = ..."
+    const hasState = /\bstate\s+\w+\s*=/.test(scriptContent);
+    // Check for event handlers in template
+    const hasEventHandlers = /\bon(click|change|input|submit|focus|blur|keydown|keyup|keypress|mousedown|mouseup|mouseover|mouseout|mouseenter|mouseleave)\s*=\s*["'{]/.test(templateContent);
+    // Check for lifecycle hooks
+    const hasLifecycleHooks = /\bzen(OnMount|OnUnmount)\s*\(/.test(scriptContent);
+    // Check for server fetch
+    const usesServerFetch = /\buseFetchServer\s*\(/.test(scriptContent);
+    // Check for client fetch
+    const usesClientFetch = /\buseFetchClient\s*\(/.test(scriptContent);
+    // Check for ZenLink with passHref
+    const usesZenLink = /<ZenLink[^>]*passHref[^>]*>/.test(templateContent);
+    // Check for reactive expressions in template: {expression}
+    // Must be actual expressions, not just static text
+    // Exclude attribute values like href="/path"
+    const hasReactiveExpressions = /{[^{}]+}/.test(templateContent);
+    // Compute derived properties
+    const needsHydration = hasState || hasEventHandlers || hasLifecycleHooks ||
+        usesClientFetch || hasReactiveExpressions;
+    const isStatic = !needsHydration && !usesServerFetch;
+    const needsSSR = usesServerFetch;
+    return {
+        hasState,
+        hasEventHandlers,
+        hasLifecycleHooks,
+        usesServerFetch,
+        usesClientFetch,
+        usesZenLink,
+        hasReactiveExpressions,
+        needsHydration,
+        isStatic,
+        needsSSR
+    };
+}
+/**
+ * Get a human-readable summary of the page analysis
+ */
+export function getAnalysisSummary(analysis) {
+    const flags = [];
+    if (analysis.isStatic) {
+        flags.push('STATIC (no JS)');
+    }
+    else {
+        if (analysis.hasState)
+            flags.push('state');
+        if (analysis.hasEventHandlers)
+            flags.push('events');
+        if (analysis.hasLifecycleHooks)
+            flags.push('lifecycle');
+        if (analysis.hasReactiveExpressions)
+            flags.push('reactive');
+        if (analysis.usesClientFetch)
+            flags.push('clientFetch');
+    }
+    if (analysis.needsSSR)
+        flags.push('SSR');
+    if (analysis.usesZenLink)
+        flags.push('SPA');
+    return flags.length > 0 ? flags.join(', ') : 'minimal';
+}
+export function getBuildOutputType(analysis) {
+    if (analysis.needsSSR)
+        return 'ssr';
+    if (analysis.needsHydration)
+        return 'hydrated';
+    return 'static';
+}

package/dist/bundler.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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 type { BundlePlan } from './ir/types';
+/**
+ * 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 declare function bundlePageScript(plan: BundlePlan): Promise<string>;

package/dist/bundler.js

@@ -0,0 +1,86 @@
+/**
+ * @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

@@ -0,0 +1,9 @@
+/**
+ * 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

@@ -0,0 +1,13 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+/**
+ * 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

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,17 @@
+/**
+ * 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

@@ -0,0 +1,60 @@
+/**
+ * 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

@@ -0,0 +1,98 @@
+/**
+ * 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

@@ -0,0 +1,32 @@
+/**
+ * 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

@@ -0,0 +1,7 @@
+/**
+ * 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

@@ -0,0 +1,6 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+/**
+ * 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

@@ -0,0 +1,19 @@
+/**
+ * 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;