@zenithbuild/core 1.2.0 → 1.2.2

package/compiler/test/map-lowering.test.ts

@@ -0,0 +1,130 @@
+import { parseTemplate } from '../parse/parseTemplate'
+import { transformTemplate } from '../transform/transformTemplate'
+import { lowerFragments } from '../transform/fragmentLowering'
+import { transformNode } from '../transform/transformNode'
+import type { ZenIR, TemplateNode, ExpressionNode, LoopFragmentNode } from '../ir/types'
+
+async function testMapLowering() {
+    console.log('--- Testing JSX .map() Lowering ---')
+
+    const source = `
+    <div>
+      {items.map((item, index) => (
+        <li key={index} class={item.active ? 'active' : ''}>
+          {item.text}
+        </li>
+      ))}
+    </div>
+  `
+
+    try {
+        const template = parseTemplate(source, 'test.zen')
+
+        // Recursive search for LoopFragmentNode
+        function findNode(nodes: TemplateNode[], type: string): any {
+            for (const node of nodes) {
+                if (node.type === type) return node
+                if ('children' in node) {
+                    const found = findNode(node.children, type)
+                    if (found) return found
+                }
+                if (node.type === 'loop-fragment') {
+                    const found = findNode(node.body, type)
+                    if (found) return found
+                }
+                if (node.type === 'conditional-fragment') {
+                    const foundC = findNode(node.consequent, type)
+                    if (foundC) return foundC
+                    const foundA = findNode(node.alternate, type)
+                    if (foundA) return foundA
+                }
+            }
+            return null
+        }
+
+        const loopNode = findNode(template.nodes, 'loop-fragment') as LoopFragmentNode
+
+        if (!loopNode) {
+            console.log('Template structure:', JSON.stringify(template.nodes, null, 2))
+            throw new Error('LoopFragmentNode not found in template')
+        }
+
+        console.assert(loopNode.source.startsWith('expr_'), 'Loop source should be an expression ID')
+        const sourceExpr = template.expressions.find(e => e.id === loopNode.source)
+        console.assert(sourceExpr?.code === 'items', `Expected source code "items", got "${sourceExpr?.code}"`)
+
+        // Check if inner expressions are registered
+        const li = loopNode.body.find(n => n.type === 'element' && n.tag === 'li') as any
+        const classAttr = li?.attributes.find((a: any) => a.name === 'class')
+        console.assert(classAttr?.value.id.startsWith('expr_'), 'Inner attribute expression should be an ID')
+
+        const textExpr = li?.children.find((n: any) => n.type === 'expression') as ExpressionNode
+        console.assert(textExpr?.expression.startsWith('expr_'), 'Inner text expression should be an ID')
+
+        // Final transformation
+        const ir: ZenIR = {
+            filePath: 'test.zen',
+            template,
+            script: null,
+            styles: []
+        }
+
+        const compiled = transformTemplate(ir)
+        console.assert(compiled.html.includes('data-zen-loop="loop_0"'), 'HTML should contain loop marker')
+        console.assert(compiled.html.includes(`data-zen-source="${loopNode.source}"`), 'HTML should contain source expression ID')
+
+        console.log('✅ JSX .map() lowering test passed')
+    } catch (e) {
+        console.error('❌ JSX .map() lowering test failed:', e)
+        process.exit(1)
+    }
+}
+
+async function testInvariantEnforcement() {
+    console.log('--- Testing INV-EXPR-REG-001 Invariant Enforcement ---')
+
+    const expressions: any[] = []
+    const badNode: ExpressionNode = {
+        type: 'expression',
+        expression: 'raw.code.here', // Should be expr_N
+        location: { line: 1, column: 1 }
+    }
+
+    try {
+        // We need to call lowerFragments but it calls assertNoRawExpressions
+        lowerFragments([badNode], 'test.zen', expressions)
+        console.error('❌ Invariant enforcement failed to catch raw expression')
+        process.exit(1)
+    } catch (e: any) {
+        console.assert(e.name === 'InvariantError', 'Expected InvariantError')
+        console.assert(e.message.includes('INV-EXPR-REG-001'), 'Expected INV-EXPR-REG-001 in error message')
+        console.log('✅ Invariant enforcement caught raw expression')
+    }
+
+    // Test transformNode safety
+    try {
+        const expressionsList: any[] = []
+        const badLoopNode: any = {
+            type: 'loop-fragment',
+            source: 'raw_source',
+            itemVar: 'item',
+            body: [],
+            location: { line: 1, column: 1 }
+        }
+        transformNode(badLoopNode, expressionsList)
+        console.error('❌ transformNode failed to catch raw loop source')
+        process.exit(1)
+    } catch (e: any) {
+        console.assert(e.name === 'InvariantError', 'Expected InvariantError in transformNode')
+        console.assert(e.message.includes('Raw loop source found'), 'Expected Loop source error')
+        console.log('✅ transformNode caught raw loop source')
+    }
+}
+
+async function runTests() {
+    await testMapLowering()
+    await testInvariantEnforcement()
+    console.log('--- All tests completed successfully ---')
+}
+
+runTests()

package/compiler/transform/fragmentLowering.ts

@@ -18,6 +18,7 @@ import type {
     OptionalFragmentNode,
     LoopFragmentNode,
     LoopContext,
+    AttributeIR,
     SourceLocation,
     ExpressionIR
 } from '../ir/types'
@@ -41,7 +42,12 @@ export function lowerFragments(
     filePath: string,
     expressions: ExpressionIR[]
 ): TemplateNode[] {
-    return nodes.map(node => lowerNode(node, filePath, expressions))
+    const lowered = nodes.map(node => lowerNode(node, filePath, expressions))
+
+    // INV-EXPR-REG-001 Enforcement
+    lowered.forEach(node => assertNoRawExpressions(node, filePath))
+
+    return lowered
 }
 
 /**
@@ -57,16 +63,11 @@ function lowerNode(
             return lowerExpressionNode(node, filePath, expressions)
 
         case 'element': {
-            // Check if this is a <for> element directive
-            if (node.tag === 'for') {
-                return lowerForElement(node, filePath, expressions)
-            }
-            
             // Check if this is an <html-content> element directive
             if (node.tag === 'html-content') {
                 return lowerHtmlContentElement(node, filePath, expressions)
             }
-            
+
             return {
                 ...node,
                 children: lowerFragments(node.children, filePath, expressions)
@@ -112,7 +113,15 @@ function lowerExpressionNode(
     filePath: string,
     expressions: ExpressionIR[]
 ): TemplateNode {
-    const classification = classifyExpression(node.expression)
+    // Resolve the expression ID to its original code for classification
+    const exprIR = expressions.find(e => e.id === node.expression)
+    if (!exprIR) {
+        // If not found in registry, it might already be an ID or an error
+        // But for classification we need the code.
+        return node
+    }
+
+    const classification = classifyExpression(exprIR.code)
 
     // Primitive expressions pass through unchanged
     if (classification.type === 'primitive') {
@@ -190,13 +199,16 @@ function lowerConditionalExpression(
     filePath: string,
     expressions: ExpressionIR[]
 ): ConditionalFragmentNode {
+    // Register condition
+    const conditionId = registerExpression(condition, node.location, expressions)
+
     // Parse both branches as JSX fragments
     const consequent = parseJSXToNodes(consequentCode, node.location, filePath, expressions, node.loopContext)
     const alternate = parseJSXToNodes(alternateCode, node.location, filePath, expressions, node.loopContext)
 
     return {
         type: 'conditional-fragment',
-        condition,
+        condition: conditionId,
         consequent,
         alternate,
         location: node.location,
@@ -216,11 +228,14 @@ function lowerOptionalExpression(
     filePath: string,
     expressions: ExpressionIR[]
 ): OptionalFragmentNode {
+    // Register condition
+    const conditionId = registerExpression(condition, node.location, expressions)
+
     const fragment = parseJSXToNodes(fragmentCode, node.location, filePath, expressions, node.loopContext)
 
     return {
         type: 'optional-fragment',
-        condition,
+        condition: conditionId,
         fragment,
         location: node.location,
         loopContext: node.loopContext
@@ -241,6 +256,9 @@ function lowerLoopExpression(
     filePath: string,
     expressions: ExpressionIR[]
 ): LoopFragmentNode {
+    // Register loop source as an expression ID
+    const sourceId = registerExpression(source, node.location, expressions)
+
     // Create loop context for the body
     const loopVariables = [itemVar]
     if (indexVar) {
@@ -251,7 +269,7 @@ function lowerLoopExpression(
         variables: node.loopContext
             ? [...node.loopContext.variables, ...loopVariables]
             : loopVariables,
-        mapSource: source
+        mapSource: sourceId // Use expression ID here
     }
 
     // Parse body with loop context
@@ -259,7 +277,7 @@ function lowerLoopExpression(
 
     return {
         type: 'loop-fragment',
-        source,
+        source: sourceId, // Use expression ID here
         itemVar,
         indexVar,
         body,
@@ -287,95 +305,6 @@ function lowerInlineFragment(
     return node
 }
 
-/**
- * Lower <for> element directive to LoopFragmentNode
- * 
- * Syntax: <for each="item" in="items">...body...</for>
- * Or:     <for each="item, index" in="items">...body...</for>
- * 
- * This is compile-time sugar for {items.map(item => ...)}
- */
-function lowerForElement(
-    node: import('../ir/types').ElementNode,
-    filePath: string,
-    expressions: ExpressionIR[]
-): LoopFragmentNode {
-    // Extract 'each' and 'in' attributes
-    const eachAttr = node.attributes.find(a => a.name === 'each')
-    const inAttr = node.attributes.find(a => a.name === 'in')
-    
-    if (!eachAttr || typeof eachAttr.value !== 'string') {
-        throw new InvariantError(
-            'ZEN001',
-            `<for> element requires an 'each' attribute specifying the item variable`,
-            'Usage: <for each="item" in="items">...body...</for>',
-            filePath,
-            node.location.line,
-            node.location.column
-        )
-    }
-    
-    if (!inAttr || typeof inAttr.value !== 'string') {
-        throw new InvariantError(
-            'ZEN001',
-            `<for> element requires an 'in' attribute specifying the source array`,
-            'Usage: <for each="item" in="items">...body...</for>',
-            filePath,
-            node.location.line,
-            node.location.column
-        )
-    }
-    
-    // Parse item variable (may include index: "item, index" or "item, i")
-    const eachValue = eachAttr.value.trim()
-    let itemVar: string
-    let indexVar: string | undefined
-    
-    if (eachValue.includes(',')) {
-        const parts = eachValue.split(',').map(p => p.trim())
-        itemVar = parts[0]!
-        indexVar = parts[1]
-    } else {
-        itemVar = eachValue
-    }
-    
-    const source = inAttr.value.trim()
-    
-    // Create loop context for the body
-    const loopVariables = [itemVar]
-    if (indexVar) {
-        loopVariables.push(indexVar)
-    }
-    
-    const bodyLoopContext: LoopContext = {
-        variables: node.loopContext
-            ? [...node.loopContext.variables, ...loopVariables]
-            : loopVariables,
-        mapSource: source
-    }
-    
-    // Lower children with loop context
-    const body = node.children.map(child => {
-        // Recursively lower children
-        const lowered = lowerNode(child, filePath, expressions)
-        // Attach loop context to children that need it
-        if ('loopContext' in lowered) {
-            return { ...lowered, loopContext: bodyLoopContext }
-        }
-        return lowered
-    })
-    
-    return {
-        type: 'loop-fragment',
-        source,
-        itemVar,
-        indexVar,
-        body,
-        location: node.location,
-        loopContext: bodyLoopContext
-    }
-}
-
 /**
  * Lower <html-content> element directive
  * 
@@ -391,7 +320,7 @@ function lowerHtmlContentElement(
 ): TemplateNode {
     // Extract 'content' attribute
     const contentAttr = node.attributes.find(a => a.name === 'content')
-    
+
     if (!contentAttr || typeof contentAttr.value !== 'string') {
         throw new InvariantError(
             'ZEN001',
@@ -402,9 +331,9 @@ function lowerHtmlContentElement(
             node.location.column
         )
     }
-    
+
     const exprCode = contentAttr.value.trim()
-    
+
     // Generate expression ID and register the expression
     const exprId = `expr_${expressions.length}`
     const exprIR: ExpressionIR = {
@@ -413,7 +342,7 @@ function lowerHtmlContentElement(
         location: node.location
     }
     expressions.push(exprIR)
-    
+
     // Create a span element with data-zen-html attribute for raw HTML binding
     return {
         type: 'element',
@@ -428,6 +357,101 @@ function lowerHtmlContentElement(
     }
 }
 
+/**
+ * Register a raw expression code string and return its ID
+ */
+function registerExpression(
+    code: string,
+    location: SourceLocation,
+    expressions: ExpressionIR[]
+): string {
+    const id = `expr_${expressions.length}`
+    expressions.push({ id, code, location })
+    return id
+}
+
+/**
+ * INV-EXPR-REG-001: Assert no raw expressions exist beyond parse phase
+ */
+function assertNoRawExpressions(node: TemplateNode, filePath: string): void {
+    const errorPrefix = `Compiler invariant violated: runtime expression used without registration. This is a compiler bug, not a user error.`
+
+    switch (node.type) {
+        case 'expression':
+            if (!node.expression.startsWith('expr_')) {
+                throw new InvariantError(
+                    'INV-EXPR-REG-001',
+                    `${errorPrefix}\nRaw expression found: "${node.expression}"`,
+                    'Every expression must be registered and referenced by ID.',
+                    filePath,
+                    node.location.line,
+                    node.location.column
+                )
+            }
+            break
+
+        case 'loop-fragment':
+            if (!node.source.startsWith('expr_')) {
+                throw new InvariantError(
+                    'INV-EXPR-REG-001',
+                    `${errorPrefix}\nRaw loop source found: "${node.source}"`,
+                    'Loop sources must be registered and referenced by ID.',
+                    filePath,
+                    node.location.line,
+                    node.location.column
+                )
+            }
+            node.body.forEach(child => assertNoRawExpressions(child, filePath))
+            break
+
+        case 'conditional-fragment':
+            if (!node.condition.startsWith('expr_')) {
+                throw new InvariantError(
+                    'INV-EXPR-REG-001',
+                    `${errorPrefix}\nRaw condition found: "${node.condition}"`,
+                    'Conditional expressions must be registered and referenced by ID.',
+                    filePath,
+                    node.location.line,
+                    node.location.column
+                )
+            }
+            node.consequent.forEach(child => assertNoRawExpressions(child, filePath))
+            node.alternate.forEach(child => assertNoRawExpressions(child, filePath))
+            break
+
+        case 'optional-fragment':
+            if (!node.condition.startsWith('expr_')) {
+                throw new InvariantError(
+                    'INV-EXPR-REG-001',
+                    `${errorPrefix}\nRaw condition found: "${node.condition}"`,
+                    'Optional expressions must be registered and referenced by ID.',
+                    filePath,
+                    node.location.line,
+                    node.location.column
+                )
+            }
+            node.fragment.forEach(child => assertNoRawExpressions(child, filePath))
+            break
+
+        case 'element':
+        case 'component':
+            node.attributes.forEach(attr => {
+                if (typeof attr.value !== 'string' && !attr.value.id.startsWith('expr_')) {
+                    throw new InvariantError(
+                        'INV-EXPR-REG-001',
+                        `${errorPrefix}\nRaw attribute expression found: "${(attr.value as any).code}"`,
+                        'Attribute expressions must be registered and referenced by ID.',
+                        filePath,
+                        attr.location.line,
+                        attr.location.column
+                    )
+                }
+            })
+            node.children.forEach(child => assertNoRawExpressions(child, filePath))
+            break
+    }
+}
+
 /**
  * Parse JSX code string into TemplateNode[]
  * 
@@ -537,9 +561,11 @@ function parseJSXChildren(
 
                 const exprCode = content.slice(i + 1, endBrace - 1).trim()
                 if (exprCode) {
+                    // Register inner expression
+                    const exprId = registerExpression(exprCode, baseLocation, expressions)
                     nodes.push({
                         type: 'expression',
-                        expression: exprCode,
+                        expression: exprId,
                         location: baseLocation,
                         loopContext
                     })
@@ -598,7 +624,7 @@ function parseJSXElementWithEnd(
     let i = startIndex + tagMatch[0].length
 
     // Parse attributes (simplified)
-    const attributes: Array<{ name: string; value: string; location: SourceLocation }> = []
+    const attributes: AttributeIR[] = []
 
     // Skip whitespace and parse attributes until > or />
     while (i < code.length) {
@@ -667,7 +693,14 @@ function parseJSXElementWithEnd(
         } else if (code[i] === '{') {
             const endBrace = findBalancedBraceEnd(code, i)
             if (endBrace !== -1) {
-                attributes.push({ name: attrName, value: code.slice(i, endBrace), location: baseLocation })
+                const exprCode = code.slice(i + 1, endBrace - 1).trim()
+                const exprId = registerExpression(exprCode, baseLocation, expressions)
+
+                attributes.push({
+                    name: attrName,
+                    value: { id: exprId, code: exprCode, location: baseLocation },
+                    location: baseLocation
+                })
                 i = endBrace
             }
         }

package/compiler/transform/transformNode.ts

@@ -6,19 +6,22 @@
  * Phase 8: Supports fragment node types (loop-fragment, conditional-fragment, optional-fragment)
  */
 
-import type { 
-  TemplateNode, 
-  ElementNode, 
-  TextNode, 
-  ExpressionNode, 
-  ExpressionIR, 
+import type {
+  TemplateNode,
+  ElementNode,
+  TextNode,
+  ExpressionNode,
+  ExpressionIR,
   LoopContext,
   LoopFragmentNode,
   ConditionalFragmentNode,
   OptionalFragmentNode,
-  ComponentNode
+  ComponentNode,
+  SourceLocation
 } from '../ir/types'
 import type { Binding } from '../output/types'
+import { InvariantError } from '../errors/compilerError'
+import { INVARIANT } from '../validate/invariants'
 
 let loopIdCounter = 0
 
@@ -126,7 +129,8 @@ export function transformNode(
       }
 
       case 'loop-fragment': {
-        // Loop fragment: {items.map(item => <li>...</li>)} or <for each="item" in="items">
+        // Loop fragment: {items.map(item => <li>...</li>)}
+        // .map() is compile-time sugar, lowered to LoopFragmentNode
         // For SSR/SSG, we render one instance of the body as a template
         // The runtime will hydrate and expand this for each actual item
         const loopNode = node as LoopFragmentNode
@@ -152,7 +156,7 @@ export function transformNode(
         // For SSR, we render ONE visible instance of the body as a template/placeholder
         // The runtime will clone this for each item in the array
         const bodyHtml = loopNode.body.map(child => transform(child, activeLoopContext)).join('')
-        
+
         // Render container with body visible for SSR (not in hidden <template>)
         // Runtime will clear and re-render with actual data
         return `<div data-zen-loop="${loopId}" data-zen-source="${escapeHtml(loopNode.source)}" data-zen-item="${loopNode.itemVar}"${loopNode.indexVar ? ` data-zen-index="${loopNode.indexVar}"` : ''} style="display: contents;">${bodyHtml}</div>`
@@ -207,7 +211,7 @@ export function transformNode(
         // This is a fallback for unresolved components
         const compNode = node as ComponentNode
         console.warn(`[Zenith] Unresolved component in transformNode: ${compNode.name}`)
-        
+
         // Render children as a fragment
         const childrenHtml = compNode.children.map(child => transform(child, loopContext)).join('')
         return `<!-- unresolved: ${compNode.name} -->${childrenHtml}`
@@ -222,9 +226,80 @@ export function transformNode(
   }
 
   const html = transform(node, parentLoopContext)
+
+  // INV-EXPR-REG-001 Enforcement: Before emitting HTML, assert all bindings resolve
+  checkEveryBindingResolves(bindings, expressions)
+
   return { html, bindings }
 }
 
+/**
+ * INV-EXPR-REG-001: Assert every data-zen-* reference resolves to a registered expression
+ */
+function checkEveryBindingResolves(bindings: Binding[], expressions: ExpressionIR[]): void {
+  const errorPrefix = `Compiler invariant violated: runtime expression used without registration. This is a compiler bug, not a user error.`
+
+  for (const binding of bindings) {
+    const exprId = binding.id
+    const resolved = expressions.find(e => e.id === exprId)
+
+    if (!resolved && binding.type !== 'loop') {
+      // Loop bindings might have a generated loopId that doesn't 
+      // exist in the expressions array, but they have a source expression ID
+    }
+
+    // Check loop source specifically
+    if (binding.type === 'loop') {
+      const sourceExprId = binding.expression
+      if (!sourceExprId.startsWith('expr_')) {
+        throw new InvariantError(
+          'INV-EXPR-REG-001',
+          `${errorPrefix}\nLoop fragment references invalid source expression: "${sourceExprId}"`,
+          'Loop fragments must reference a valid registered expression ID.',
+          'unknown', // transformNode doesn't have filePath, but we can't easily get it here without changing signature
+          binding.location?.line || 1,
+          binding.location?.column || 1
+        )
+      }
+
+      const sourceResolved = expressions.find(e => e.id === sourceExprId)
+      if (!sourceResolved) {
+        throw new InvariantError(
+          'INV-EXPR-REG-001',
+          `${errorPrefix}\nLoop source expression "${sourceExprId}" not found in registry.`,
+          'Every loop source must be registered as an ExpressionIR.',
+          'unknown',
+          binding.location?.line || 1,
+          binding.location?.column || 1
+        )
+      }
+    } else {
+      // General expression check
+      if (!exprId.startsWith('expr_')) {
+        throw new InvariantError(
+          'INV-EXPR-REG-001',
+          `${errorPrefix}\nBinding references invalid expression ID: "${exprId}"`,
+          'Every binding must reference a valid registered expression ID.',
+          'unknown',
+          binding.location?.line || 1,
+          binding.location?.column || 1
+        )
+      }
+
+      if (!resolved) {
+        throw new InvariantError(
+          'INV-EXPR-REG-001',
+          `${errorPrefix}\nExpression ID "${exprId}" not found in registry.`,
+          'Every binding must resolve to a registered expression.',
+          'unknown',
+          binding.location?.line || 1,
+          binding.location?.column || 1
+        )
+      }
+    }
+  }
+}
+
 /**
  * Escape HTML special characters
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/core",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Core library for the Zenith framework",
   "license": "MIT",
   "type": "module",
@@ -77,4 +77,4 @@
     "parse5": "^8.0.0",
     "picocolors": "^1.1.1"
   }
-}
+}