@zenithbuild/compiler 1.0.2

package/dist/test/compiler-authority.test.js

@@ -0,0 +1,90 @@
+import { expect, test, describe } from "bun:test";
+import { analyzeAndEmit } from "../runtime/analyzeAndEmit";
+function createIR(templateNodes = [], expressions = [], script = "") {
+    return {
+        filePath: "test.zen",
+        template: {
+            raw: "",
+            nodes: templateNodes,
+            expressions: expressions
+        },
+        script: {
+            raw: script,
+            attributes: {}
+        },
+        styles: [],
+        componentScripts: []
+    };
+}
+describe("Rust Compiler Authority", () => {
+    test("JSX transformation into __zenith.h", async () => {
+        const ir = createIR([], [{ id: "expr_jsx", code: "<div><span>Hello</span></div>" }], "state count = 0;");
+        const result = await analyzeAndEmit(ir);
+        const bundle = result.bundle;
+        // Should contain native indicators (like state. prefix or h() calls)
+        expect(bundle).toContain("state");
+        // Should contain __zenith.h calls in expressions
+        expect(result.expressions).toContain('__zenith.h("div"');
+        expect(result.expressions).toContain('__zenith.h("span"');
+        expect(result.expressions).toContain('"Hello"');
+        // Should NOT contain raw HTML tags
+        expect(result.expressions).not.toContain("<div>");
+    });
+    test("State identifier renaming - state. prefix", async () => {
+        const ir = createIR([], [{ id: "expr_state", code: "count + 1" }], "state count = 0;");
+        const result = await analyzeAndEmit(ir);
+        // Should be renamed to state.count
+        expect(result.expressions).toContain("state.count");
+        // It shouldn't be plain count + 1 (except maybe in some comment if we had one)
+        expect(result.expressions).not.toContain("return (count + 1)");
+    });
+    test("Local variables (loop vars) are NOT prefixed with state.", async () => {
+        const ir = createIR([
+            {
+                type: "loop-fragment",
+                itemVar: "item",
+                indexVar: "i",
+                source: "items",
+                body: [],
+                location: { line: 1, column: 1 }
+            }
+        ], [{ id: "expr_loop", code: "item.name + i" }], "state items = [];");
+        const result = await analyzeAndEmit(ir);
+        // item and i should STAY AS IS
+        expect(result.expressions).toContain("item.name + i");
+        expect(result.expressions).not.toContain("state.item");
+        expect(result.expressions).not.toContain("state.i");
+    });
+    test("Nested JSX with state and local variables", async () => {
+        const ir = createIR([
+            {
+                type: "loop-fragment",
+                itemVar: "item",
+                indexVar: "i",
+                source: "items",
+                body: [],
+                location: { line: 1, column: 1 }
+            }
+        ], [{ id: "expr_complex", code: "items.map(it => <div class={active ? 'active' : ''}>{it.name}</div>)" }], "state items = []; state active = true;");
+        const result = await analyzeAndEmit(ir);
+        // 1. JSX lowered
+        expect(result.expressions).toContain('__zenith.h("div"');
+        // 2. state.active
+        expect(result.expressions).toContain('state.active');
+        // 2. state.active
+        expect(result.expressions).toContain('class: state.active');
+        // 3. state.items
+        expect(result.expressions).toContain('state.items.map');
+        // 4. it.name stays as is (it's local to the map)
+        expect(result.expressions).toContain('[it.name]');
+        expect(result.expressions).not.toContain(': state.it');
+    });
+    test("JSX Attributes transformation", async () => {
+        const ir = createIR([], [{ id: "expr_attr", code: "<button disabled={loading} onclick={() => count++}>Click</button>" }], "state loading = false; state count = 0;");
+        const result = await analyzeAndEmit(ir);
+        expect(result.expressions).toContain('__zenith.h("button"');
+        // Attributes should be in an object
+        expect(result.expressions).toContain('disabled: state.loading');
+        expect(result.expressions).toContain('onclick: () => state.count++');
+    });
+});

package/dist/test/component-instance-test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/component-instance-test.js

@@ -0,0 +1,115 @@
+import { test, expect } from "bun:test";
+import { resolveComponentsInIR } from "../transform/componentResolver";
+// Helper to create a basic IR
+function createIR(nodes, expressions = []) {
+    return {
+        filePath: "test.zen",
+        template: {
+            raw: "",
+            nodes,
+            expressions
+        },
+        script: { raw: "", attributes: {} },
+        styles: [],
+        componentScripts: []
+    };
+}
+// Helper to create component metadata
+function createComponent(name, nodes, expressions) {
+    return {
+        name,
+        path: `${name}.zen`,
+        template: "",
+        nodes,
+        expressions,
+        slots: [],
+        props: [],
+        styles: [],
+        script: null,
+        scriptAttributes: null,
+        hasScript: false,
+        hasStyles: false
+    };
+}
+test("Component instantiation generates unique instance expression IDs", () => {
+    // Define a component "Card" with one expression {title}
+    // usage: <div>{title}</div>
+    const cardExpr = { id: "expr_card_1", code: "title", location: { line: 1, column: 1 } };
+    const cardNodes = [
+        {
+            type: "element",
+            tag: "div",
+            attributes: [],
+            children: [
+                {
+                    type: "expression",
+                    expression: "expr_card_1",
+                    location: { line: 1, column: 1 }
+                }
+            ],
+            location: { line: 1, column: 1 }
+        }
+    ];
+    const components = new Map();
+    components.set("Card", createComponent("Card", cardNodes, [cardExpr]));
+    // Create a page using <Card /> twice
+    // <root>
+    //   <Card />
+    //   <Card />
+    // </root>
+    const pageNodes = [
+        {
+            type: "element",
+            tag: "root",
+            attributes: [],
+            children: [
+                {
+                    type: "component",
+                    name: "Card",
+                    attributes: [],
+                    children: [],
+                    location: { line: 1, column: 1 }
+                },
+                {
+                    type: "component",
+                    name: "Card",
+                    attributes: [],
+                    children: [],
+                    location: { line: 2, column: 1 }
+                }
+            ],
+            location: { line: 0, column: 0 }
+        }
+    ];
+    const ir = createIR(pageNodes);
+    // Resolve components
+    const resolvedIR = resolveComponentsInIR(ir, components);
+    // Assertions
+    const root = resolvedIR.template.nodes[0];
+    expect(root.type).toBe("element");
+    expect(root.children.length).toBe(2);
+    const card1 = root.children[0];
+    const card2 = root.children[1];
+    // Check structure
+    expect(card1.type).toBe("element"); // Resolved to div
+    expect(card2.type).toBe("element");
+    // Check expression nodes inside
+    const exprNode1 = card1.children[0];
+    const exprNode2 = card2.children[0];
+    expect(exprNode1.type).toBe("expression");
+    expect(exprNode2.type).toBe("expression");
+    const id1 = exprNode1.expression;
+    const id2 = exprNode2.expression;
+    console.log(`Card 1 Expression ID: ${id1}`);
+    console.log(`Card 2 Expression ID: ${id2}`);
+    // Critically, IDs must be unique
+    expect(id1).not.toBe(id2);
+    expect(id1).not.toBe("expr_card_1"); // Should be rewritten
+    expect(id1).toContain("inst");
+    // Check registry
+    const registryIDs = resolvedIR.template.expressions.map(e => e.id);
+    expect(registryIDs).toContain(id1);
+    expect(registryIDs).toContain(id2);
+    // Ensure both are registered
+    expect(registryIDs.length).toBeGreaterThanOrEqual(2);
+});

package/dist/test/error-native-bridge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/error-native-bridge.test.js

@@ -0,0 +1,51 @@
+import { compileZenSource } from '../index';
+import { InvariantError } from '../errors/compilerError';
+/**
+ * Integration Test: Native Error Bridge
+ * Triggers an INV005 (TEMPLATE_TAG) error and verifies detailed info.
+ */
+async function testNativeErrorBridge() {
+    console.log('Testing Native Error Bridge (INV001-INV006)...');
+    const source = `
+<script>
+    const name = "Zenith";
+</script>
+
+<template>
+    <div>This is invalid because of the template tag</div>
+</template>
+    `;
+    try {
+        await compileZenSource(source, 'test-invalid.zen');
+        throw new Error('Should have thrown an InvariantError for <template> tag');
+    }
+    catch (e) {
+        if (e instanceof InvariantError) {
+            console.log('Caught InvariantError:', e.code);
+            if (e.code !== 'INV005') {
+                throw new Error(`Expected error code INV005, but got ${e.code}`);
+            }
+            if (e.context !== '<template>') {
+                throw new Error(`Expected context "<template>", but got "${e.context}"`);
+            }
+            if (!e.hints || e.hints.length === 0) {
+                throw new Error('Expected hints to be populated');
+            }
+            if (!e.hints.some(h => h.includes('Zenith component') || h.includes('Card.Header'))) {
+                throw new Error('Hints do not contain expected content');
+            }
+            console.log('✅ Native error bridge test passed');
+        }
+        else {
+            console.error('Unexpected error type:', e);
+            throw e;
+        }
+    }
+}
+// Run tests
+if (import.meta.main) {
+    testNativeErrorBridge().catch(e => {
+        console.error('❌ Integration test failed:', e.message);
+        process.exit(1);
+    });
+}

package/dist/test/error-serialization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/error-serialization.test.js

@@ -0,0 +1,38 @@
+import { InvariantError, CompilerError } from '../errors/compilerError';
+/**
+ * Test cases for the enhanced Error System
+ */
+function testErrorStructure() {
+    console.log('Testing CompilerError structure...');
+    const error = new CompilerError('Test message', 'test.zen', 10, 5, 'COMPILER_ERROR', 'TEST_CONTEXT', ['Hint 1', 'Hint 2']);
+    console.assert(error.message.includes('Test message'), 'Message should be preserved');
+    console.assert(error.file === 'test.zen', 'File should be preserved');
+    console.assert(error.line === 10, 'Line should be preserved');
+    console.assert(error.column === 5, 'Column should be preserved');
+    console.assert(error.context === 'TEST_CONTEXT', 'Context should be preserved');
+    console.assert(error.hints.length === 2, 'Hints should be preserved');
+    console.assert(error.hints[0] === 'Hint 1', 'Hint 1 should match');
+    console.log('✅ CompilerError structure test passed');
+}
+function testInvariantErrorStructure() {
+    console.log('Testing InvariantError structure...');
+    const error = new InvariantError('INV001', 'Invariant failed', 'Always be true', 'test.zen', 20, 15, 'INVARIANT_CONTEXT', ['Fix hint']);
+    console.assert(error.code === 'INV001', 'Code should be preserved');
+    console.assert(error.guarantee === 'Always be true', 'Guarantee should be preserved');
+    console.assert(error.errorType === 'InvariantViolation', 'Default errorType should be InvariantViolation');
+    console.assert(error.context === 'INVARIANT_CONTEXT', 'Context should be preserved');
+    console.assert(error.hints[0] === 'Fix hint', 'Hints should be preserved');
+    console.log('✅ InvariantError structure test passed');
+}
+// Run tests
+if (import.meta.main) {
+    try {
+        testErrorStructure();
+        testInvariantErrorStructure();
+        console.log('✅ All Error System unit tests passed!');
+    }
+    catch (e) {
+        console.error('❌ Tests failed:', e);
+        process.exit(1);
+    }
+}

package/dist/test/macro-inlining.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/macro-inlining.test.js

@@ -0,0 +1,178 @@
+import { test, expect } from "bun:test";
+import { resolveComponentsInIR } from "../transform/componentResolver";
+// Helper to create a basic ZenIR
+function createIR(templateContent, script = '') {
+    return {
+        filePath: 'test.zen',
+        template: {
+            raw: templateContent,
+            nodes: [],
+            expressions: []
+        },
+        script: {
+            raw: script,
+            attributes: {}
+        },
+        styles: [],
+        componentScripts: []
+    };
+}
+test("Selective symbol renaming in component expressions", async () => {
+    // 1. Mock component metadata
+    const counterMeta = {
+        name: "Counter",
+        hasScript: true,
+        script: "let count = 0; function inc() { count++; }",
+        expressions: [
+            { id: "expr_0", code: "count" },
+            { id: "expr_1", code: "Math.floor(count / 2)" }
+        ],
+        nodes: [
+            {
+                type: 'element',
+                tag: 'button',
+                attributes: [{ name: 'onclick', value: { id: 'expr_1', code: 'inc()', location: { line: 1, column: 1 } }, location: { line: 1, column: 1 } }],
+                children: [{ type: 'expression', expression: 'expr_0', location: { line: 1, column: 1 } }],
+                location: { line: 1, column: 1 }
+            }
+        ],
+        props: [],
+        styles: []
+    };
+    const components = new Map();
+    components.set("Counter", counterMeta);
+    // 2. Mock page IR with two counter instances
+    const pageIR = createIR("<Counter /><Counter />");
+    pageIR.template.nodes = [
+        { type: 'component', name: 'Counter', attributes: [], children: [], location: { line: 1, column: 1 } },
+        { type: 'component', name: 'Counter', attributes: [], children: [], location: { line: 1, column: 10 } }
+    ];
+    // 3. Resolve components
+    const resolvedIR = resolveComponentsInIR(pageIR, components);
+    // 4. Verify expressions are renamed
+    // We expect 4 expressions (2 per instance)
+    expect(resolvedIR.template.expressions.length).toBe(4);
+    // Check first instance
+    const expr0_inst0 = resolvedIR.template.expressions.find(e => e.id === "expr_0_inst0");
+    expect(expr0_inst0?.code).toBe("count_inst0");
+    // Check second instance
+    const expr0_inst1 = resolvedIR.template.expressions.find(e => e.id === "expr_0_inst1");
+    expect(expr0_inst1?.code).toBe("count_inst1");
+    // 5. Verify script renaming
+    expect(resolvedIR.script?.raw).toContain("let count_inst0 = 0");
+    expect(resolvedIR.script?.raw).toContain("function inc_inst0()");
+    expect(resolvedIR.script?.raw).toContain("let count_inst1 = 0");
+});
+test("Parent symbols are NOT renamed in component expressions", async () => {
+    const compMeta = {
+        name: "Hello",
+        hasScript: true,
+        script: "let local = 'hi';",
+        expressions: [
+            { id: "expr_0", code: "local + globalVar" }
+        ],
+        nodes: [],
+        props: [],
+        styles: []
+    };
+    const components = new Map();
+    components.set("Hello", compMeta);
+    const pageIR = createIR("<Hello />");
+    pageIR.template.nodes = [{ type: 'component', name: 'Hello', attributes: [], children: [], location: { line: 1, column: 1 } }];
+    const resIR = resolveComponentsInIR(pageIR, components);
+    const expr = resIR.template.expressions[0];
+    // 'local' should be renamed, 'globalVar' should NOT
+    expect(expr?.code).toContain("_inst");
+    expect(expr?.code).toContain("globalVar");
+    expect(expr?.code).not.toContain("globalVar_inst");
+});
+test("Macro Prop Substitution", async () => {
+    const compMeta = {
+        name: "Welcome",
+        hasScript: true,
+        script: "console.log(title)",
+        expressions: [
+            { id: "expr_0", code: "title" }
+        ],
+        nodes: [],
+        props: ["title"],
+        styles: []
+    };
+    const components = new Map();
+    components.set("Welcome", compMeta);
+    const pageIR = createIR("<Welcome title={pageTitle} />");
+    pageIR.template.nodes = [{
+            type: 'component',
+            name: 'Welcome',
+            attributes: [{
+                    name: 'title',
+                    value: { id: 'expr_P', code: 'pageTitle', location: { line: 1, column: 1 } },
+                    location: { line: 1, column: 1 }
+                }],
+            children: [],
+            location: { line: 1, column: 1 }
+        }];
+    const resolvedIR = resolveComponentsInIR(pageIR, components);
+    // Expression should be substituted with parent code
+    const expr = resolvedIR.template.expressions.find(e => e.id === "expr_0_inst0");
+    expect(expr?.code).toBe("(pageTitle)");
+    // Script should also be substituted
+    expect(resolvedIR.script?.raw).toContain("console.log((pageTitle))");
+});
+test("Event Handler Renaming in Template", async () => {
+    const compMeta = {
+        name: "Button",
+        hasScript: true,
+        script: "function handleClick() { console.log('clicked'); }",
+        expressions: [],
+        nodes: [
+            {
+                type: 'element',
+                tag: 'button',
+                attributes: [
+                    { name: 'onclick', value: 'handleClick', location: { line: 1, column: 1 } }
+                ],
+                children: [],
+                location: { line: 1, column: 1 }
+            }
+        ],
+        props: [],
+        styles: []
+    };
+    const components = new Map();
+    components.set("Button", compMeta);
+    const pageIR = createIR("<Button />");
+    pageIR.template.nodes = [{ type: 'component', name: 'Button', attributes: [], children: [], location: { line: 1, column: 1 } }];
+    const resolvedIR = resolveComponentsInIR(pageIR, components);
+    // The button's onclick should be renamed
+    const button = resolvedIR.template.nodes[0];
+    expect(button.attributes[0].value).toBe("handleClick_inst0");
+});
+test("Multi-instance isolation and props.prefix substitution", async () => {
+    const compMeta = {
+        name: "Box",
+        hasScript: true,
+        script: "const val = signal(props.initial);",
+        expressions: [{ id: "expr_0", code: "val.value + props.label" }],
+        nodes: [],
+        props: ["initial", "label"],
+        styles: []
+    };
+    const components = new Map();
+    components.set("Box", compMeta);
+    const pageIR = createIR("<Box initial={1} label='A' /><Box initial={10} label='B' />");
+    pageIR.template.nodes = [
+        { type: 'component', name: 'Box', attributes: [{ name: 'initial', value: { id: 'expr_P1', code: '1' } }, { name: 'label', value: 'A' }], children: [], location: { line: 1, column: 1 } },
+        { type: 'component', name: 'Box', attributes: [{ name: 'initial', value: { id: 'expr_P2', code: '10' } }, { name: 'label', value: 'B' }], children: [], location: { line: 1, column: 30 } }
+    ];
+    const resolvedIR = resolveComponentsInIR(pageIR, components);
+    // Verify first instance
+    const script = resolvedIR.script?.raw || "";
+    expect(script).toContain("const val_inst0 = signal((1))");
+    const expr0 = resolvedIR.template.expressions.find(e => e.id === "expr_0_inst0");
+    expect(expr0?.code).toBe("val_inst0.value + \"A\"");
+    // Verify second instance
+    expect(script).toContain("const val_inst1 = signal((10))");
+    const expr1 = resolvedIR.template.expressions.find(e => e.id === "expr_0_inst1");
+    expect(expr1?.code).toBe("val_inst1.value + \"B\"");
+});

package/dist/test/validate-test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Test Cases for Expression Validation
+ *
+ * Phase 8/9/10: Tests that invalid expressions fail the build
+ */
+export {};

package/dist/test/validate-test.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Test Cases for Expression Validation
+ *
+ * Phase 8/9/10: Tests that invalid expressions fail the build
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const validateExpressions_1 = require("../validate/validateExpressions");
+/**
+ * Test valid expressions
+ */
+function testValidExpressions() {
+    const validExpressions = [
+        {
+            id: 'expr_0',
+            code: 'user.name',
+            location: { line: 10, column: 5 }
+        },
+        {
+            id: 'expr_1',
+            code: 'count + 1',
+            location: { line: 11, column: 8 }
+        },
+        {
+            id: 'expr_2',
+            code: 'isActive ? "on" : "off"',
+            location: { line: 12, column: 12 }
+        }
+    ];
+    const result = (0, validateExpressions_1.validateExpressions)(validExpressions, 'test.zen');
+    console.assert(result.valid === true, 'Valid expressions should pass validation');
+    console.assert(result.errors.length === 0, 'Valid expressions should have no errors');
+    console.log('✅ Valid expressions test passed');
+}
+/**
+ * Test invalid expressions
+ */
+function testInvalidExpressions() {
+    const invalidExpressions = [
+        {
+            id: 'expr_0',
+            code: 'user.name}', // Mismatched brace
+            location: { line: 10, column: 5 }
+        }
+    ];
+    const result = (0, validateExpressions_1.validateExpressions)(invalidExpressions, 'test.zen');
+    console.assert(result.valid === false, 'Invalid expressions should fail validation');
+    console.assert(result.errors.length > 0, 'Invalid expressions should have errors');
+    console.log('✅ Invalid expressions test passed');
+}
+/**
+ * Test unsafe code detection
+ */
+function testUnsafeCode() {
+    const unsafeExpressions = [
+        {
+            id: 'expr_0',
+            code: 'eval("alert(1)")',
+            location: { line: 10, column: 5 }
+        }
+    ];
+    const result = (0, validateExpressions_1.validateExpressions)(unsafeExpressions, 'test.zen');
+    console.assert(result.valid === false, 'Unsafe code should fail validation');
+    console.assert(result.errors.length > 0, 'Unsafe code should have errors');
+    console.log('✅ Unsafe code detection test passed');
+}
+/**
+ * Test validateExpressionsOrThrow
+ */
+function testThrowOnInvalid() {
+    const invalidExpressions = [
+        {
+            id: 'expr_0',
+            code: 'user.name}', // Mismatched brace
+            location: { line: 10, column: 5 }
+        }
+    ];
+    try {
+        (0, validateExpressions_1.validateExpressionsOrThrow)(invalidExpressions, 'test.zen');
+        console.assert(false, 'Should have thrown on invalid expressions');
+    }
+    catch (error) {
+        console.assert(error instanceof Error, 'Should throw Error');
+        console.log('✅ Throw on invalid expressions test passed');
+    }
+}
+// Run tests
+if (require.main === module) {
+    console.log('Running validation tests...');
+    testValidExpressions();
+    testInvalidExpressions();
+    testUnsafeCode();
+    testThrowOnInvalid();
+    console.log('✅ All validation tests passed!');
+}

package/dist/transform/classifyExpression.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Expression Classification
+ *
+ * Analyzes expression code to determine output type for structural lowering.
+ *
+ * JSX expressions are allowed if — and only if — the compiler can statically
+ * enumerate all possible DOM shapes and lower them at compile time.
+ */
+/**
+ * Expression output types
+ *
+ * - primitive: string, number, boolean → text binding
+ * - conditional: cond ? <A /> : <B /> → ConditionalFragmentNode
+ * - optional: cond && <A /> → OptionalFragmentNode
+ * - loop: arr.map(i => <JSX />) → LoopFragmentNode
+ * - fragment: <A /> or <><A /><B /></> → inline fragment
+ * - unknown: cannot be statically determined → COMPILE ERROR
+ */
+export type ExpressionOutputType = 'primitive' | 'conditional' | 'optional' | 'loop' | 'fragment' | 'unknown';
+/**
+ * Classification result with extracted metadata
+ */
+export interface ExpressionClassification {
+    type: ExpressionOutputType;
+    condition?: string;
+    consequent?: string;
+    alternate?: string;
+    optionalCondition?: string;
+    optionalFragment?: string;
+    loopSource?: string;
+    loopItemVar?: string;
+    loopIndexVar?: string;
+    loopBody?: string;
+    fragmentCode?: string;
+}
+/**
+ * Classify expression output type
+ *
+ * @param code - The expression code to classify
+ * @returns Classification result with metadata
+ */
+export declare function classifyExpression(code: string): ExpressionClassification;
+/**
+ * Check if an expression type requires structural lowering
+ */
+export declare function requiresStructuralLowering(type: ExpressionOutputType): boolean;