@zenithbuild/compiler 1.3.2 → 1.3.9

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/phase5-boundary.test.d.ts

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

package/dist/test/phase5-boundary.test.js

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'bun:test';
+import { compile } from '../index';
+import * as Compiler from '../index';
+/**
+ * Phase 5: Boundary & Integration Lockdown
+ *
+ * These tests ensure that the Zenith Compiler enforces strict boundaries:
+ * 1. The CLI acts as a thin transport.
+ * 2. The Internal API is locked down (only specific exports).
+ * 3. Legacy paths are removed.
+ */
+describe('Phase 5: Boundary Contracts', () => {
+    it('Should expose only the allowed API surface', () => {
+        const exportedKeys = Object.keys(Compiler);
+        // Allowed public exports (Hardened Surface)
+        const allowed = [
+            'compile',
+            'parseZenFile',
+            // Types are allowed (and don't show up in Object.keys except in some environments, but we list them if they do)
+            'FinalizedOutput',
+            'CompiledTemplate'
+        ];
+        // Ensure everything exported is in the allowed list
+        exportedKeys.forEach(key => {
+            expect(allowed).toContain(key);
+        });
+        // Ensure important ones are present
+        expect(Compiler.compile).toBeDefined();
+    });
+    it('Should compile a simple file without side effects (Purity Check)', async () => {
+        const source = `
+        <script>
+        state count = 0;
+        </script>
+        <button on:click={() => count++}>{count}</button>
+        `;
+        const result = await compile(source, 'integrity-check.zen', {});
+        expect(result.finalized).toBeDefined();
+        // Ensure no "patching" logic in pure compile result
+        // (If there was patching in CLI, it's not here)
+    });
+    // Verify Legacy Paths are Gone
+    it('Should NOT expose compileZenSource (Legacy)', () => {
+        // @ts-ignore
+        expect(Compiler.compileZenSource).toBeUndefined();
+    });
+    it('Should NOT expose old build modes', () => {
+        // @ts-ignore
+        expect(Compiler.buildSPA).toBeUndefined();
+    });
+});

package/dist/transform/layoutProcessor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Layout Processor - wraps page content with layout HTML
+ *
+ * This module provides TypeScript-based layout processing by replacing
+ * the default slot in a layout with the page content.
+ */
+export interface LayoutDefinition {
+    name: string;
+    filePath: string;
+    html: string;
+    props?: string[];
+    styles?: string[];
+    scripts?: string[];
+}
+/**
+ * Process layout wrapping for a Zenith source file.
+ *
+ * Takes page source content and wraps it with the layout HTML,
+ * replacing the <slot /> placeholder with the page content.
+ *
+ * @param source - The source content of the page
+ * @param layout - The layout definition
+ * @param _props - Optional props (reserved for future use)
+ * @returns Processed source with layout applied
+ */
+export declare function processLayout(source: string, layout: LayoutDefinition | string, _props?: Record<string, any>): string;

package/dist/transform/layoutProcessor.js

@@ -0,0 +1,34 @@
+/**
+ * Layout Processor - wraps page content with layout HTML
+ *
+ * This module provides TypeScript-based layout processing by replacing
+ * the default slot in a layout with the page content.
+ */
+/**
+ * Process layout wrapping for a Zenith source file.
+ *
+ * Takes page source content and wraps it with the layout HTML,
+ * replacing the <slot /> placeholder with the page content.
+ *
+ * @param source - The source content of the page
+ * @param layout - The layout definition
+ * @param _props - Optional props (reserved for future use)
+ * @returns Processed source with layout applied
+ */
+export function processLayout(source, layout, _props) {
+    // If layout is a string path, return source unchanged (caller should resolve)
+    if (typeof layout === 'string') {
+        return source;
+    }
+    // Extract template portion from page source (content between close of <script> and open of <style> or end)
+    // For now, pass through - the native compiler handles layout via parseFullZenNative options
+    const layoutHtml = layout.html;
+    // Replace default slot with page content
+    // The slot syntax in Zenith is <slot /> or <slot></slot>
+    const slotPattern = /<slot\s*\/?>/gi;
+    if (slotPattern.test(layoutHtml)) {
+        return layoutHtml.replace(slotPattern, source);
+    }
+    // If no slot found, append page content
+    return layoutHtml + '\n' + source;
+}

package/dist/validate/invariants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Invariant Validation
+ *
+ * NATIVE BRIDGE: All validation logic exists in Rust (`native/compiler-native/src/validate.rs`).
+ * The NAPI function `validateIr(irJson)` is the sole semantic authority.
+ */
+import type { ZenIR } from '../ir/types';
+/**
+ * Native bridge for IR validation
+ */
+export declare function validateIr(ir: ZenIR): void;
+export declare const INVARIANT: {
+    readonly LOOP_CONTEXT_LOST: "INV001";
+    readonly ATTRIBUTE_NOT_FORWARDED: "INV002";
+    readonly UNRESOLVED_COMPONENT: "INV003";
+    readonly REACTIVE_BOUNDARY: "INV004";
+    readonly TEMPLATE_TAG: "INV005";
+    readonly SLOT_ATTRIBUTE: "INV006";
+    readonly ORPHAN_COMPOUND: "INV007";
+    readonly NON_ENUMERABLE_JSX: "INV008";
+    readonly UNREGISTERED_EXPRESSION: "INV009";
+    readonly COMPONENT_PRECOMPILED: "INV010";
+};

package/dist/validate/invariants.js

@@ -0,0 +1,55 @@
+/**
+ * Invariant Validation
+ *
+ * NATIVE BRIDGE: All validation logic exists in Rust (`native/compiler-native/src/validate.rs`).
+ * The NAPI function `validateIr(irJson)` is the sole semantic authority.
+ */
+import { InvariantError } from '../errors/compilerError';
+let native;
+try {
+    try {
+        native = require('../../native/compiler-native');
+    }
+    catch {
+        native = require('../../native/compiler-native/index.js');
+    }
+}
+catch (e) {
+    // Bridge load handled elsewhere
+}
+/**
+ * Native bridge for IR validation
+ */
+export function validateIr(ir) {
+    if (native && native.validateIr) {
+        const validationIR = {
+            filePath: ir.filePath,
+            template: {
+                raw: ir.template.raw,
+                nodes: ir.template.nodes,
+                expressions: ir.template.expressions,
+            },
+            styles: ir.styles,
+            script: ir.script,
+        };
+        const error = native.validateIr(JSON.stringify(validationIR));
+        if (error) {
+            throw new InvariantError(error.code, error.message, error.guarantee, error.file, error.line, error.column, error.context, error.hints);
+        }
+    }
+    else {
+        throw new Error('[Zenith Native] Validation bridge unavailable');
+    }
+}
+export const INVARIANT = {
+    LOOP_CONTEXT_LOST: 'INV001',
+    ATTRIBUTE_NOT_FORWARDED: 'INV002',
+    UNRESOLVED_COMPONENT: 'INV003',
+    REACTIVE_BOUNDARY: 'INV004',
+    TEMPLATE_TAG: 'INV005',
+    SLOT_ATTRIBUTE: 'INV006',
+    ORPHAN_COMPOUND: 'INV007',
+    NON_ENUMERABLE_JSX: 'INV008',
+    UNREGISTERED_EXPRESSION: 'INV009',
+    COMPONENT_PRECOMPILED: 'INV010',
+};

package/native/compiler-native/index.d.ts

@@ -20,25 +20,7 @@ export interface ScriptImport {
   typeOnly: boolean
   sideEffect: boolean
 }
-export declare function generateRuntimeCode(inputJson: string): RuntimeCode
 export declare function generateCodegenIntent(): string
-export declare function resolveComponentsNative(irJson: string, componentsJson: string): string
-/** Discover all components in a directory */
-export declare function discoverComponentsNative(baseDir: string): any
-export declare function extractStylesNative(source: string): Array<string>
-export declare function extractPageBindingsNative(script: string): Array<string>
-export declare function extractPagePropsNative(script: string): Array<string>
-export interface VirtualModule {
-  id: string
-  code: string
-}
-export interface BundlePlan {
-  entry: string
-  platform: string
-  format: string
-  resolveRoots: Array<string>
-  virtualModules: Array<VirtualModule>
-}
 /**
  * Manifest export for the bundler's capability-based chunking.
  * This is the Compiler → Bundler handshake contract.
@@ -60,6 +42,8 @@ export interface ZenManifestExport {
   requiredCapabilities: Array<string>
   /** Compiled script content (author code) */
   script: string
+  /** Full hydrated bundle */
+  bundle: string
   /** Compiled expressions */
   expressions: string
   /** Compiled styles */
@@ -74,10 +58,6 @@ export interface FinalizedOutput {
   /** Manifest for bundler's capability-based chunking */
   manifest?: ZenManifestExport
 }
-export declare function finalizeOutputNative(irJson: any, compiledJson: any): FinalizedOutput
-export declare function parseTemplateNative(html: string, filePath: string): any
-export declare function parseScriptNative(html: string): any | null
-export declare function isComponentTagNative(tagName: string): boolean
 /**
  * Full Zenith compilation entry point - the "One True Syscall"
  *
@@ -92,29 +72,6 @@ export interface ParseFullOptions {
   props?: any
 }
 export declare function parseFullZenNative(source: string, filePath: string, optionsJson: string): any
-export interface ExpressionAnalysisResult {
-  id: string
-  classification: string
-  dependencies: Array<string>
-  usesState: boolean
-  usesLoopContext: boolean
-}
-export interface EvaluatedExpression {
-  id: string
-  expressionType: string
-  dependencies: Array<string>
-  usesState: boolean
-  usesLoopContext: boolean
-  classificationJson: string
-}
-export interface AnalysisOutput {
-  results: Array<ExpressionAnalysisResult>
-  bindingCount: number
-}
-export declare function lowerFragmentsNative(nodesJson: string, expressionsJson: string, filePath: string): string
-export declare function evaluateExpressionNative(id: string, code: string, knownBindingsJson: string, loopContextJson?: string | undefined | null): EvaluatedExpression
-export declare function classifyExpressionNative(code: string): string
-export declare function analyzeExpressions(inputJson: string): AnalysisOutput
 export interface Binding {
   id: string
   type: string
@@ -147,6 +104,5 @@ export interface LoopContext {
   variables: Array<string>
   mapSource?: string
 }
-export declare function validateIr(irJson: string): CompilerError | null
 export declare function compileBridge(): string
 export declare class ResolutionContext { }

package/native/compiler-native/index.js

@@ -310,25 +310,10 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { generateRuntimeCode, generateCodegenIntent, ResolutionContext, resolveComponentsNative, discoverComponentsNative, extractStylesNative, extractPageBindingsNative, extractPagePropsNative, finalizeOutputNative, parseTemplateNative, parseScriptNative, isComponentTagNative, parseFullZenNative, lowerFragmentsNative, evaluateExpressionNative, classifyExpressionNative, analyzeExpressions, transformTemplateNative, validateIr, compileBridge } = nativeBinding
+const { generateCodegenIntent, ResolutionContext, parseFullZenNative, transformTemplateNative, compileBridge } = nativeBinding
 
-module.exports.generateRuntimeCode = generateRuntimeCode
 module.exports.generateCodegenIntent = generateCodegenIntent
 module.exports.ResolutionContext = ResolutionContext
-module.exports.resolveComponentsNative = resolveComponentsNative
-module.exports.discoverComponentsNative = discoverComponentsNative
-module.exports.extractStylesNative = extractStylesNative
-module.exports.extractPageBindingsNative = extractPageBindingsNative
-module.exports.extractPagePropsNative = extractPagePropsNative
-module.exports.finalizeOutputNative = finalizeOutputNative
-module.exports.parseTemplateNative = parseTemplateNative
-module.exports.parseScriptNative = parseScriptNative
-module.exports.isComponentTagNative = isComponentTagNative
 module.exports.parseFullZenNative = parseFullZenNative
-module.exports.lowerFragmentsNative = lowerFragmentsNative
-module.exports.evaluateExpressionNative = evaluateExpressionNative
-module.exports.classifyExpressionNative = classifyExpressionNative
-module.exports.analyzeExpressions = analyzeExpressions
 module.exports.transformTemplateNative = transformTemplateNative
-module.exports.validateIr = validateIr
 module.exports.compileBridge = compileBridge

package/native/compiler-native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/compiler-native",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@zenithbuild/compiler",
-  "version": "1.3.2",
+  "version": "1.3.9",
   "description": "The Iron Heart: Native Compiler for the Zenith Framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
-    "./config": "./dist/core/config/index.js",
-    "./plugins": "./dist/core/plugins/index.js",
-    "./runtime": "./dist/runtime/index.js"
+    "./config": "./dist/core/config/loader.js",
+    "./plugins": "./dist/core/plugins/bridge.js",
+    "./registry": "./dist/core/plugins/registry.js",
+    "./runtime": "./dist/runtime/bundle-generator.js",
+    "./discovery": "./dist/discovery/componentDiscovery.js",
+    "./layouts": "./dist/discovery/layouts.js",
+    "./transform": "./dist/transform/layoutProcessor.js",
+    "./css": "./dist/css/index.js",
+    "./bundler": "./dist/bundler/index.js"
   },
   "files": [
     "dist",
@@ -21,7 +27,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc --skipLibCheck && cd native/compiler-native && bun run build",
+    "build": "tsc --skipLibCheck && cd native/compiler-native && bun run build && cp compiler-native.node compiler-native.darwin-arm64.node 2>/dev/null || true",
     "test": "bun test"
   },
   "dependencies": {
@@ -37,7 +43,11 @@
     "prompts": "^2.4.2",
     "glob": "^10.3.10"
   },
+  "peerDependencies": {
+    "@zenithbuild/runtime": "^0.1.0"
+  },
   "devDependencies": {
+    "@zenithbuild/runtime": "workspace:*",
     "@types/node": "^20.11.0",
     "@types/acorn": "^6.0.4",
     "@types/marked": "^6.0.0",