@zenithbuild/core 0.1.0 → 0.3.1

package/assets/logos/README.md

@@ -1,54 +0,0 @@
-# Zenith Logos
-
-This directory contains the Zenith framework logo assets.
-
-## Logo Files
-
-Based on the logo designs, you should place the following files here:
-
-1. **zenith-logo-icon.png** (or .svg) - The file icon version with the folded corner and ".ZENITH" button
-2. **zenith-logo-z.png** (or .svg) - The stylized "Z" logo with gradient and light trails
-3. **zenith-logo-full.png** (or .svg) - The full logo with "ZENITH" text below
-4. **zenith-logo-soon.png** (or .svg) - The logo variant with "Soon" text
-
-## File Icon for .zen Files
-
-The SVG logo has been converted to a macOS `.icns` file to use as the file icon for `.zen` files.
-
-### Setting the Icon
-
-**Option 1: Use the automated script (recommended)**
-```bash
-cd assets/logos
-./set-zen-icon.sh path/to/your/file.zen
-```
-
-**Option 2: Set icon for all .zen files in a directory**
-```bash
-cd assets/logos
-find ../app -name "*.zen" -exec ./set-zen-icon.sh {} \;
-```
-
-**Option 3: Manual method**
-1. Open Finder and navigate to a `.zen` file
-2. Right-click the file and select "Get Info"
-3. Drag `zen.icns` onto the small icon in the top-left of the Get Info window
-4. Close the Get Info window
-
-### Recreating the .icns File
-
-If you update the SVG and need to regenerate the `.icns` file:
-```bash
-cd assets/logos
-./create-zen-icon.sh
-```
-
-## Usage
-
-These logos can be used in:
-- Documentation (`docs/`)
-- README files
-- Website/marketing materials
-- Framework branding
-- File type icons (`.zen` files)
-

package/bun.lock

@@ -1,39 +0,0 @@
-{
-  "lockfileVersion": 1,
-  "configVersion": 1,
-  "workspaces": {
-    "": {
-      "name": "zenith",
-      "dependencies": {
-        "@types/parse5": "^7.0.0",
-        "parse5": "^8.0.0",
-      },
-      "devDependencies": {
-        "@types/bun": "latest",
-        "prettier": "^3.7.4",
-      },
-      "peerDependencies": {
-        "typescript": "^5",
-      },
-    },
-  },
-  "packages": {
-    "@types/bun": ["@types/bun@1.3.5", "", { "dependencies": { "bun-types": "1.3.5" } }, "sha512-RnygCqNrd3srIPEWBd5LFeUYG7plCoH2Yw9WaZGyNmdTEei+gWaHqydbaIRkIkcbXwhBT94q78QljxN0Sk838w=="],
-
-    "@types/node": ["@types/node@25.0.3", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-W609buLVRVmeW693xKfzHeIV6nJGGz98uCPfeXI1ELMLXVeKYZ9m15fAMSaUPBHYLGFsVRcMmSCksQOrZV9BYA=="],
-
-    "@types/parse5": ["@types/parse5@7.0.0", "", { "dependencies": { "parse5": "*" } }, "sha512-f2SeAxumolBmhuR62vNGTsSAvdz/Oj0k682xNrcKJ4dmRnTPODB74j6CPoNPzBPTHsu7Y7W7u93Mgp8Ovo8vWw=="],
-
-    "bun-types": ["bun-types@1.3.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-inmAYe2PFLs0SUbFOWSVD24sg1jFlMPxOjOSSCYqUgn4Hsc3rDc7dFvfVYjFPNHtov6kgUeulV4SxbuIV/stPw=="],
-
-    "entities": ["entities@6.0.1", "", {}, "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g=="],
-
-    "parse5": ["parse5@8.0.0", "", { "dependencies": { "entities": "^6.0.0" } }, "sha512-9m4m5GSgXjL4AjumKzq1Fgfp3Z8rsvjRNbnkVwfu2ImRqE5D0LnY2QfDen18FSY9C573YU5XxSapdHZTZ2WolA=="],
-
-    "prettier": ["prettier@3.7.4", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-v6UNi1+3hSlVvv8fSaoUbggEM5VErKmmpGA7Pl3HF8V6uKY7rvClBOJlH6yNwQtfTueNkGVpOv/mtWL9L4bgRA=="],
-
-    "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
-
-    "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
-  }
-}

package/compiler/legacy/binding.ts

@@ -1,254 +0,0 @@
-// compiler/binding.ts
-// Phase 2: Reactive text bindings runtime generator
-// Generates code to update DOM when state values change
-// Extended to support component instance-scoped state
-
-import type { StateBinding } from "./types"
-
-// Extract instance ID and base state name from instance-scoped state name
-// e.g., "__zen_comp_0_clicks" -> { instanceId: "comp-0", baseState: "clicks" }
-function parseInstanceState(stateName: string): { instanceId: string; baseState: string } | null {
-  const match = stateName.match(/^__zen_comp_(\d+)_(.+)$/);
-  if (match) {
-    const instanceNum = match[1];
-    const baseState = match[2];
-    return { instanceId: `comp-${instanceNum}`, baseState };
-  }
-  return null;
-}
-
-export function generateBindingRuntime(
-  stateBindings: StateBinding[],
-  stateDeclarations: Map<string, string>
-): string {
-  if (stateBindings.length === 0 && stateDeclarations.size === 0) {
-    return "";
-  }
-
-  const stateNames = Array.from(stateDeclarations.keys());
-
-  // Separate global state and instance-scoped state
-  const globalStates = new Set<string>();
-  const instanceStates = new Map<string, Map<string, string[]>>(); // instanceId -> baseState -> fullStateNames
-
-  for (const stateName of stateNames) {
-    const instanceInfo = parseInstanceState(stateName);
-    if (instanceInfo) {
-      if (!instanceStates.has(instanceInfo.instanceId)) {
-        instanceStates.set(instanceInfo.instanceId, new Map());
-      }
-      const instanceMap = instanceStates.get(instanceInfo.instanceId)!;
-      if (!instanceMap.has(instanceInfo.baseState)) {
-        instanceMap.set(instanceInfo.baseState, []);
-      }
-      instanceMap.get(instanceInfo.baseState)!.push(stateName);
-    } else {
-      globalStates.add(stateName);
-    }
-  }
-
-  // Generate binding update map - collect all nodes for each state
-  // Order is preserved: bindings are processed in the order they appear in stateBindings array
-  // (which matches DOM traversal order from compilation)
-  const bindingMapEntries: string[] = [];
-  const bindingMap = new Map<string, string[]>();
-  
-  // Iterate over stateBindings array to preserve compile-time order
-  // Maps preserve insertion order, so this maintains deterministic ordering
-  for (const stateBinding of stateBindings) {
-    if (!bindingMap.has(stateBinding.stateName)) {
-      bindingMap.set(stateBinding.stateName, []);
-    }
-    const selectors = bindingMap.get(stateBinding.stateName)!;
-    // Push bindings in the order they appear in stateBinding.bindings array
-    // This preserves the DOM traversal order from compilation
-    for (const binding of stateBinding.bindings) {
-      const bindId = `bind-${binding.nodeIndex}`;
-      
-      // Check if this is an instance-scoped binding
-      const instanceInfo = parseInstanceState(stateBinding.stateName);
-      if (instanceInfo) {
-        // Scope selector to component instance root
-        selectors.push(`[data-zen-instance="${instanceInfo.instanceId}"] span[data-zen-bind="${stateBinding.stateName}"][data-zen-bind-id="${bindId}"]`);
-      } else {
-        // Global binding
-        selectors.push(`span[data-zen-bind="${stateBinding.stateName}"][data-zen-bind-id="${bindId}"]`);
-      }
-    }
-  }
-
-  // Generate update functions for each binding
-  // Each function captures a DOM node reference directly
-  // Map.entries() preserves insertion order, maintaining compile-time binding order
-  for (const [stateName, selectors] of bindingMap.entries()) {
-    if (selectors.length > 0) {
-      // Generate an array of update functions, each capturing a node reference
-      const updateFunctions = selectors.map((selector, index) => {
-        const escapedSelector = selector.replace(/"/g, '\\"');
-        // Create a function that captures the node and updates it
-        // We'll query the node once during init, then the function captures it
-        return `(function() {
-        const node = document.querySelector("${escapedSelector}");
-        return function(value) {
-          if (node) node.textContent = String(value);
-        };
-      })()`;
-      }).join(",\n      ");
-      
-      bindingMapEntries.push(
-        `    "${stateName}": [\n      ${updateFunctions}\n    ]`
-      );
-    }
-  }
-
-  const bindingMapCode = bindingMapEntries.length > 0 
-    ? `__zen_bindings = {\n${bindingMapEntries.join(",\n")}\n  };`
-    : `__zen_bindings = {};`;
-
-  // Generate global state initialization code
-  const globalStateInitCode = Array.from(globalStates).map(name => {
-    const initialValue = stateDeclarations.get(name) || "undefined";
-    return `
-  // Initialize global state: ${name}
-  (function() {
-    let __zen_${name} = ${initialValue};
-    Object.defineProperty(window, "${name}", {
-      get: function() { return __zen_${name}; },
-      set: function(value) {
-        __zen_${name} = value;
-        // Immediately trigger synchronous updates - no batching, no async
-        __zen_update_bindings("${name}", value);
-        // Also trigger dynamic expression updates
-        if (window.__zen_trigger_expression_updates) {
-          window.__zen_trigger_expression_updates("${name}");
-        }
-      },
-      enumerable: true,
-      configurable: true
-    });
-  })();`;
-  }).join("");
-
-  // Generate instance state initialization code
-  const instanceStateInitCode: string[] = [];
-  for (const [instanceId, baseStateMap] of instanceStates.entries()) {
-    const safeInstanceId = instanceId.replace(/-/g, '_');
-    
-    for (const [baseState, fullStateNames] of baseStateMap.entries()) {
-      // For each instance, create a state proxy scoped to that instance
-      // Only process the first fullStateName (they should all have the same instance)
-      const fullStateName = fullStateNames[0];
-      const initialValue = stateDeclarations.get(fullStateName) || "undefined";
-      
-      instanceStateInitCode.push(`
-  // Initialize instance-scoped state: ${fullStateName} (${instanceId}.${baseState})
-  (function() {
-    const instanceRoot = document.querySelector('[data-zen-instance="${instanceId}"]');
-    if (!instanceRoot) {
-      console.warn('[Zenith] Component instance "${instanceId}" not found in DOM');
-      return;
-    }
-    
-    let __zen_${safeInstanceId}_${baseState} = ${initialValue};
-    
-    // Create instance-scoped state proxy
-    const instanceState = new Proxy({}, {
-      get(target, prop) {
-        if (prop === '${baseState}') {
-          return __zen_${safeInstanceId}_${baseState};
-        }
-        return undefined;
-      },
-      set(target, prop, value) {
-        if (prop === '${baseState}') {
-          __zen_${safeInstanceId}_${baseState} = value;
-          // Trigger updates only for bindings within this instance
-          __zen_update_bindings("${fullStateName}", value);
-          return true;
-        }
-        return false;
-      }
-    });
-    
-    // Store instance state on window for component access
-    if (!window.__zen_instances) {
-      window.__zen_instances = {};
-    }
-    if (!window.__zen_instances["${instanceId}"]) {
-      window.__zen_instances["${instanceId}"] = instanceState;
-    } else {
-      window.__zen_instances["${instanceId}"].${baseState} = __zen_${safeInstanceId}_${baseState};
-    }
-    
-      // Create global property accessor for instance-scoped state
-    Object.defineProperty(window, "${fullStateName}", {
-      get: function() { return __zen_${safeInstanceId}_${baseState}; },
-      set: function(value) {
-        __zen_${safeInstanceId}_${baseState} = value;
-        // Update instance state object
-        if (window.__zen_instances && window.__zen_instances["${instanceId}"]) {
-          window.__zen_instances["${instanceId}"].${baseState} = value;
-        }
-        __zen_update_bindings("${fullStateName}", value);
-        // Also trigger attribute binding updates for this instance
-        if (window.__zen_update_attribute_bindings) {
-          window.__zen_update_attribute_bindings("${instanceId}");
-        }
-        // Also trigger dynamic expression updates
-        if (window.__zen_trigger_expression_updates) {
-          window.__zen_trigger_expression_updates("${fullStateName}");
-        }
-      },
-      enumerable: true,
-      configurable: true
-    });
-  })();`);
-    }
-  }
-
-  // Generate initialization call (after DOM is ready)
-  const initBindingsCode = stateNames.map(name => {
-    return `    __zen_update_bindings("${name}", ${name});`;
-  }).join("\n");
-
-  return `
-// Phase 2: Reactive text bindings runtime (with component instance support)
-(function() {
-  let __zen_bindings = {};
-
-  // Update function for a specific state
-  // Calls all registered update functions for the given state property
-  // Executes synchronously, immediately, in compile-order (array order)
-  // No batching, no async scheduling, no reordering
-  function __zen_update_bindings(stateName, value) {
-    const updaters = __zen_bindings[stateName];
-    if (updaters) {
-      // Execute update functions in deterministic order (compile-time order)
-      // forEach executes synchronously, preserving array order
-      updaters.forEach(updateFn => {
-        if (typeof updateFn === 'function') {
-          updateFn(value);
-        }
-      });
-    }
-  }
-
-${globalStateInitCode}
-${instanceStateInitCode.join('')}
-
-  // Initialize binding map and bindings after DOM is ready
-  function __zen_init_bindings() {
-${bindingMapCode.split('\n').map(line => '    ' + line).join('\n')}
-${initBindingsCode.split('\n').map(line => '    ' + line).join('\n')}
-  }
-
-  // Initialize bindings when DOM is ready (scripts are deferred, so DOM should be ready)
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', __zen_init_bindings);
-  } else {
-    __zen_init_bindings();
-  }
-})();
-`;
-}
-

package/compiler/legacy/bindings.ts

@@ -1,338 +0,0 @@
-// compiler/bindings.ts
-// Phase 2: Object-style dynamic attribute bindings with quoted expressions
-// Supports :class and :value attributes with synchronous, deterministic updates
-
-export function generateAttributeBindingRuntime(bindings: Array<{ type: 'class' | 'value'; expression: string }>): string {
-  if (bindings.length === 0) {
-    return ''; // No bindings, no runtime needed
-  }
-
-  // Generate unique expression IDs for tracking
-  const expressionIds = bindings.map((_, i) => `expr_${i}`);
-  const expressionsStr = JSON.stringify(bindings.map(b => b.expression));
-  const typesStr = JSON.stringify(bindings.map(b => b.type));
-
-  return `
-// Phase 2: Attribute binding runtime - synchronous, deterministic updates
-// Note: 'use strict' is omitted to allow 'with' statement for expression evaluation
-(function() {
-  
-  // Store all binding elements and their expressions
-  const bindingExpressions = ${expressionsStr};
-  const bindingTypes = ${typesStr};
-  const bindingElements = [];
-  
-  // Reactive state proxy - tracks property access and updates DOM synchronously
-  // Initialize with empty object - properties will be added dynamically
-  const stateTarget = {};
-  const stateProxy = new Proxy(stateTarget, {
-    set(target, prop, value) {
-      const oldValue = target[prop];
-      target[prop] = value;
-      
-      // Log state change for debugging
-      // console.log('[Zenith] State change:', prop, '=', value);
-      
-      // Synchronously update all affected bindings
-      bindingElements.forEach(binding => {
-        try {
-          // Re-evaluate expression in context of current state
-          // Pass target (the state object) as parameter to the evaluator function
-          // If this binding has instance state, merge it with global state
-          const mergedState = binding.instanceState 
-            ? Object.assign({}, target, binding.instanceState)
-            : target;
-          const result = binding.fn(mergedState);
-          
-          if (binding.type === 'class') {
-            updateClassBinding(binding.el, result);
-            // console.log('[Zenith] Updated :class binding for element:', binding.el, 'result:', result);
-          } else if (binding.type === 'value') {
-            updateValueBinding(binding.el, result);
-            // console.log('[Zenith] Updated :value binding for element:', binding.el, 'result:', result);
-          }
-        } catch (e) {
-          // Log errors for debugging (Phase 2: graceful degradation)
-          console.warn('[Zenith] Binding evaluation error:', e, 'for expression:', binding.expression);
-        }
-      });
-      
-      return true;
-    },
-    get(target, prop) {
-      // Return undefined for missing properties (don't throw errors)
-      return target[prop];
-    }
-  });
-  
-  // Make stateProxy available globally as 'state'
-  window.state = stateProxy;
-  
-  // Function to update attribute bindings for a specific component instance
-  // Called when instance-scoped state changes
-  function updateAttributeBindingsForInstance(instanceId) {
-    const instanceRoot = document.querySelector('[data-zen-instance="' + instanceId + '"]');
-    if (!instanceRoot) return;
-    
-    // Update all bindings within this instance
-    bindingElements.forEach(binding => {
-      // Check if this binding belongs to the instance
-      const bindingInstanceRoot = findInstanceRoot(binding.el);
-      if (bindingInstanceRoot === instanceRoot) {
-        try {
-          const instanceState = getInstanceStateForElement(binding.el);
-          const mergedState = instanceState 
-            ? Object.assign({}, stateProxy, instanceState)
-            : stateProxy;
-          const result = binding.fn(mergedState);
-          
-          if (binding.type === 'class') {
-            updateClassBinding(binding.el, result);
-          } else if (binding.type === 'value') {
-            updateValueBinding(binding.el, result);
-          }
-        } catch (e) {
-          console.warn('[Zenith] Attribute binding evaluation error:', e, 'for expression:', binding.expression);
-        }
-      }
-    });
-  }
-  
-  // Expose update function globally so text binding runtime can trigger it
-  window.__zen_update_attribute_bindings = updateAttributeBindingsForInstance;
-  
-  // Helper: Evaluate class binding expression
-  // Handles: objects, strings, empty objects, falsy values
-  // Preserves existing static classes from the class attribute
-  function updateClassBinding(el, result) {
-    // Store static classes on first update (from class attribute)
-    if (!el._zenStaticClasses) {
-      const staticClasses = el.getAttribute('class') || '';
-      el._zenStaticClasses = staticClasses.split(/\\s+/).filter(c => c);
-    }
-    const staticClassList = el._zenStaticClasses;
-    
-    if (typeof result === 'string') {
-      // String value: treat as raw class names, merge with static classes
-      const dynamicClasses = result.split(/\\s+/).filter(c => c);
-      el.className = [...staticClassList, ...dynamicClasses].join(' ').trim();
-    } else if (result && typeof result === 'object' && !Array.isArray(result)) {
-      // Object value: extract keys with true values
-      const dynamicClasses = [];
-      for (const key in result) {
-        if (result.hasOwnProperty(key) && result[key] === true) {
-          dynamicClasses.push(key);
-        }
-      }
-      // Merge static and dynamic classes
-      el.className = [...staticClassList, ...dynamicClasses].join(' ').trim();
-    } else {
-      // Falsy, null, undefined, or non-object: keep only static classes
-      el.className = staticClassList.join(' ').trim();
-    }
-  }
-  
-  // Helper: Evaluate value binding expression
-  // Handles: primitives, falsy values
-  function updateValueBinding(el, result) {
-    if (result === null || result === undefined) {
-      el.value = '';
-    } else {
-      el.value = String(result);
-    }
-  }
-  
-  // Helper: Safely evaluate expression string
-  // Creates a function that evaluates the expression with state properties in scope
-  // Supports both global state (via state object) and instance-scoped state (via window)
-  function createEvaluator(expression) {
-    // Trim whitespace from expression
-    let trimmed = expression.trim();
-    
-    // Check if expression is a quoted string (single or double quotes)
-    // If so, unquote it and check if it's a simple identifier
-    let isSimpleIdentifier = false;
-    let evalExpression = trimmed;
-    
-    // Handle quoted strings: "username" or 'username' -> username
-    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || 
-        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-      // Extract the unquoted value
-      const unquoted = trimmed.slice(1, -1);
-      // Check if unquoted value is a simple identifier
-      if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(unquoted)) {
-        isSimpleIdentifier = true;
-        evalExpression = unquoted; // Use unquoted identifier for evaluation
-      }
-      // Otherwise, treat as string literal (e.g., "'static-class'" -> "static-class")
-    } else {
-      // Not quoted: check if it's a simple identifier
-      isSimpleIdentifier = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(trimmed);
-      if (isSimpleIdentifier) {
-        evalExpression = trimmed; // Already unquoted identifier
-      }
-    }
-    
-    try {
-      // Create a function that evaluates the expression
-      // The expression is written as if state properties are directly accessible
-      // We use Function constructor with 'with' statement to make state properties available
-      // Note: 'with' is deprecated but necessary for this use case in non-strict mode
-      return function(state) {
-        try {
-          // Use window.__zen_eval_expr for consistent expression evaluation
-          // This handles window properties (state variables) correctly
-          if (typeof window !== 'undefined' && window.__zen_eval_expr) {
-            return window.__zen_eval_expr(evalExpression);
-          }
-          
-          // Fallback: Merge state with window to access instance-scoped state variables
-          // This allows expressions to reference both global state and instance-scoped state
-          // Copy window properties that look like instance-scoped state to the merged context
-          const mergedContext = Object.assign({}, state);
-          for (const key in window) {
-            if (key.startsWith('__zen_comp_') && !(key in mergedContext)) {
-              mergedContext[key] = window[key];
-            }
-          }
-          
-          // Use Function constructor to create evaluator
-          // The 'with' statement makes state properties and instance-scoped state available as variables
-          // This allows expressions like "{ active: isActive }" where isActive refers to state.isActive
-          // or instance-scoped variables like __zen_comp_0_clicks
-          const func = new Function('state', 
-            'try {' +
-            '  with (state) {' +
-            '    return (' + evalExpression + ');' +
-            '  }' +
-            '} catch (e) {' +
-            '  console.warn("[Zenith] Expression evaluation error:", ' + JSON.stringify(trimmed) + ', e);' +
-            '  return null;' +
-            '}'
-          );
-          const result = func(mergedContext);
-          // console.log('[Zenith] Evaluated expression:', trimmed, 'result:', result, 'state:', state);
-          return result;
-        } catch (e) {
-          // Last resort: return safe default
-          console.warn('Expression evaluation error:', trimmed, e);
-          const bindingIndex = bindingExpressions.indexOf(expression);
-          return bindingIndex >= 0 && bindingTypes[bindingIndex] === 'class' ? {} : '';
-        }
-      };
-    } catch (e) {
-      // If expression is invalid, return a function that returns empty string/object
-      console.warn('Invalid binding expression:', expression, e);
-      const bindingIndex = bindingExpressions.indexOf(expression);
-      return function() { 
-        return bindingIndex >= 0 && bindingTypes[bindingIndex] === 'class' ? {} : ''; 
-      };
-    }
-  }
-  
-  // Helper: Find component instance root for an element
-  function findInstanceRoot(el) {
-    let current = el;
-    while (current) {
-      if (current.hasAttribute && current.hasAttribute('data-zen-instance')) {
-        return current;
-      }
-      current = current.parentElement;
-    }
-    return null;
-  }
-  
-  // Helper: Get instance-scoped state for an element
-  function getInstanceStateForElement(el) {
-    const instanceRoot = findInstanceRoot(el);
-    if (instanceRoot) {
-      const instanceId = instanceRoot.getAttribute('data-zen-instance');
-      if (instanceId && window.__zen_instances && window.__zen_instances[instanceId]) {
-        return window.__zen_instances[instanceId];
-      }
-    }
-    return null;
-  }
-  
-  // Enhanced evaluator that supports both global and instance-scoped state
-  function createEnhancedEvaluator(expression, instanceState) {
-    const baseEvaluator = createEvaluator(expression);
-    return function(state) {
-      // Merge global state and instance state
-      const mergedState = Object.assign({}, state);
-      if (instanceState) {
-        Object.assign(mergedState, instanceState);
-      }
-      // Also check window for instance-scoped state variables (e.g., __zen_comp_0_clicks)
-      // These are set up by the binding runtime
-      return baseEvaluator(mergedState);
-    };
-  }
-  
-  // Initialize bindings after DOM is ready
-  function initializeBindings() {
-    // console.log('[Zenith] Initializing attribute bindings...');
-    
-    // Find all elements with data-zen-class or data-zen-value attributes
-    const classElements = document.querySelectorAll('[data-zen-class]');
-    const valueElements = document.querySelectorAll('[data-zen-value]');
-    
-    // console.log('[Zenith] Found', classElements.length, ':class bindings and', valueElements.length, ':value bindings');
-    
-    // Process :class bindings
-    classElements.forEach((el) => {
-      const expression = el.getAttribute('data-zen-class');
-      if (expression) {
-        // console.log('[Zenith] Setting up :class binding:', expression, 'for element:', el);
-        const instanceState = getInstanceStateForElement(el);
-        const fn = createEnhancedEvaluator(expression, instanceState);
-        
-        // Use merged state for initial evaluation
-        const mergedState = Object.assign({}, stateProxy);
-        if (instanceState) {
-          Object.assign(mergedState, instanceState);
-        }
-        const result = fn(mergedState);
-        updateClassBinding(el, result);
-        bindingElements.push({ el: el, type: 'class', expression, fn, instanceState });
-        // console.log('[Zenith] Initial :class result:', result, 'applied classes:', el.className);
-      }
-    });
-    
-    // Process :value bindings
-    valueElements.forEach((el) => {
-      const expression = el.getAttribute('data-zen-value');
-      if (expression) {
-        // console.log('[Zenith] Setting up :value binding:', expression, 'for element:', el);
-        const instanceState = getInstanceStateForElement(el);
-        const fn = createEnhancedEvaluator(expression, instanceState);
-        
-        // Use merged state for initial evaluation
-        const mergedState = Object.assign({}, stateProxy);
-        if (instanceState) {
-          Object.assign(mergedState, instanceState);
-        }
-        const result = fn(mergedState);
-        updateValueBinding(el, result);
-        bindingElements.push({ el: el, type: 'value', expression, fn, instanceState });
-        // console.log('[Zenith] Initial :value result:', result, 'applied value:', el.value);
-      }
-    });
-    
-    // Instance state proxies are set up by the text binding runtime
-    // Attribute binding updates are triggered via window.__zen_update_attribute_bindings
-    // when instance-scoped state changes
-    
-    // console.log('[Zenith] Initialized', bindingElements.length, 'bindings. State object:', stateProxy);
-  }
-  
-  // Initialize when DOM is ready
-  if (document.readyState === 'loading') {
-    document.addEventListener('DOMContentLoaded', initializeBindings);
-  } else {
-    initializeBindings();
-  }
-})();
-`;
-}
-