@zenithbuild/compiler 1.0.16 → 1.3.1

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

@@ -12,6 +12,7 @@ export interface RuntimeCode {
   stateInit: string
   bundle: string
   npmImports: Array<ScriptImport>
+  errors: Array<string>
 }
 export interface ScriptImport {
   source: string
@@ -26,8 +27,7 @@ export declare function resolveComponentsNative(irJson: string, componentsJson:
 export declare function discoverComponentsNative(baseDir: string): any
 export declare function extractStylesNative(source: string): Array<string>
 export declare function extractPageBindingsNative(script: string): Array<string>
-/** Discover layouts in a directory */
-export declare function discoverLayoutsNative(layoutsDir: string): any
+export declare function extractPagePropsNative(script: string): Array<string>
 export interface VirtualModule {
   id: string
   code: string
@@ -39,20 +39,59 @@ export interface BundlePlan {
   resolveRoots: Array<string>
   virtualModules: Array<VirtualModule>
 }
+/**
+ * Manifest export for the bundler's capability-based chunking.
+ * This is the Compiler → Bundler handshake contract.
+ */
+export interface ZenManifestExport {
+  /** Entry point path */
+  entry: string
+  /** Pre-rendered HTML template */
+  template: string
+  /** Whether this page uses reactive state */
+  usesState: boolean
+  /** Whether this page has event handlers */
+  hasEvents: boolean
+  /** Whether this page is fully static */
+  isStatic: boolean
+  /** CSS classes used by this page (for pruning) */
+  cssClasses: Array<string>
+  /** Required runtime capabilities (as strings for JS interop) */
+  requiredCapabilities: Array<string>
+  /** Compiled script content (author code) */
+  script: string
+  /** Compiled expressions */
+  expressions: string
+  /** Compiled styles */
+  styles: string
+  /** NPM imports */
+  npmImports: string
+}
 export interface FinalizedOutput {
   html: string
-  js: string
-  npmImports: string
-  styles: Array<string>
   hasErrors: boolean
   errors: Array<string>
-  bundlePlan?: BundlePlan
+  /** Manifest for bundler's capability-based chunking */
+  manifest?: ZenManifestExport
 }
 export declare function finalizeOutputNative(irJson: any, compiledJson: any): FinalizedOutput
-export declare function processLayoutNative(source: string, layoutJson: string, propsJson: string): string
 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"
+ *
+ * Combines: parse_template + parse_script → ZenIR → component resolution →
+ * transform → finalize → FinalizedOutput
+ */
+export interface ParseFullOptions {
+  mode?: string
+  useCache?: boolean
+  components?: any
+  layout?: any
+  props?: any
+}
+export declare function parseFullZenNative(source: string, filePath: string, optionsJson: string): any
 export interface ExpressionAnalysisResult {
   id: string
   classification: string

package/native/compiler-native/index.js

@@ -1,19 +1,334 @@
-const { join } = require('path');
-const { statSync } = require('fs');
-
-let nativeBinding;
-
-// Get the mtime of the .node file to bust bun's cache
-const nodePath = join(__dirname, 'compiler-native.node');
-const mtime = statSync(nodePath).mtimeMs;
-
-try {
-    // Clear require cache to force reload
-    delete require.cache[require.resolve('./compiler-native.node')];
-    nativeBinding = require('./compiler-native.node');
-} catch (e) {
-    console.error('[Zenith Native] Failed to load native binding:', e.message);
-    throw e;
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
 }
 
-module.exports = nativeBinding;
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'compiler-native.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.android-arm64.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'compiler-native.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'compiler-native.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'compiler-native.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'compiler-native.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'compiler-native.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./compiler-native.darwin-universal.node')
+      } else {
+        nativeBinding = require('@zenithbuild/compiler-native-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'compiler-native.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.darwin-x64.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'compiler-native.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'compiler-native.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./compiler-native.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@zenithbuild/compiler-native-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'compiler-native.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./compiler-native.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@zenithbuild/compiler-native-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'compiler-native.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./compiler-native.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@zenithbuild/compiler-native-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  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
+
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenithbuild/compiler",
-  "version": "1.0.16",
+  "version": "1.3.1",
   "description": "The Iron Heart: Native Compiler for the Zenith Framework",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -46,4 +46,4 @@
     "typescript": "^5.3.3",
     "bun-types": "latest"
   }
-}
+}

package/dist/build-analyzer.d.ts

@@ -1,44 +0,0 @@
-/**
- * Zenith Build Analyzer
- *
- * Analyzes .zen page source to determine build strategy:
- * - Static: Pure HTML+CSS, no JS needed
- * - Hydration: Has state/events/hooks, needs page-specific JS
- * - SSR: Uses useFetchServer, needs server rendering
- * - SPA: Uses ZenLink with passHref, needs client router
- */
-export interface PageAnalysis {
-    /** Page has state declarations that need hydration */
-    hasState: boolean;
-    /** Page has event handlers (onclick, etc.) */
-    hasEventHandlers: boolean;
-    /** Page uses lifecycle hooks (zenOnMount, zenOnUnmount) */
-    hasLifecycleHooks: boolean;
-    /** Page uses useFetchServer (requires SSR) */
-    usesServerFetch: boolean;
-    /** Page uses useFetchClient (client-side data) */
-    usesClientFetch: boolean;
-    /** Page uses ZenLink with passHref (SPA navigation) */
-    usesZenLink: boolean;
-    /** Page uses reactive expressions in templates */
-    hasReactiveExpressions: boolean;
-    /** Computed: page needs any JavaScript */
-    needsHydration: boolean;
-    /** Computed: page is purely static (no JS) */
-    isStatic: boolean;
-    /** Computed: page needs SSR */
-    needsSSR: boolean;
-}
-/**
- * Analyze a .zen page source to determine build requirements
- */
-export declare function analyzePageSource(source: string): PageAnalysis;
-/**
- * Get a human-readable summary of the page analysis
- */
-export declare function getAnalysisSummary(analysis: PageAnalysis): string;
-/**
- * Determine build output type for a page
- */
-export type BuildOutputType = 'static' | 'hydrated' | 'ssr';
-export declare function getBuildOutputType(analysis: PageAnalysis): BuildOutputType;

package/dist/build-analyzer.js

@@ -1,87 +0,0 @@
-/**
- * Zenith Build Analyzer
- *
- * Analyzes .zen page source to determine build strategy:
- * - Static: Pure HTML+CSS, no JS needed
- * - Hydration: Has state/events/hooks, needs page-specific JS
- * - SSR: Uses useFetchServer, needs server rendering
- * - SPA: Uses ZenLink with passHref, needs client router
- */
-/**
- * Analyze a .zen page source to determine build requirements
- */
-export function analyzePageSource(source) {
-    // Extract script content for analysis
-    const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
-    const scriptContent = scriptMatch?.[1] || '';
-    // Extract template content (everything outside script/style)
-    const templateContent = source
-        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
-    // Check for state declarations: "state varName = ..."
-    const hasState = /\bstate\s+\w+\s*=/.test(scriptContent);
-    // Check for event handlers in template
-    const hasEventHandlers = /\bon(click|change|input|submit|focus|blur|keydown|keyup|keypress|mousedown|mouseup|mouseover|mouseout|mouseenter|mouseleave)\s*=\s*["'{]/.test(templateContent);
-    // Check for lifecycle hooks
-    const hasLifecycleHooks = /\bzen(OnMount|OnUnmount)\s*\(/.test(scriptContent);
-    // Check for server fetch
-    const usesServerFetch = /\buseFetchServer\s*\(/.test(scriptContent);
-    // Check for client fetch
-    const usesClientFetch = /\buseFetchClient\s*\(/.test(scriptContent);
-    // Check for ZenLink with passHref
-    const usesZenLink = /<ZenLink[^>]*passHref[^>]*>/.test(templateContent);
-    // Check for reactive expressions in template: {expression}
-    // Must be actual expressions, not just static text
-    // Exclude attribute values like href="/path"
-    const hasReactiveExpressions = /{[^{}]+}/.test(templateContent);
-    // Compute derived properties
-    const needsHydration = hasState || hasEventHandlers || hasLifecycleHooks ||
-        usesClientFetch || hasReactiveExpressions;
-    const isStatic = !needsHydration && !usesServerFetch;
-    const needsSSR = usesServerFetch;
-    return {
-        hasState,
-        hasEventHandlers,
-        hasLifecycleHooks,
-        usesServerFetch,
-        usesClientFetch,
-        usesZenLink,
-        hasReactiveExpressions,
-        needsHydration,
-        isStatic,
-        needsSSR
-    };
-}
-/**
- * Get a human-readable summary of the page analysis
- */
-export function getAnalysisSummary(analysis) {
-    const flags = [];
-    if (analysis.isStatic) {
-        flags.push('STATIC (no JS)');
-    }
-    else {
-        if (analysis.hasState)
-            flags.push('state');
-        if (analysis.hasEventHandlers)
-            flags.push('events');
-        if (analysis.hasLifecycleHooks)
-            flags.push('lifecycle');
-        if (analysis.hasReactiveExpressions)
-            flags.push('reactive');
-        if (analysis.usesClientFetch)
-            flags.push('clientFetch');
-    }
-    if (analysis.needsSSR)
-        flags.push('SSR');
-    if (analysis.usesZenLink)
-        flags.push('SPA');
-    return flags.length > 0 ? flags.join(', ') : 'minimal';
-}
-export function getBuildOutputType(analysis) {
-    if (analysis.needsSSR)
-        return 'ssr';
-    if (analysis.needsHydration)
-        return 'hydrated';
-    return 'static';
-}

package/dist/bundler.d.ts

@@ -1,31 +0,0 @@
-/**
- * @zenithbuild/core - Page Script Bundler
- *
- * COMPILER-FIRST ARCHITECTURE
- * ═══════════════════════════════════════════════════════════════════════════════
- *
- * This bundler performs ZERO inference. It executes exactly what the compiler specifies.
- *
- * Rules:
- * - If a BundlePlan is provided, bundling MUST occur
- * - If bundling fails, throw a hard error (no fallback)
- * - The bundler never inspects source code for intent
- * - No temp files, no heuristics, no recovery
- *
- * Bundler failure = compiler bug.
- * ═══════════════════════════════════════════════════════════════════════════════
- */
-import type { BundlePlan } from './ir/types';
-/**
- * Execute a compiler-emitted BundlePlan
- *
- * This is a PURE PLAN EXECUTOR. It does not:
- * - Inspect source code for imports
- * - Decide whether bundling is needed
- * - Fall back on failure
- * - Use temp files
- *
- * @param plan - Compiler-emitted BundlePlan (must exist; caller must not call if no plan)
- * @throws Error if bundling fails (no fallback, no recovery)
- */
-export declare function bundlePageScript(plan: BundlePlan): Promise<string>;