@zenithbuild/cli 1.3.7 → 1.3.17

package/dist/zen-build.js

@@ -1532,7 +1532,7 @@ function showServerPanel(options) {
 `);
 }
 
-// ../zenith-bundler/src/bundle-generator.ts
+// ../zenith-bundler/dist/bundle-generator.js
 import { readFileSync, existsSync } from "fs";
 import path3 from "path";
 function generateBundleJS(pluginData) {
@@ -2338,7 +2338,7 @@ ${lifecycleJS ? `  // ============================================
 function transformExportsToGlobal(source) {
   return source.replace(/export\s+(const|function|class)\s+(\w+)/g, "var $2");
 }
-// ../zenith-bundler/src/build-analyzer.ts
+// ../zenith-bundler/dist/build-analyzer.js
 function analyzePageSource(source) {
   const scriptMatch = source.match(/<script[^>]*>([\s\S]*?)<\/script>/i);
   const scriptContent = scriptMatch?.[1] || "";
@@ -8978,7 +8978,7 @@ if (isMainThread) {
 }
 var BindingMagicString = import_binding6.BindingMagicString;
 
-// ../zenith-bundler/src/bundler.ts
+// ../zenith-bundler/dist/bundler.js
 async function bundlePageScript(plan) {
   const VIRTUAL_ENTRY = "\x00zenith:entry.tsx";
   const virtualModules = new Map;
@@ -9022,7 +9022,7 @@ async function bundlePageScript(plan) {
   }
   return output[0].code;
 }
-// ../zenith-bundler/src/css.ts
+// ../zenith-bundler/dist/css.js
 import { spawn, spawnSync } from "child_process";
 import path6 from "path";
 import fs2 from "fs";
@@ -9166,7 +9166,7 @@ function resolveGlobalsCss(projectRoot) {
     return globalPath;
   return null;
 }
-// ../zenith-bundler/src/runtime-generator.ts
+// ../zenith-bundler/dist/runtime-generator.js
 function generateRuntime(manifest, isDev = false) {
   const routes = JSON.stringify(manifest.routes);
   return {
@@ -9187,153 +9187,14 @@ if (window.zenith) {
 `
   };
 }
-// ../zenith-router/src/manifest.ts
-import fs3 from "fs";
-import path7 from "path";
-
-// ../zenith-router/index.js
-import { createRequire as createRequire2 } from "module";
-var require2 = createRequire2(import.meta.url);
-var native = require2("./zenith-router.node");
-var { generateRouteManifestNative, renderRouteNative, resolveRouteNative, generateRuntimeRouterNative, SegmentType, routerBridge } = native;
-
-// ../zenith-router/src/manifest.ts
-var SEGMENT_SCORES = {
-  [SegmentType.Static]: 10,
-  [SegmentType.Dynamic]: 5,
-  [SegmentType.CatchAll]: 1,
-  [SegmentType.OptionalCatchAll]: 0
-};
-function discoverPages(pagesDir) {
-  const pages = [];
-  function walk(dir) {
-    if (!fs3.existsSync(dir))
-      return;
-    const entries = fs3.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path7.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".zen")) {
-        pages.push(fullPath);
-      }
-    }
-  }
-  walk(pagesDir);
-  return pages;
-}
-function filePathToRoutePath(filePath, pagesDir) {
-  const relativePath = path7.relative(pagesDir, filePath);
-  const withoutExt = relativePath.replace(/\.zen$/, "");
-  const segmentsList = withoutExt.split(path7.sep);
-  const routeSegments = [];
-  for (const segment of segmentsList) {
-    if (segment === "index")
-      continue;
-    const optionalCatchAllMatch = segment.match(/^\[\[\.\.\.(\w+)\]\]$/);
-    if (optionalCatchAllMatch) {
-      routeSegments.push(`*${optionalCatchAllMatch[1]}?`);
-      continue;
-    }
-    const catchAllMatch = segment.match(/^\[\.\.\.(\w+)\]$/);
-    if (catchAllMatch) {
-      routeSegments.push(`*${catchAllMatch[1]}`);
-      continue;
-    }
-    const dynamicMatch = segment.match(/^\[(\w+)\]$/);
-    if (dynamicMatch) {
-      routeSegments.push(`:${dynamicMatch[1]}`);
-      continue;
-    }
-    routeSegments.push(segment);
-  }
-  const routePath = "/" + routeSegments.join("/");
-  return routePath === "/" ? "/" : routePath.replace(/\/$/, "");
-}
-function parseRouteSegments(routePath) {
-  if (routePath === "/")
-    return [];
-  const segmentsList = routePath.slice(1).split("/");
-  const parsed = [];
-  for (const segment of segmentsList) {
-    if (segment.startsWith("*") && segment.endsWith("?")) {
-      parsed.push({ segmentType: SegmentType.OptionalCatchAll, paramName: segment.slice(1, -1), raw: segment });
-      continue;
-    }
-    if (segment.startsWith("*")) {
-      parsed.push({ segmentType: SegmentType.CatchAll, paramName: segment.slice(1), raw: segment });
-      continue;
-    }
-    if (segment.startsWith(":")) {
-      parsed.push({ segmentType: SegmentType.Dynamic, paramName: segment.slice(1), raw: segment });
-      continue;
-    }
-    parsed.push({ segmentType: SegmentType.Static, raw: segment });
-  }
-  return parsed;
-}
-function calculateRouteScore(segments) {
-  if (segments.length === 0)
-    return 100;
-  let score = 0;
-  for (const segment of segments) {
-    score += SEGMENT_SCORES[segment.segmentType];
-  }
-  const staticCount = segments.filter((s2) => s2.segmentType === SegmentType.Static).length;
-  score += staticCount * 2;
-  return score;
-}
-function extractParamNames(segments) {
-  return segments.filter((s2) => s2.paramName !== undefined).map((s2) => s2.paramName);
-}
-function routePathToRegex(routePath) {
-  if (routePath === "/")
-    return /^\/$/;
-  const segmentsList = routePath.slice(1).split("/");
-  const regexParts = [];
-  for (let i2 = 0;i2 < segmentsList.length; i2++) {
-    const segment = segmentsList[i2];
-    if (!segment)
-      continue;
-    if (segment.startsWith("*") && segment.endsWith("?")) {
-      regexParts.push("(?:\\/(.*))?");
-      continue;
-    }
-    if (segment.startsWith("*")) {
-      regexParts.push("\\/(.+)");
-      continue;
-    }
-    if (segment.startsWith(":")) {
-      regexParts.push("\\/([^/]+)");
-      continue;
-    }
-    const escaped = segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    regexParts.push(`\\/${escaped}`);
-  }
-  return new RegExp(`^${regexParts.join("")}\\/?$`);
-}
-function generateRouteDefinition(filePath, pagesDir) {
-  const routePath = filePathToRoutePath(filePath, pagesDir);
-  const segments = parseRouteSegments(routePath);
-  const paramNames = extractParamNames(segments);
-  const score = calculateRouteScore(segments);
-  return {
-    path: routePath,
-    paramNames,
-    score,
-    filePath,
-    regex: routePathToRegex(routePath)
-  };
-}
-
 // ../zenith-compiler/dist/parseZenFile.js
 import { readFileSync as readFileSync2 } from "fs";
-var native2;
+var native;
 try {
-  native2 = require_compiler_native();
+  native = require_compiler_native();
 } catch (e3) {
   try {
-    native2 = require_compiler_native();
+    native = require_compiler_native();
   } catch {
     console.error(`
 \x1B[31m[Zenith Critical] Native bridge unavailable.\x1B[0m`);
@@ -9347,7 +9208,7 @@ function parseZenFile(filePath, sourceInput, options = {}) {
   const source = sourceInput ?? readFileSync2(filePath, "utf-8");
   const mode = options.mode ?? "full";
   const useCache = options.useCache ?? process.env.ZENITH_CACHE !== "0";
-  if (!native2.parseFullZenNative) {
+  if (!native.parseFullZenNative) {
     throw new Error("[Zenith Critical] Broken native bridge: parseFullZenNative symbol missing. Rebuild required.");
   }
   try {
@@ -9358,7 +9219,7 @@ function parseZenFile(filePath, sourceInput, options = {}) {
       layout: options.layout ?? null,
       props: options.props ?? null
     };
-    const result = native2.parseFullZenNative(source, filePath, JSON.stringify(nativeOptions));
+    const result = native.parseFullZenNative(source, filePath, JSON.stringify(nativeOptions));
     return result;
   } catch (error4) {
     throw new Error(`[Zenith Native Fatal] ${error4.message}
@@ -9408,122 +9269,18 @@ class InvariantError extends CompilerError {
   }
 }
 
-// ../zenith-compiler/dist/index.js
-async function compile(source, filePath, options) {
-  const opts = options || {};
-  const components = opts.components || new Map;
-  const finalized = parseZenFile(filePath, source, {
-    mode: "full",
-    components: components ? Object.fromEntries(components) : {},
-    layout: opts.layout,
-    props: opts.props,
-    useCache: true
-  });
-  if (finalized.code && (finalized.errorType || finalized.error_type)) {
-    throw new InvariantError(finalized.code, finalized.message, finalized.guarantee || "Zenith Invariant Violation", filePath, finalized.line || 1, finalized.column || 1, finalized.context, finalized.hints);
-  }
-  return {
-    ir: finalized.ir,
-    compiled: {
-      html: finalized.html,
-      bindings: finalized.bindings || [],
-      scripts: finalized.js || null,
-      styles: finalized.styles || []
-    },
-    finalized: {
-      ...finalized,
-      js: finalized.js,
-      npmImports: finalized.npmImports,
-      bundlePlan: finalized.bundlePlan
-    }
-  };
-}
-
-// src/discovery/layouts.ts
-import * as fs4 from "fs";
-import * as path8 from "path";
-function discoverLayouts(layoutsDir) {
-  const layouts = new Map;
-  if (!fs4.existsSync(layoutsDir))
-    return layouts;
-  const files = fs4.readdirSync(layoutsDir);
-  for (const file of files) {
-    if (file.endsWith(".zen")) {
-      const fullPath = path8.join(layoutsDir, file);
-      const name = path8.basename(file, ".zen");
-      try {
-        const ir = parseZenFile(fullPath, undefined, { mode: "metadata" });
-        layouts.set(name, {
-          name,
-          filePath: fullPath,
-          props: ir.props || [],
-          states: new Map,
-          html: ir.template.raw,
-          scripts: ir.script ? [ir.script.content] : [],
-          styles: ir.styles?.map((s2) => s2.raw) || []
-        });
-      } catch (e3) {
-        console.error(`[Zenith Layout Discovery] Failed to parse layout ${file}:`, e3);
-      }
-    }
-  }
-  return layouts;
-}
-
-// src/discovery/componentDiscovery.ts
-import * as fs5 from "fs";
-import * as path9 from "path";
-function discoverComponents(baseDir) {
-  const components = new Map;
-  if (!fs5.existsSync(baseDir))
-    return components;
-  const walk = (dir) => {
-    const files = fs5.readdirSync(dir);
-    for (const file of files) {
-      const fullPath = path9.join(dir, file);
-      if (fs5.statSync(fullPath).isDirectory()) {
-        walk(fullPath);
-      } else if (file.endsWith(".zen")) {
-        const name = path9.basename(file, ".zen");
-        try {
-          const ir = parseZenFile(fullPath, undefined, { mode: "metadata" });
-          components.set(name, {
-            name,
-            path: fullPath,
-            template: ir.template.raw,
-            nodes: ir.template.nodes,
-            expressions: ir.template.expressions,
-            slots: [],
-            props: ir.props || [],
-            states: ir.script?.states || {},
-            styles: ir.styles?.map((s2) => s2.raw) || [],
-            script: ir.script?.raw || null,
-            scriptAttributes: ir.script?.attributes || null,
-            hasScript: !!ir.script,
-            hasStyles: ir.styles?.length > 0
-          });
-        } catch (e3) {
-          console.error(`[Zenith Discovery] Failed to parse component ${file}:`, e3);
-        }
-      }
-    }
-  };
-  walk(baseDir);
-  return components;
-}
-
 // ../zenith-compiler/dist/core/config/loader.js
-import fs6 from "fs";
-import path10 from "path";
+import fs3 from "fs";
+import path7 from "path";
 async function loadZenithConfig(projectRoot) {
   const configPaths = [
-    path10.join(projectRoot, "zenith.config.ts"),
-    path10.join(projectRoot, "zenith.config.js"),
-    path10.join(projectRoot, "zenith.config.mjs")
+    path7.join(projectRoot, "zenith.config.ts"),
+    path7.join(projectRoot, "zenith.config.js"),
+    path7.join(projectRoot, "zenith.config.mjs")
   ];
   let configPath = null;
   for (const p of configPaths) {
-    if (fs6.existsSync(p)) {
+    if (fs3.existsSync(p)) {
       configPath = p;
       break;
     }
@@ -9545,7 +9302,6 @@ async function loadZenithConfig(projectRoot) {
     return { plugins: [] };
   }
 }
-
 // ../zenith-compiler/dist/core/plugins/registry.js
 var pluginDataStore = {};
 function getPluginDataByNamespace(namespace) {
@@ -9595,7 +9351,6 @@ function createPluginContext(projectRoot) {
     options: {}
   };
 }
-
 // ../zenith-compiler/dist/core/plugins/bridge.js
 var hookRegistry = new Map;
 function registerHook(hook, handler) {
@@ -9644,6 +9399,246 @@ function createBridgeAPI() {
     on: registerHook
   };
 }
+// ../zenith-compiler/dist/index.js
+async function compile(source, filePath, options) {
+  const opts = options || {};
+  const components = opts.components || new Map;
+  const finalized = parseZenFile(filePath, source, {
+    mode: "full",
+    components: components ? Object.fromEntries(components) : {},
+    layout: opts.layout,
+    props: opts.props,
+    useCache: true
+  });
+  if (finalized.code && (finalized.errorType || finalized.error_type)) {
+    throw new InvariantError(finalized.code, finalized.message, finalized.guarantee || "Zenith Invariant Violation", filePath, finalized.line || 1, finalized.column || 1, finalized.context, finalized.hints);
+  }
+  return {
+    ir: finalized.ir,
+    compiled: {
+      html: finalized.html,
+      bindings: finalized.bindings || [],
+      scripts: finalized.js || null,
+      styles: finalized.styles || []
+    },
+    finalized: {
+      ...finalized,
+      js: finalized.js,
+      npmImports: finalized.npmImports,
+      bundlePlan: finalized.bundlePlan
+    }
+  };
+}
+
+// ../zenith-router/dist/manifest.js
+import fs4 from "fs";
+import path8 from "path";
+
+// ../zenith-router/index.js
+import { createRequire as createRequire2 } from "module";
+var require2 = createRequire2(import.meta.url);
+var native2 = require2("./zenith-router.node");
+
+// ../zenith-router/dist/manifest.js
+var SEGMENT_SCORES = {
+  [0]: 10,
+  [1]: 5,
+  [2]: 1,
+  [3]: 0
+};
+function discoverPages(pagesDir) {
+  const pages = [];
+  function walk(dir) {
+    if (!fs4.existsSync(dir))
+      return;
+    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".zen")) {
+        pages.push(fullPath);
+      }
+    }
+  }
+  walk(pagesDir);
+  return pages;
+}
+function filePathToRoutePath(filePath, pagesDir) {
+  const relativePath = path8.relative(pagesDir, filePath);
+  const withoutExt = relativePath.replace(/\.zen$/, "");
+  const segmentsList = withoutExt.split(path8.sep);
+  const routeSegments = [];
+  for (const segment of segmentsList) {
+    if (segment === "index")
+      continue;
+    const optionalCatchAllMatch = segment.match(/^\[\[\.\.\.(\w+)\]\]$/);
+    if (optionalCatchAllMatch) {
+      routeSegments.push(`*${optionalCatchAllMatch[1]}?`);
+      continue;
+    }
+    const catchAllMatch = segment.match(/^\[\.\.\.(\w+)\]$/);
+    if (catchAllMatch) {
+      routeSegments.push(`*${catchAllMatch[1]}`);
+      continue;
+    }
+    const dynamicMatch = segment.match(/^\[(\w+)\]$/);
+    if (dynamicMatch) {
+      routeSegments.push(`:${dynamicMatch[1]}`);
+      continue;
+    }
+    routeSegments.push(segment);
+  }
+  const routePath = "/" + routeSegments.join("/");
+  return routePath === "/" ? "/" : routePath.replace(/\/$/, "");
+}
+function parseRouteSegments(routePath) {
+  if (routePath === "/")
+    return [];
+  const segmentsList = routePath.slice(1).split("/");
+  const parsed = [];
+  for (const segment of segmentsList) {
+    if (segment.startsWith("*") && segment.endsWith("?")) {
+      parsed.push({ segmentType: 3, paramName: segment.slice(1, -1), raw: segment });
+      continue;
+    }
+    if (segment.startsWith("*")) {
+      parsed.push({ segmentType: 2, paramName: segment.slice(1), raw: segment });
+      continue;
+    }
+    if (segment.startsWith(":")) {
+      parsed.push({ segmentType: 1, paramName: segment.slice(1), raw: segment });
+      continue;
+    }
+    parsed.push({ segmentType: 0, raw: segment });
+  }
+  return parsed;
+}
+function calculateRouteScore(segments) {
+  if (segments.length === 0)
+    return 100;
+  let score = 0;
+  for (const segment of segments) {
+    score += SEGMENT_SCORES[segment.segmentType];
+  }
+  const staticCount = segments.filter((s2) => s2.segmentType === 0).length;
+  score += staticCount * 2;
+  return score;
+}
+function extractParamNames(segments) {
+  return segments.filter((s2) => s2.paramName !== undefined).map((s2) => s2.paramName);
+}
+function routePathToRegex(routePath) {
+  if (routePath === "/")
+    return /^\/$/;
+  const segmentsList = routePath.slice(1).split("/");
+  const regexParts = [];
+  for (let i2 = 0;i2 < segmentsList.length; i2++) {
+    const segment = segmentsList[i2];
+    if (!segment)
+      continue;
+    if (segment.startsWith("*") && segment.endsWith("?")) {
+      regexParts.push("(?:\\/(.*))?");
+      continue;
+    }
+    if (segment.startsWith("*")) {
+      regexParts.push("\\/(.+)");
+      continue;
+    }
+    if (segment.startsWith(":")) {
+      regexParts.push("\\/([^/]+)");
+      continue;
+    }
+    const escaped = segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    regexParts.push(`\\/${escaped}`);
+  }
+  return new RegExp(`^${regexParts.join("")}\\/?$`);
+}
+function generateRouteDefinition(filePath, pagesDir) {
+  const routePath = filePathToRoutePath(filePath, pagesDir);
+  const segments = parseRouteSegments(routePath);
+  const paramNames = extractParamNames(segments);
+  const score = calculateRouteScore(segments);
+  return {
+    path: routePath,
+    paramNames,
+    score,
+    filePath,
+    regex: routePathToRegex(routePath)
+  };
+}
+// src/discovery/layouts.ts
+import * as fs5 from "fs";
+import * as path9 from "path";
+function discoverLayouts2(layoutsDir) {
+  const layouts2 = new Map;
+  if (!fs5.existsSync(layoutsDir))
+    return layouts2;
+  const files = fs5.readdirSync(layoutsDir);
+  for (const file of files) {
+    if (file.endsWith(".zen")) {
+      const fullPath = path9.join(layoutsDir, file);
+      const name = path9.basename(file, ".zen");
+      try {
+        const ir = parseZenFile(fullPath, undefined, { mode: "metadata" });
+        layouts2.set(name, {
+          name,
+          filePath: fullPath,
+          props: ir.props || [],
+          states: new Map,
+          html: ir.template.raw,
+          scripts: ir.script ? [ir.script.content] : [],
+          styles: ir.styles?.map((s2) => s2.raw) || []
+        });
+      } catch (e3) {
+        console.error(`[Zenith Layout Discovery] Failed to parse layout ${file}:`, e3);
+      }
+    }
+  }
+  return layouts2;
+}
+
+// src/discovery/componentDiscovery.ts
+import * as fs6 from "fs";
+import * as path10 from "path";
+function discoverComponents2(baseDir) {
+  const components = new Map;
+  if (!fs6.existsSync(baseDir))
+    return components;
+  const walk = (dir) => {
+    const files = fs6.readdirSync(dir);
+    for (const file of files) {
+      const fullPath = path10.join(dir, file);
+      if (fs6.statSync(fullPath).isDirectory()) {
+        walk(fullPath);
+      } else if (file.endsWith(".zen")) {
+        const name = path10.basename(file, ".zen");
+        try {
+          const ir = parseZenFile(fullPath, undefined, { mode: "metadata" });
+          components.set(name, {
+            name,
+            path: fullPath,
+            template: ir.template.raw,
+            nodes: ir.template.nodes,
+            expressions: ir.template.expressions,
+            slots: [],
+            props: ir.props || [],
+            states: ir.script?.states || {},
+            styles: ir.styles?.map((s2) => s2.raw) || [],
+            script: ir.script?.raw || null,
+            scriptAttributes: ir.script?.attributes || null,
+            hasScript: !!ir.script,
+            hasStyles: ir.styles?.length > 0
+          });
+        } catch (e3) {
+          console.error(`[Zenith Discovery] Failed to parse component ${file}:`, e3);
+        }
+      }
+    }
+  };
+  walk(baseDir);
+  return components;
+}
 
 // src/commands/dev.ts
 var pageCache = new Map;
@@ -9709,10 +9704,10 @@ async function dev(options = {}) {
     try {
       const layoutsDir = path11.join(pagesDir, "../layouts");
       const componentsDir = path11.join(pagesDir, "../components");
-      const layouts = discoverLayouts(layoutsDir);
-      const components = new Map([...layouts]);
+      const layouts2 = discoverLayouts2(layoutsDir);
+      const components = new Map([...layouts2]);
       if (fs7.existsSync(componentsDir)) {
-        const discovered = discoverComponents(componentsDir);
+        const discovered = discoverComponents2(componentsDir);
         for (const [k2, v2] of discovered) {
           components.set(k2, v2);
         }
@@ -9968,12 +9963,12 @@ async function compilePage(pagePath, pagesDir, baseDir = process.cwd()) {
   const layoutsDir = path.join(srcDir, "layouts");
   const components = new Map;
   if (fs8.existsSync(componentsDir)) {
-    const comps = discoverComponents(componentsDir);
+    const comps = discoverComponents2(componentsDir);
     for (const [k2, v2] of comps)
       components.set(k2, v2);
   }
   if (fs8.existsSync(layoutsDir)) {
-    const layoutComps = discoverComponents(layoutsDir);
+    const layoutComps = discoverComponents2(layoutsDir);
     for (const [k2, v2] of layoutComps) {
       if (k2[0] === k2[0]?.toUpperCase()) {
         components.set(k2, v2);