@zenithbuild/core 1.2.2 → 1.2.4

package/runtime/client-runtime.ts

@@ -1,891 +0,0 @@
-/**
- * Zenith Client Runtime
- * 
- * Shared runtime module served as /runtime.js in dev mode.
- * Includes:
- * - Reactivity primitives (signal, state, effect, memo)
- * - Lifecycle hooks (zenOnMount, zenOnUnmount)
- * - Event wiring
- * - Hydration functions
- * 
- * This is a standalone module that can be imported/served separately
- * from page-specific code.
- */
-
-// ============================================
-// Dependency Tracking System
-// ============================================
-
-let currentEffect: any = null;
-const effectStack: any[] = [];
-let batchDepth = 0;
-const pendingEffects = new Set<any>();
-
-function pushContext(effect: any) {
-    effectStack.push(currentEffect);
-    currentEffect = effect;
-}
-
-function popContext() {
-    currentEffect = effectStack.pop() || null;
-}
-
-function trackDependency(subscribers: Set<any>) {
-    if (currentEffect) {
-        subscribers.add(currentEffect);
-        currentEffect.dependencies.add(subscribers);
-    }
-}
-
-function notifySubscribers(subscribers: Set<any>) {
-    const effects = [...subscribers];
-    for (const effect of effects) {
-        if (batchDepth > 0) {
-            pendingEffects.add(effect);
-        } else {
-            effect.run();
-        }
-    }
-}
-
-function cleanupEffect(effect: any) {
-    for (const deps of effect.dependencies) {
-        deps.delete(effect);
-    }
-    effect.dependencies.clear();
-}
-
-// ============================================
-// zenSignal - Atomic reactive value
-// ============================================
-
-export function zenSignal<T>(initialValue: T): (newValue?: T) => T {
-    let value = initialValue;
-    const subscribers = new Set<any>();
-
-    function signal(newValue?: T): T {
-        if (arguments.length === 0) {
-            trackDependency(subscribers);
-            return value;
-        }
-        if (newValue !== value) {
-            value = newValue as T;
-            notifySubscribers(subscribers);
-        }
-        return value;
-    }
-
-    return signal;
-}
-
-// ============================================
-// zenState - Deep reactive object with Proxy
-// ============================================
-
-export function zenState<T extends object>(initialObj: T): T {
-    const subscribers = new Map<string, Set<any>>();
-
-    function getSubscribers(path: string): Set<any> {
-        if (!subscribers.has(path)) {
-            subscribers.set(path, new Set());
-        }
-        return subscribers.get(path)!;
-    }
-
-    function createProxy(obj: any, parentPath: string = ''): any {
-        if (obj === null || typeof obj !== 'object') {
-            return obj;
-        }
-
-        return new Proxy(obj, {
-            get(target, prop) {
-                if (typeof prop === 'symbol') return target[prop];
-
-                const path = parentPath ? `${parentPath}.${String(prop)}` : String(prop);
-                trackDependency(getSubscribers(path));
-
-                const value = target[prop];
-                if (value !== null && typeof value === 'object') {
-                    return createProxy(value, path);
-                }
-                return value;
-            },
-
-            set(target, prop, newValue) {
-                if (typeof prop === 'symbol') {
-                    target[prop] = newValue;
-                    return true;
-                }
-
-                const path = parentPath ? `${parentPath}.${String(prop)}` : String(prop);
-                const oldValue = target[prop];
-
-                if (oldValue !== newValue) {
-                    target[prop] = newValue;
-
-                    // Notify this path
-                    const subs = subscribers.get(path);
-                    if (subs) notifySubscribers(subs);
-
-                    // Notify parent paths
-                    const parts = path.split('.');
-                    for (let i = parts.length - 1; i >= 0; i--) {
-                        const parentPath = parts.slice(0, i).join('.');
-                        if (parentPath) {
-                            const parentSubs = subscribers.get(parentPath);
-                            if (parentSubs) notifySubscribers(parentSubs);
-                        }
-                    }
-                }
-                return true;
-            }
-        });
-    }
-
-    return createProxy(initialObj);
-}
-
-// ============================================
-// zenEffect - Reactive effect
-// ============================================
-
-export function zenEffect(fn: () => void | (() => void)): () => void {
-    let cleanup: (() => void) | void;
-
-    const effect = {
-        dependencies: new Set<Set<any>>(),
-        run() {
-            cleanupEffect(effect);
-            pushContext(effect);
-            try {
-                if (cleanup) cleanup();
-                cleanup = fn();
-            } finally {
-                popContext();
-            }
-        }
-    };
-
-    effect.run();
-
-    return () => {
-        cleanupEffect(effect);
-        if (cleanup) cleanup();
-    };
-}
-
-// ============================================
-// zenMemo - Computed/derived value
-// ============================================
-
-export function zenMemo<T>(fn: () => T): () => T {
-    let value: T;
-    let dirty = true;
-    const subscribers = new Set<any>();
-
-    const effect = {
-        dependencies: new Set<Set<any>>(),
-        run() {
-            cleanupEffect(effect);
-            pushContext(effect);
-            try {
-                value = fn();
-                dirty = false;
-                notifySubscribers(subscribers);
-            } finally {
-                popContext();
-            }
-        }
-    };
-
-    return () => {
-        trackDependency(subscribers);
-        if (dirty) {
-            effect.run();
-        }
-        return value;
-    };
-}
-
-// ============================================
-// zenRef - Non-reactive mutable container
-// ============================================
-
-export function zenRef<T>(initialValue?: T): { current: T | null } {
-    return { current: initialValue !== undefined ? initialValue : null };
-}
-
-// ============================================
-// zenBatch - Batch updates
-// ============================================
-
-export function zenBatch(fn: () => void): void {
-    batchDepth++;
-    try {
-        fn();
-    } finally {
-        batchDepth--;
-        if (batchDepth === 0) {
-            const effects = [...pendingEffects];
-            pendingEffects.clear();
-            for (const effect of effects) {
-                effect.run();
-            }
-        }
-    }
-}
-
-// ============================================
-// zenUntrack - Read without tracking
-// ============================================
-
-export function zenUntrack<T>(fn: () => T): T {
-    const prevEffect = currentEffect;
-    currentEffect = null;
-    try {
-        return fn();
-    } finally {
-        currentEffect = prevEffect;
-    }
-}
-
-// ============================================
-// Lifecycle Hooks
-// ============================================
-
-const mountCallbacks: Array<() => void | (() => void)> = [];
-const unmountCallbacks: Array<() => void> = [];
-let isMounted = false;
-
-export function zenOnMount(fn: () => void | (() => void)): void {
-    if (isMounted) {
-        const cleanup = fn();
-        if (typeof cleanup === 'function') {
-            unmountCallbacks.push(cleanup);
-        }
-    } else {
-        mountCallbacks.push(fn);
-    }
-}
-
-export function zenOnUnmount(fn: () => void): void {
-    unmountCallbacks.push(fn);
-}
-
-export function triggerMount(): void {
-    isMounted = true;
-    for (const cb of mountCallbacks) {
-        const cleanup = cb();
-        if (typeof cleanup === 'function') {
-            unmountCallbacks.push(cleanup);
-        }
-    }
-    mountCallbacks.length = 0;
-}
-
-export function triggerUnmount(): void {
-    isMounted = false;
-    for (const cb of unmountCallbacks) {
-        try { cb(); } catch (e) { console.error('[Zenith] Unmount error:', e); }
-    }
-    unmountCallbacks.length = 0;
-}
-
-// ============================================
-// Expression Registry
-// ============================================
-
-const expressionRegistry = new Map<string, (state: any) => any>();
-
-export function registerExpression(id: string, fn: (state: any) => any): void {
-    expressionRegistry.set(id, fn);
-}
-
-export function getExpression(id: string): ((state: any) => any) | undefined {
-    return expressionRegistry.get(id);
-}
-
-// ============================================
-// Hydration Functions
-// ============================================
-
-// ============================================
-// Hydration & Binding System
-// ============================================
-
-interface BaseBinding {
-    node: Node;
-    type: 'text' | 'attribute' | 'html' | 'conditional' | 'optional' | 'loop';
-    id: string; // Binding/Expression ID
-}
-
-interface TextBinding extends BaseBinding {
-    type: 'text';
-    node: Text;
-}
-
-interface AttributeBinding extends BaseBinding {
-    type: 'attribute';
-    node: Element;
-    attrName: string;
-}
-
-interface HtmlBinding extends BaseBinding {
-    type: 'html';
-    node: Element;
-}
-
-interface ConditionalBinding extends BaseBinding {
-    type: 'conditional';
-    node: Element; // The container div with data-zen-cond
-    trueBranch?: Node[]; // Cached true branch nodes
-    falseBranch?: Node[]; // Cached false branch nodes
-    currentBranch: boolean | null; // true, false, or null (uninitialized)
-}
-
-interface OptionalBinding extends BaseBinding {
-    type: 'optional';
-    node: Element; // The container div with data-zen-opt
-    content?: Node[]; // Cached content nodes
-    isVisible: boolean | null;
-}
-
-interface LoopBinding extends BaseBinding {
-    type: 'loop';
-    node: Element; // The container div with data-zen-loop
-    template: Node[]; // THe template nodes (cloned from initial content)
-    items: any[]; // Current items list
-    itemBindings: Binding[][]; // Bindings for each item
-    itemVar: string;
-    indexVar: string | null;
-    sourceExpr: string;
-}
-
-type Binding = TextBinding | AttributeBinding | HtmlBinding | ConditionalBinding | OptionalBinding | LoopBinding;
-
-// Root bindings for the application
-const rootBindings: Binding[] = [];
-
-/**
- * Recursive Hydration (Tree Walker)
- * 
- * Scans the DOM tree for bindings, respecting scope boundaries.
- * Returns a list of bindings found in this subtree (excluding those inside child scopes like loops).
- */
-
-/**
- * Manual recursive traversal to better handle skipping subtrees
- */
-function scanBindings(node: Node, bindings: Binding[]): void {
-    if (node.nodeType === Node.ELEMENT_NODE) {
-        const element = node as Element;
-
-        // Check for Loop - Stop traversal into children if found
-        if (element.hasAttribute('data-zen-loop')) {
-            const id = element.getAttribute('data-zen-loop')!;
-            const source = element.getAttribute('data-zen-source')!;
-            const itemVar = element.getAttribute('data-zen-item')!;
-            const indexVar = element.getAttribute('data-zen-index');
-
-            // Capture template from initial content (SSR)
-            // Note: For client-side nav, this might modify `element` immediately?
-            // For now assume standard hydration of SSR content
-            const template = Array.from(element.childNodes).map(n => n.cloneNode(true));
-
-            // The loop binding itself manages the children. 
-            // We do NOT scan children here. The loop update() will scan/hydrate instances.
-
-            // Clear initial SSR content so we can re-render fresh? 
-            // Or try to hydrate existing? Hydrating lists is hard (keys etc).
-            // Simplest safe fix: Clear and re-render.
-            element.innerHTML = '';
-
-            bindings.push({
-                type: 'loop',
-                node: element,
-                id,
-                sourceExpr: source,
-                itemVar,
-                indexVar,
-                template,
-                items: [],
-                itemBindings: []
-            } as LoopBinding);
-
-            return; // STOP recursion into loop children
-        }
-
-        // Check for Conditional - Stop recursion?
-        // Actually, conditional blocks contain children we WANT to bind if they are currently visible.
-        // But if we toggle, we need to re-scan.
-        // So ConditionalBinding should manage its children.
-        if (element.hasAttribute('data-zen-cond')) {
-            const id = element.getAttribute('data-zen-cond')!;
-            // We assume the true/false branches are initially present as separate containers
-            // OR `data-zen-cond-true` / `data-zen-cond-false` markers?
-            // The compiler output:
-            // <div data_zen_cond="id" data_zen_cond_true style="display:contents">...</div>
-            // <div data_zen_cond="id" data_zen_cond_false style="display:none">...</div>
-            // These are siblings usually? Or nested?
-            // Wait, compiler generates TWO divs.
-            // <div data-zen-cond="id" ...true> and <div data-zen-cond="id" ...false>
-            // Each is a separate binding effectively?
-            // If they share the same ID, they are part of the same logic.
-            // Scanning will find both. We can treat them as independent toggle-able areas?
-
-            // Actually, simpler to treat them as ConditionalBinding.
-            // But we need to know which branch it is.
-            const isTrueBranch = element.hasAttribute('data-zen-cond-true');
-
-            // For now, let's treat them as distinct bindings that listen to the same expression
-            // and toggle visibility.
-            // We DO want to scan their children because they might be visible.
-
-            // Optimization: If display:none, maybe don't scan yet? 
-            // But we want to be ready to show.
-
-            // Let's implement ConditionalBinding to manage visibility AND recurse.
-            bindings.push({
-                type: 'conditional',
-                node: element,
-                id,
-                currentBranch: null, // Force update
-
-            } as any); // Simplification: Just toggle display
-            // NO, wait. If we hide it, we shouldn't update its children's bindings if they depend on ephemeral state?
-            // Actually, simplest is just toggle binding.
-            // Let's rely on standard attribute binding?
-            // No, standard attribute binding doesn't handle children.
-
-            // Revisiting the compiler:
-            // It's just a div with an ID. The logic is "If cond is true, show TrueDiv, hide FalseDiv".
-            // So we can have a Binding that just toggles 'style.display'.
-            // And we CONTINUE scanning children.
-        }
-
-        // Optional? Same.
-
-        // Bind attributes
-        const attrSelectors = ['class', 'style', 'src', 'href', 'disabled', 'checked', 'value', 'placeholder'];
-        for (const attr of attrSelectors) {
-            const attrKey = `data-zen-attr-${attr}`;
-            if (element.hasAttribute(attrKey)) {
-                bindings.push({
-                    type: 'attribute',
-                    node: element,
-                    id: element.getAttribute(attrKey)!,
-                    attrName: attr
-                });
-            }
-        }
-
-        // Bind HTML
-        if (element.hasAttribute('data-zen-html')) {
-            bindings.push({
-                type: 'html',
-                node: element,
-                id: element.getAttribute('data-zen-html')!
-            });
-        }
-
-        // Bind Events
-        bindEventsHelpers(element);
-    }
-
-    // Check Text Nodes
-    if (node.nodeType === Node.TEXT_NODE) {
-        // Text nodes can't have attributes, so we look at parent?
-        // No, Zenith compiler puts `data-zen-text="id"` on the PARENT element usually?
-        // Or strictly on the element wrapping the text?
-        // Compiler: <span data-zen-text="id"></span> or similar.
-        // Wait, `transformNode` for text binding:
-        // Returns `<!--binding:id-->`? No.
-        // It returns a TextNode in IR. `generateBindings` validates "Text binding must have target 'data-zen-text'".
-        // `transformNode`: if binding exists, it sets `data-zen-text` attribute on the element?
-        // Wait, text nodes don't have attributes.
-        // The compiler wraps text in a generic element or expects the parent?
-        // Usually framework puts it on the parent element.
-        // Let's check `parseTemplate.ts` or `transformNode.ts`...
-        // Assuming the element with `data-zen-text` owns the text content.
-    }
-
-    // Check parent for Text Binding (on Element)
-    if (node.nodeType === Node.ELEMENT_NODE) {
-        const el = node as Element;
-        if (el.hasAttribute('data-zen-text')) {
-            bindings.push({
-                type: 'text',
-                node: el.firstChild as Text || el.appendChild(document.createTextNode('')), // Ensure text node exists
-                id: el.getAttribute('data-zen-text')!
-            } as TextBinding);
-            // We don't skip children here, but usually text binding replaces content.
-        }
-    }
-
-    // Recurse to children (unless stopped above)
-    let child = node.firstChild;
-    while (child) {
-        scanBindings(child, bindings);
-        child = child.nextSibling;
-    }
-}
-
-function bindEventsHelpers(element: Element) {
-    const eventTypes = ['click', 'change', 'input', 'submit', 'focus', 'blur', 'keyup', 'keydown'];
-    for (const eventType of eventTypes) {
-        const attr = `data-zen-${eventType}`;
-        if (element.hasAttribute(attr)) {
-            // We attach handler immediately?
-            // Handler needs to access runtime state.
-            // We'll use a closure that calls the global/scoped handler at runtime.
-            const handlerName = element.getAttribute(attr)!;
-
-            // Remove old
-            const oldHandler = (element as any)[`__zen_${eventType}`];
-            if (oldHandler) element.removeEventListener(eventType, oldHandler);
-
-            // Add new
-            const handler = (e: Event) => dispatchEvent(e, handlerName, element);
-            (element as any)[`__zen_${eventType}`] = handler;
-            element.addEventListener(eventType, handler);
-        }
-    }
-}
-
-function dispatchEvent(event: Event, handlerName: string, element: Element) {
-    // We need to find the SCOPE.
-    // Event handler might be looking for `item` (loop variable).
-    // This is tricky with standard DOM events.
-    // We attach scope info to the DOM element?
-    // When LoopBinding creates nodes, it should attach `_zen_scope` property to the root of the item?
-
-    // Finding scope: traverse up to find an element with `_zen_scope`.
-    let target = element as any;
-    let scope = {};
-
-    while (target) {
-        if (target._zen_scope) {
-            scope = { ...target._zen_scope, ...scope }; // Merge scopes (inner wins? No, inner is more specific)
-            // Actually, prototype chain or Object.assign?
-            // List items usually have unique props.
-            // Let's accumulate.
-            // For a simple hierarchy: Global < LoopItem.
-            // We start matching from Global? No.
-            // The handler execution needs the collected scope.
-            break; // Assuming flat scope per loop item for now or merge?
-        }
-        target = target.parentNode;
-    }
-
-    // Global scopes
-    // We don't easily have access to the *current* global state passed to update() here, 
-    // unless we store it globally.
-    // `expressionRegistry` handlers take `state`.
-    // We need to fetch the latest state? 
-    // Zenith signals usually read current value directly.
-    // But `expression(state)` pattern implies pure function of state.
-
-    // For events: usually they call a function. `increment()`.
-    // That function access signals/state directly.
-    // BUT if it uses arguments like `doSomething(item)`, `item` comes from scope.
-
-    // Only expressions registered in registry need `state` passed?
-    // If `handlerName` is in `__ZENITH_EXPRESSIONS__`, calling it requires state.
-    // Which state? One with loop vars.
-
-    // HACK: for now, we rely on the fact that most handlers are simple fn calls.
-    // If they are expressions expecting args, we assume they are bound or don't need args?
-    // Wait, `<button onclick="remove(item)">`.
-    // Compiler lower this to an expression: `(state) => remove(state.item)`.
-    // So we DO need to pass the scope-enriched state to the handler if it's an expression.
-
-    const handlerFunc = (window as any)[handlerName] || (window as any).__ZENITH_EXPRESSIONS__?.get(handlerName);
-
-    if (typeof handlerFunc === 'function') {
-        // Determine effective state
-        // We might need a global `getLastState()` or similar if strictly functional.
-        // Or we pass `scope` (which has item) as the state?
-        // If generic state is required, we are in trouble without a global reference.
-        // Let's assume `window.__zenith_last_state` is available or similar?
-        // Added `window.__zenith_currentState` in update().
-
-        const globalState = (window as any).__zenith_currentState || {};
-        const effectiveState = { ...globalState, ...scope };
-
-        handlerFunc(event, element, effectiveState); // Pass state as 3rd arg? Or 1st?
-        // Expression signature: (state) => ...
-        // Event handler signature: (e, el) => ...
-        // Conflict.
-        // Zenith compiler usually generates `(state) => (e) => ...` or similar for events?
-        // Or the expression IS the handler body?
-        // If it's `(state) => ...`, we call it to get the result.
-        // If result is function, call it with event?
-
-        // Let's try calling with state. If it returns function, call that.
-        try {
-            const result = handlerFunc(effectiveState);
-            if (typeof result === 'function') {
-                result(event, element);
-            }
-        } catch (e) {
-            // It might be a direct event handler (e) => ...
-            handlerFunc(event, element);
-        }
-    }
-}
-
-export function hydrate(state: any, container?: Element | Document): void {
-    const root = container || document;
-    // Clear global bindings
-    rootBindings.length = 0;
-
-    // Store initial state for events
-    (window as any).__zenith_currentState = state;
-
-    scanBindings(root, rootBindings);
-
-    // Initial update
-    updateBindings(rootBindings, state);
-    triggerMount();
-}
-
-/**
- * Update Loop Logic
- */
-function updateLoop(binding: LoopBinding, state: any) {
-    const { node, id, sourceExpr, itemVar, indexVar, template } = binding;
-
-    // 1. Evaluate Source
-    const expr = expressionRegistry.get(sourceExpr);
-    if (!expr) return;
-
-    let list = [];
-    try {
-        list = expr(state) || [];
-    } catch (e) { console.error('Loop source error', e); }
-
-    if (!Array.isArray(list)) list = [];
-
-    // 2. Reconcile (Naive: Clear and Re-render)
-    // Optimization: Reuse existing items?
-    // For Patch 1.1.0, let's keep it simple and safe: Full Re-render.
-    // Ideally we diff.
-
-    // Detect if nothing changed? (Deep equals or ref check)
-    if (binding.items === list) {
-        // Same reference, assumes no change? 
-        // In mutable state (Proxy), the array might be same ref but mutated.
-        // We probably should re-render or at least re-update children.
-        // Let's fall through.
-    }
-    binding.items = list;
-
-    node.innerHTML = '';
-    binding.itemBindings = []; // Clear child bindings
-
-    list.forEach((item, index) => {
-        // Create Scope
-        const scope = { [itemVar]: item };
-        if (indexVar) scope[indexVar] = index;
-
-        // Clone Template
-        const fragment = document.createDocumentFragment();
-        template.forEach(n => fragment.appendChild(n.cloneNode(true)));
-
-        // Mark Scope on Root Elements of Item
-        // (Used for event delegation)
-        Array.from(fragment.childNodes).forEach((child: any) => {
-            if (child.nodeType === 1) child._zen_scope = scope;
-        });
-
-        // Hydrate this instance (collect bindings)
-        const instanceBindings: Binding[] = [];
-        // Scan fragment BEFORE appending? Or after?
-        // Appending first is easier for traversal, but we want to bind to the specific nodes.
-        scanBindings(fragment, instanceBindings);
-        binding.itemBindings.push(instanceBindings);
-
-        node.appendChild(fragment);
-
-        // Initial Update for this instance
-        updateBindings(instanceBindings, { ...state, ...scope });
-    });
-}
-
-function updateBindings(bindingsList: Binding[], state: any) {
-    for (const binding of bindingsList) {
-        if (binding.type === 'text') {
-            const expr = expressionRegistry.get(binding.id);
-            if (expr) {
-                try { binding.node.textContent = String(expr(state) ?? ''); }
-                catch (e) { }
-            }
-        } else if (binding.type === 'attribute') {
-            updateAttributeBinding(binding.node, binding.attrName, binding.id, state);
-        } else if (binding.type === 'html') {
-            const expr = expressionRegistry.get(binding.id);
-            if (expr) {
-                try {
-                    const val = expr(state);
-                    binding.node.innerHTML = String(val ?? '');
-                } catch (e) { }
-            }
-        } else if (binding.type === 'conditional' || binding.type === 'optional') {
-            // Toggle display based on truthiness
-            const expr = expressionRegistry.get(binding.id);
-            if (expr) {
-                const val = !!expr(state);
-                // Check if inverted (data-zen-cond-false)
-                const isInverse = (binding.node as Element).hasAttribute('data-zen-cond-false');
-                const shouldShow = isInverse ? !val : val;
-
-                (binding.node as HTMLElement).style.display = shouldShow ? 'contents' : 'none';
-            }
-        } else if (binding.type === 'loop') {
-            updateLoop(binding as LoopBinding, state);
-        }
-    }
-}
-
-export function update(state: any): void {
-    (window as any).__zenith_currentState = state;
-    updateBindings(rootBindings, state);
-}
-
-export function cleanup(container?: Element | Document): void {
-    rootBindings.length = 0;
-    rootBindings.length = 0;
-    triggerUnmount();
-}
-
-// ... existing helper functions (updateAttributeBinding, bindEvents) need slight adjustments or imports?
-// We need to keep updateAttributeBinding available.
-
-// REUSING EXISTING updateAttributeBinding from previous implementation
-// (Need to make sure it's defined or moved)
-
-function updateAttributeBinding(element: Element, attrName: string, expressionId: string, state: any): void {
-    const expression = expressionRegistry.get(expressionId);
-    if (!expression) return;
-
-    try {
-        const result = expression(state);
-
-        if (attrName === 'class' || attrName === 'className') {
-            (element as HTMLElement).className = String(result ?? '');
-        } else if (attrName === 'style' && typeof result === 'object') {
-            const styleStr = Object.entries(result).map(([k, v]) => `${k}: ${v}`).join('; ');
-            element.setAttribute('style', styleStr);
-        } else if (['disabled', 'checked', 'readonly'].includes(attrName)) {
-            if (result) {
-                element.setAttribute(attrName, '');
-            } else {
-                element.removeAttribute(attrName);
-            }
-        } else {
-            if (result === null || result === undefined || result === false) {
-                element.removeAttribute(attrName);
-            } else {
-                element.setAttribute(attrName, String(result));
-            }
-        }
-    } catch (error) {
-        console.error(`[Zenith] Error updating attribute ${attrName}:`, error);
-    }
-}
-
-export function bindEvents(container: Element | Document): void {
-    // Legacy support or external call?
-    // Our scanBindings() handles events.
-    // If called manually, we traverse?
-    if (container.nodeType === Node.ELEMENT_NODE) {
-        bindEventsHelpers(container as Element);
-        // And children...
-        const all = (container as Element).querySelectorAll('*');
-        all.forEach(el => bindEventsHelpers(el));
-    }
-}
-
-
-// ============================================
-// Plugin Runtime Data Access
-// ============================================
-
-/**
- * Access plugin data from the neutral envelope
- * 
- * Plugins use this to retrieve their data at runtime.
- * The CLI injected this data via window.__ZENITH_PLUGIN_DATA__
- * 
- * @param namespace - Plugin namespace (e.g., 'content', 'router')
- * @returns The plugin's data, or undefined if not present
- */
-export function getPluginRuntimeData(namespace: string): unknown {
-    if (typeof window === 'undefined') return undefined;
-    const envelope = (window as any).__ZENITH_PLUGIN_DATA__;
-    return envelope?.[namespace];
-}
-
-// ============================================
-// Browser Globals Setup
-// ============================================
-
-export function setupGlobals(): void {
-    if (typeof window === 'undefined') return;
-
-    const w = window as any;
-
-    // Zenith namespace
-    w.__zenith = {
-        signal: zenSignal,
-        state: zenState,
-        effect: zenEffect,
-        memo: zenMemo,
-        ref: zenRef,
-        batch: zenBatch,
-        untrack: zenUntrack,
-        onMount: zenOnMount,
-        onUnmount: zenOnUnmount,
-        triggerMount,
-        triggerUnmount,
-        getPluginData: getPluginRuntimeData  // Access plugin data from envelope
-    };
-
-    // Expression registry
-    w.__ZENITH_EXPRESSIONS__ = expressionRegistry;
-
-    // Hydration functions
-    w.__zenith_hydrate = hydrate;
-    w.__zenith_update = update;
-    w.__zenith_bindEvents = bindEvents;
-    w.__zenith_cleanup = cleanup;
-    w.zenithHydrate = hydrate;
-    w.zenithUpdate = update;
-    w.zenithBindEvents = bindEvents;
-    w.zenithCleanup = cleanup;
-
-    // Direct primitives
-    w.zenSignal = zenSignal;
-    w.zenState = zenState;
-    w.zenEffect = zenEffect;
-    w.zenMemo = zenMemo;
-    w.zenRef = zenRef;
-    w.zenBatch = zenBatch;
-    w.zenUntrack = zenUntrack;
-    w.zenOnMount = zenOnMount;
-    w.zenOnUnmount = zenOnUnmount;
-
-    // Short aliases
-    w.signal = zenSignal;
-    w.state = zenState;
-    w.effect = zenEffect;
-    w.memo = zenMemo;
-    w.ref = zenRef;
-    w.batch = zenBatch;
-    w.untrack = zenUntrack;
-    w.onMount = zenOnMount;
-    w.onUnmount = zenOnUnmount;
-}
-
-// Auto-setup globals on import
-setupGlobals();