@zenithbuild/cli 1.3.7 → 1.3.18

package/dist/zen-build.js

@@ -1320,17 +1320,17 @@ var require_compiler_native = __commonJS((exports, module) => {
 import process2 from "process";
 
 // src/commands/dev.ts
-import path11 from "path";
+import path10 from "path";
 import fs7 from "fs";
 var {serve } = globalThis.Bun;
 
 // src/utils/project.ts
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 function findProjectRoot(startDir = process.cwd()) {
   let current = startDir;
-  while (current !== path2.dirname(current)) {
-    const pkgPath = path2.join(current, "package.json");
+  while (current !== path.dirname(current)) {
+    const pkgPath = path.join(current, "package.json");
     if (fs.existsSync(pkgPath)) {
       try {
         const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
@@ -1341,7 +1341,7 @@ function findProjectRoot(startDir = process.cwd()) {
         }
       } catch {}
     }
-    current = path2.dirname(current);
+    current = path.dirname(current);
   }
   return null;
 }
@@ -1349,14 +1349,14 @@ function getProject(cwd = process.cwd()) {
   const root = findProjectRoot(cwd);
   if (!root)
     return null;
-  let appDir = path2.join(root, "app");
+  let appDir = path.join(root, "app");
   if (!fs.existsSync(appDir)) {
-    appDir = path2.join(root, "src");
+    appDir = path.join(root, "src");
   }
   return {
     root,
-    pagesDir: path2.join(appDir, "pages"),
-    distDir: path2.join(appDir, "dist"),
+    pagesDir: path.join(appDir, "pages"),
+    distDir: path.join(appDir, "dist"),
     hasZenithDeps: true
   };
 }
@@ -1390,13 +1390,13 @@ function header(title) {
 ${import_picocolors.default.bold(import_picocolors.default.cyan(title))}
 `);
 }
-function hmr(type, path3) {
-  console.log(`${import_picocolors.default.magenta("[HMR]")} ${import_picocolors.default.bold(type)} updated: ${import_picocolors.default.dim(path3)}`);
+function hmr(type, path2) {
+  console.log(`${import_picocolors.default.magenta("[HMR]")} ${import_picocolors.default.bold(type)} updated: ${import_picocolors.default.dim(path2)}`);
 }
-function route(method, path3, status, totalMs, compileMs, renderMs) {
+function route(method, path2, status, totalMs, compileMs, renderMs) {
   const statusColor = status < 400 ? import_picocolors.default.green : import_picocolors.default.red;
   const timeColor = totalMs > 1000 ? import_picocolors.default.yellow : import_picocolors.default.gray;
-  console.log(`${import_picocolors.default.bold(method)} ${import_picocolors.default.cyan(path3.padEnd(15))} ` + `${statusColor(status)} ${import_picocolors.default.dim("in")} ${timeColor(`${totalMs}ms`)} ` + `${import_picocolors.default.dim(`(compile: ${compileMs}ms, render: ${renderMs}ms)`)}`);
+  console.log(`${import_picocolors.default.bold(method)} ${import_picocolors.default.cyan(path2.padEnd(15))} ` + `${statusColor(status)} ${import_picocolors.default.dim("in")} ${timeColor(`${totalMs}ms`)} ` + `${import_picocolors.default.dim(`(compile: ${compileMs}ms, render: ${renderMs}ms)`)}`);
 }
 function debug(message) {
   if (process.env.ZENITH_DEBUG === "true") {
@@ -1532,25 +1532,25 @@ function showServerPanel(options) {
 `);
 }
 
-// ../zenith-bundler/src/bundle-generator.ts
+// ../zenith-bundler/dist/bundle-generator.js
 import { readFileSync, existsSync } from "fs";
-import path3 from "path";
+import path2 from "path";
 function generateBundleJS(pluginData) {
   const serializedData = pluginData ? JSON.stringify(pluginData).replace(/<\/script/g, "<\\/script") : "{}";
   const rootDir = process.cwd();
-  let coreRuntimePath = path3.join(rootDir, "../zenith-core/dist/runtime");
+  let coreRuntimePath = path2.join(rootDir, "../zenith-core/dist/runtime");
   if (!existsSync(coreRuntimePath)) {
-    coreRuntimePath = path3.join(rootDir, "../zenith-core/core");
+    coreRuntimePath = path2.join(rootDir, "../zenith-core/core");
   }
   let reactivityJS = "";
   let lifecycleJS = "";
   try {
-    let reactivityFile = path3.join(coreRuntimePath, "reactivity/index.js");
+    let reactivityFile = path2.join(coreRuntimePath, "reactivity/index.js");
     if (!existsSync(reactivityFile))
-      reactivityFile = path3.join(coreRuntimePath, "reactivity/index.ts");
-    let lifecycleFile = path3.join(coreRuntimePath, "lifecycle/index.js");
+      reactivityFile = path2.join(coreRuntimePath, "reactivity/index.ts");
+    let lifecycleFile = path2.join(coreRuntimePath, "lifecycle/index.js");
     if (!existsSync(lifecycleFile))
-      lifecycleFile = path3.join(coreRuntimePath, "lifecycle/index.ts");
+      lifecycleFile = path2.join(coreRuntimePath, "lifecycle/index.ts");
     if (existsSync(reactivityFile) && reactivityFile.endsWith(".js")) {
       reactivityJS = transformExportsToGlobal(readFileSync(reactivityFile, "utf-8"));
     }
@@ -1563,8 +1563,8 @@ function generateBundleJS(pluginData) {
     }
   }
   if (!reactivityJS || !lifecycleJS) {
-    const compilerRoot = path3.resolve(path3.dirname(import.meta.url.replace("file://", "")), "../../zenith-compiler");
-    const nativeRuntimePath = path3.join(compilerRoot, "native/compiler-native/src/hydration_runtime.js");
+    const compilerRoot = path2.resolve(path2.dirname(import.meta.url.replace("file://", "")), "../../zenith-compiler");
+    const nativeRuntimePath = path2.join(compilerRoot, "native/compiler-native/src/hydration_runtime.js");
     if (existsSync(nativeRuntimePath)) {
       const nativeJS = readFileSync(nativeRuntimePath, "utf-8");
       reactivityJS = nativeJS;
@@ -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] || "";
@@ -3344,7 +3344,7 @@ function parseAst(sourceText, options, filename) {
 }
 
 // ../node_modules/.bun/rolldown@1.0.0-rc.3/node_modules/rolldown/dist/shared/bindingify-input-options-CorDub0q.mjs
-import path4 from "path";
+import path3 from "path";
 
 // ../node_modules/.bun/@rolldown+pluginutils@1.0.0-rc.3/node_modules/@rolldown/pluginutils/dist/filter/composable-filters.js
 class And {
@@ -4629,9 +4629,9 @@ function preProcessSourceMap(ret, id2) {
     return;
   let map = typeof ret.map === "object" ? ret.map : JSON.parse(ret.map);
   if (!isEmptySourcemapFiled(map.sources)) {
-    const directory = path4.dirname(id2) || ".";
+    const directory = path3.dirname(id2) || ".";
     const sourceRoot = map.sourceRoot || ".";
-    map.sources = map.sources.map((source) => path4.resolve(directory, sourceRoot, source));
+    map.sources = map.sources.map((source) => path3.resolve(directory, sourceRoot, source));
   }
   return map;
 }
@@ -5675,7 +5675,7 @@ function bindingifyPreserveEntrySignatures(preserveEntrySignatures) {
 
 // ../node_modules/.bun/rolldown@1.0.0-rc.3/node_modules/rolldown/dist/shared/rolldown-build-CGNuOAoF.mjs
 import { Worker } from "worker_threads";
-import path5, { sep } from "path";
+import path4, { sep } from "path";
 import { formatWithOptions, styleText } from "util";
 import process$12 from "process";
 import * as tty from "tty";
@@ -5761,9 +5761,9 @@ var getExtendedLogMessage = (log2) => {
   return prefix + log2.message;
 };
 function relativeId(id2) {
-  if (!path5.isAbsolute(id2))
+  if (!path4.isAbsolute(id2))
     return id2;
-  return path5.relative(path5.resolve(), id2);
+  return path4.relative(path4.resolve(), id2);
 }
 var ENUMERATED_INPUT_PLUGIN_HOOK_NAMES = [
   "options",
@@ -7421,12 +7421,12 @@ function validateOption(key, options) {
   if (!parsed.success) {
     const errors = parsed.issues.map((issue) => {
       let issueMsg = issue.message;
-      const issuePaths = issue.path.map((path6) => path6.key);
+      const issuePaths = issue.path.map((path5) => path5.key);
       if (issue.type === "union") {
         const subIssue = issue.issues?.find((i) => !(i.type !== issue.received && i.input === issue.input));
         if (subIssue) {
           if (subIssue.path)
-            issuePaths.push(subIssue.path.map((path6) => path6.key));
+            issuePaths.push(subIssue.path.map((path5) => path5.key));
           issueMsg = subIssue.message;
         }
       }
@@ -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,9 +9022,9 @@ 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 path5 from "path";
 import fs2 from "fs";
 function compileCss(options) {
   const startTime = performance.now();
@@ -9051,7 +9051,7 @@ function compileCss(options) {
       args2.push("--minify");
     }
     const result = spawnSync("bunx", args2, {
-      cwd: path6.dirname(input),
+      cwd: path5.dirname(input),
       encoding: "utf-8",
       stdio: useStdout ? ["pipe", "pipe", "pipe"] : ["pipe", "inherit", "pipe"],
       env: { ...process.env }
@@ -9108,7 +9108,7 @@ async function compileCssAsync(options) {
       args2.push("--minify");
     }
     const child = spawn("bunx", args2, {
-      cwd: path6.dirname(input),
+      cwd: path5.dirname(input),
       stdio: useStdout ? ["pipe", "pipe", "pipe"] : ["pipe", "inherit", "pipe"],
       env: { ...process.env }
     });
@@ -9158,15 +9158,15 @@ async function compileCssAsync(options) {
   });
 }
 function resolveGlobalsCss(projectRoot) {
-  const globalsPath = path6.join(projectRoot, "src", "styles", "globals.css");
+  const globalsPath = path5.join(projectRoot, "src", "styles", "globals.css");
   if (fs2.existsSync(globalsPath))
     return globalsPath;
-  const globalPath = path6.join(projectRoot, "src", "styles", "global.css");
+  const globalPath = path5.join(projectRoot, "src", "styles", "global.css");
   if (fs2.existsSync(globalPath))
     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 path6 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")
+    path6.join(projectRoot, "zenith.config.ts"),
+    path6.join(projectRoot, "zenith.config.js"),
+    path6.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 path7 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 = 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: 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 path8 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 = path8.join(layoutsDir, file);
+      const name = path8.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 path9 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 = path9.join(dir, file);
+      if (fs6.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;
+}
 
 // src/commands/dev.ts
 var pageCache = new Map;
@@ -9671,7 +9666,7 @@ async function dev(options = {}) {
   const globalsCssPath = resolveGlobalsCss(rootDir);
   let compiledCss = "";
   if (globalsCssPath) {
-    debug(`Compiling CSS: ${path11.relative(rootDir, globalsCssPath)}`);
+    debug(`Compiling CSS: ${path10.relative(rootDir, globalsCssPath)}`);
     const cssResult = await compileCssAsync({ input: globalsCssPath, output: ":memory:" });
     if (cssResult.success) {
       compiledCss = cssResult.css;
@@ -9707,12 +9702,12 @@ async function dev(options = {}) {
   ]);
   async function compilePageInMemory(pagePath) {
     try {
-      const layoutsDir = path11.join(pagesDir, "../layouts");
-      const componentsDir = path11.join(pagesDir, "../components");
-      const layouts = discoverLayouts(layoutsDir);
-      const components = new Map([...layouts]);
+      const layoutsDir = path10.join(pagesDir, "../layouts");
+      const componentsDir = path10.join(pagesDir, "../components");
+      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);
         }
@@ -9743,19 +9738,36 @@ async function dev(options = {}) {
     }
   }
   async function generateDevHTML(page) {
-    const scriptTag = `<script type="module">
+    const injection = `
+    <!-- Zenith Dev Injection -->
+    <link rel="stylesheet" href="/assets/styles.css">
+    <script>window.zenith = window.zenith || {};</script>
+    <script src="/runtime.js"></script>
+    <script type="importmap">
+    {
+      "imports": {
+        "zenith:core": "/zenith-core.js",
+        "@zenithbuild/core": "/zenith-core.js",
+        "@zenithbuild/runtime": "/zenith-core.js",
+        "@zenithbuild/router": "/zenith-router.js",
+        "gsap": "https://esm.sh/gsap"
+      }
+    }
+    </script>
+    <script type="module">
 ${page.script}
-</script>`;
-    let html = page.html.includes("</body>") ? page.html.replace("</body>", `${scriptTag}
+    </script>
+        `;
+    let html = page.html.includes("</body>") ? page.html.replace("</body>", `${injection}
 </body>`) : `${page.html}
-${scriptTag}`;
+${injection}`;
     if (!html.trimStart().toLowerCase().startsWith("<!doctype")) {
       html = `<!DOCTYPE html>
 ${html}`;
     }
     return html;
   }
-  const watcher = fs7.watch(path11.join(pagesDir, ".."), { recursive: true }, async (event, filename) => {
+  const watcher = fs7.watch(path10.join(pagesDir, ".."), { recursive: true }, async (event, filename) => {
     if (!filename)
       return;
     await runPluginHooks("cli:dev:file-change", {
@@ -9799,12 +9811,25 @@ ${html}`;
       const startTime = performance.now();
       const url = new URL(req.url);
       const pathname = url.pathname;
-      const ext = path11.extname(pathname).toLowerCase();
+      const ext = path10.extname(pathname).toLowerCase();
       if (pathname === "/hmr") {
         const upgraded = server2.upgrade(req, { data: { timestamp: Date.now() } });
         if (upgraded)
           return;
       }
+      if (pathname.startsWith("/assets/")) {
+        let assetPath = path10.join(rootDir, "dist", pathname);
+        if (!fs7.existsSync(assetPath)) {
+          assetPath = path10.join(rootDir, "src", "dist", pathname);
+        }
+        if (fs7.existsSync(assetPath)) {
+          const content = fs7.readFileSync(assetPath);
+          const contentType = ext === ".css" ? "text/css" : ext === ".js" ? "application/javascript" : "application/octet-stream";
+          return new Response(content, {
+            headers: { "Content-Type": contentType }
+          });
+        }
+      }
       if (pathname === "/runtime.js") {
         const payloads = await collectHookReturns("cli:runtime:collect", hookCtx);
         const envelope = buildRuntimeEnvelope(payloads);
@@ -9814,7 +9839,38 @@ ${html}`;
         route("GET", pathname, 200, Math.round(performance.now() - startTime), 0, Math.round(performance.now() - startTime));
         return response;
       }
-      if (pathname === "/assets/styles.css") {
+      if (pathname === "/zenith-core.js") {
+        try {
+          const entry = __require.resolve("@zenithbuild/core");
+          const build = await Bun.build({
+            entrypoints: [entry],
+            external: ["@zenithbuild/router"],
+            target: "browser",
+            format: "esm"
+          });
+          if (build.success) {
+            return new Response(build.outputs[0]);
+          }
+        } catch (e3) {
+          error("Failed to bundle zenith-core: " + e3);
+        }
+      }
+      if (pathname === "/zenith-router.js") {
+        try {
+          const entry = __require.resolve("/Users/judahsullivan/Personal/zenith/zenith-router/dist/index.js");
+          const build = await Bun.build({
+            entrypoints: [entry],
+            target: "browser",
+            format: "esm"
+          });
+          if (build.success) {
+            return new Response(build.outputs[0]);
+          }
+        } catch (e3) {
+          error("Failed to bundle zenith-router: " + e3);
+        }
+      }
+      if (pathname === "/assets/styles.css" && compiledCss) {
         const response = new Response(compiledCss, {
           headers: { "Content-Type": "text/css; charset=utf-8" }
         });
@@ -9829,7 +9885,7 @@ ${html}`;
         return response;
       }
       if (STATIC_EXTENSIONS.has(ext)) {
-        const publicPath = path11.join(pagesDir, "../public", pathname);
+        const publicPath = path10.join(pagesDir, "../public", pathname);
         if (fs7.existsSync(publicPath)) {
           const response = new Response(Bun.file(publicPath));
           route("GET", pathname, 200, Math.round(performance.now() - startTime), 0, Math.round(performance.now() - startTime));
@@ -9879,32 +9935,32 @@ ${html}`;
   await new Promise(() => {});
 }
 function findPageForRoute(route2, pagesDir) {
-  const exactPath = path11.join(pagesDir, route2 === "/" ? "index.zen" : `${route2.slice(1)}.zen`);
+  const exactPath = path10.join(pagesDir, route2 === "/" ? "index.zen" : `${route2.slice(1)}.zen`);
   if (fs7.existsSync(exactPath))
     return exactPath;
-  const indexPath = path11.join(pagesDir, route2 === "/" ? "index.zen" : `${route2.slice(1)}/index.zen`);
+  const indexPath = path10.join(pagesDir, route2 === "/" ? "index.zen" : `${route2.slice(1)}/index.zen`);
   if (fs7.existsSync(indexPath))
     return indexPath;
   const segments = route2 === "/" ? [] : route2.slice(1).split("/").filter(Boolean);
   for (let i2 = segments.length - 1;i2 >= 0; i2--) {
     const staticPart = segments.slice(0, i2).join("/");
-    const baseDir = staticPart ? path11.join(pagesDir, staticPart) : pagesDir;
-    const singleDynamicPath = path11.join(baseDir, "[slug].zen");
+    const baseDir = staticPart ? path10.join(pagesDir, staticPart) : pagesDir;
+    const singleDynamicPath = path10.join(baseDir, "[slug].zen");
     if (fs7.existsSync(singleDynamicPath))
       return singleDynamicPath;
-    const catchAllPath = path11.join(baseDir, "[...slug].zen");
+    const catchAllPath = path10.join(baseDir, "[...slug].zen");
     if (fs7.existsSync(catchAllPath)) {
       return catchAllPath;
     }
   }
-  const rootCatchAll = path11.join(pagesDir, "[...slug].zen");
+  const rootCatchAll = path10.join(pagesDir, "[...slug].zen");
   if (fs7.existsSync(rootCatchAll))
     return rootCatchAll;
   return null;
 }
 
 // src/commands/preview.ts
-import path12 from "path";
+import path11 from "path";
 var {serve: serve2 } = globalThis.Bun;
 async function preview(options = {}) {
   const project = requireProject();
@@ -9934,16 +9990,16 @@ async function preview(options = {}) {
     async fetch(req) {
       const url = new URL(req.url);
       const pathname = url.pathname;
-      const ext = path12.extname(pathname).toLowerCase();
+      const ext = path11.extname(pathname).toLowerCase();
       if (STATIC_EXTENSIONS.has(ext)) {
-        const filePath = path12.join(distDir, pathname);
+        const filePath = path11.join(distDir, pathname);
         const file = Bun.file(filePath);
         if (await file.exists()) {
           return new Response(file);
         }
         return new Response("Not found", { status: 404 });
       }
-      const indexPath = path12.join(distDir, "index.html");
+      const indexPath = path11.join(distDir, "index.html");
       const indexFile = Bun.file(indexPath);
       if (await indexFile.exists()) {
         return new Response(indexFile, {
@@ -9960,20 +10016,21 @@ async function preview(options = {}) {
 
 // src/ssg-build.ts
 import fs8 from "fs";
+import path12 from "path";
 async function compilePage(pagePath, pagesDir, baseDir = process.cwd()) {
   const source = fs8.readFileSync(pagePath, "utf-8");
   const analysis = analyzePageSource(source);
-  const srcDir = path.dirname(pagesDir);
-  const componentsDir = path.join(srcDir, "components");
-  const layoutsDir = path.join(srcDir, "layouts");
+  const srcDir = path12.dirname(pagesDir);
+  const componentsDir = path12.join(srcDir, "components");
+  const layoutsDir = path12.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);
@@ -10082,7 +10139,7 @@ ${page.pageScript}
 `;
 }
 async function buildSSG(options) {
-  const { pagesDir, outDir, baseDir = path.dirname(pagesDir) } = options;
+  const { pagesDir, outDir, baseDir = path12.dirname(pagesDir) } = options;
   console.log("\uD83D\uDD28 Zenith SSG Build");
   console.log(`   Pages: ${pagesDir}`);
   console.log(`   Output: ${outDir}`);
@@ -10110,7 +10167,7 @@ async function buildSSG(options) {
     fs8.rmSync(outDir, { recursive: true, force: true });
   }
   fs8.mkdirSync(outDir, { recursive: true });
-  fs8.mkdirSync(path.join(outDir, "assets"), { recursive: true });
+  fs8.mkdirSync(path12.join(outDir, "assets"), { recursive: true });
   const pageFiles = discoverPages(pagesDir);
   if (pageFiles.length === 0) {
     console.warn("\u26A0\uFE0F No pages found in", pagesDir);
@@ -10120,7 +10177,7 @@ async function buildSSG(options) {
   const compiledPages = [];
   let hasHydratedPages = false;
   for (const pageFile of pageFiles) {
-    const relativePath = path.relative(pagesDir, pageFile);
+    const relativePath = path12.relative(pagesDir, pageFile);
     console.log(`   Compiling: ${relativePath}`);
     try {
       const compiled = await compilePage(pageFile, pagesDir, baseDir);
@@ -10141,8 +10198,8 @@ async function buildSSG(options) {
   let globalStyles = "";
   const globalsCssPath = resolveGlobalsCss(baseDir);
   if (globalsCssPath) {
-    console.log("\uD83D\uDCE6 Compiling CSS:", path.relative(baseDir, globalsCssPath));
-    const cssOutputPath = path.join(outDir, "assets", "styles.css");
+    console.log("\uD83D\uDCE6 Compiling CSS:", path12.relative(baseDir, globalsCssPath));
+    const cssOutputPath = path12.join(outDir, "assets", "styles.css");
     const result = compileCss({
       input: globalsCssPath,
       output: cssOutputPath,
@@ -10157,14 +10214,14 @@ async function buildSSG(options) {
   }
   if (hasHydratedPages) {
     const bundleJS = generateBundleJS(pluginEnvelope);
-    fs8.writeFileSync(path.join(outDir, "assets", "bundle.js"), bundleJS);
+    fs8.writeFileSync(path12.join(outDir, "assets", "bundle.js"), bundleJS);
     console.log("\uD83D\uDCE6 Generated assets/bundle.js (with plugin data)");
   }
   for (const page of compiledPages) {
-    const pageOutDir = path.join(outDir, page.outputDir);
+    const pageOutDir = path12.join(outDir, page.outputDir);
     fs8.mkdirSync(pageOutDir, { recursive: true });
     const html = generatePageHTML(page, globalStyles, pluginEnvelope);
-    fs8.writeFileSync(path.join(pageOutDir, "index.html"), html);
+    fs8.writeFileSync(path12.join(pageOutDir, "index.html"), html);
     if (page.pageScript) {
       const pageJsName = page.routePath === "/" ? "page_index.js" : `page_${page.routePath.replace(/^\//, "").replace(/\//g, "_")}.js`;
       const pageJS = generatePageJS(page);
@@ -10183,28 +10240,28 @@ async function buildSSG(options) {
         const plan = {
           ...page.bundlePlan,
           entry: pageJS,
-          resolveRoots: [path.join(baseDir, "node_modules"), "node_modules"]
+          resolveRoots: [path12.join(baseDir, "node_modules"), "node_modules"]
         };
         bundledJS = await bundlePageScript(plan);
       }
-      fs8.writeFileSync(path.join(outDir, "assets", pageJsName), bundledJS);
+      fs8.writeFileSync(path12.join(outDir, "assets", pageJsName), bundledJS);
     }
     console.log(`\u2705 ${page.outputDir}/index.html`);
   }
-  const faviconPath = path.join(baseDir, "favicon.ico");
+  const faviconPath = path12.join(baseDir, "favicon.ico");
   if (fs8.existsSync(faviconPath)) {
-    fs8.copyFileSync(faviconPath, path.join(outDir, "favicon.ico"));
+    fs8.copyFileSync(faviconPath, path12.join(outDir, "favicon.ico"));
     console.log("\uD83D\uDCE6 Copied favicon.ico");
   }
   const custom404Candidates = ["404.zen", "+404.zen", "not-found.zen"];
   let has404 = false;
   for (const candidate of custom404Candidates) {
-    const custom404Path = path.join(pagesDir, candidate);
+    const custom404Path = path12.join(pagesDir, candidate);
     if (fs8.existsSync(custom404Path)) {
       try {
         const compiled = await compilePage(custom404Path, pagesDir, baseDir);
         const html = generatePageHTML(compiled, globalStyles, pluginEnvelope);
-        fs8.writeFileSync(path.join(outDir, "404.html"), html);
+        fs8.writeFileSync(path12.join(outDir, "404.html"), html);
         console.log("\uD83D\uDCE6 Generated 404.html (custom)");
         has404 = true;
         if (compiled.pageScript) {
@@ -10214,11 +10271,11 @@ async function buildSSG(options) {
             const plan = {
               ...compiled.bundlePlan,
               entry: pageJS,
-              resolveRoots: [path.join(baseDir, "node_modules"), "node_modules"]
+              resolveRoots: [path12.join(baseDir, "node_modules"), "node_modules"]
             };
             bundledJS = await bundlePageScript(plan);
           }
-          fs8.writeFileSync(path.join(outDir, "assets", "page_404.js"), bundledJS);
+          fs8.writeFileSync(path12.join(outDir, "assets", "page_404.js"), bundledJS);
         }
       } catch (error4) {
         console.warn(`   \u26A0\uFE0F Could not compile ${candidate}: ${error4.message}`);
@@ -10252,7 +10309,7 @@ async function buildSSG(options) {
   </div>
 </body>
 </html>`;
-    fs8.writeFileSync(path.join(outDir, "404.html"), default404HTML);
+    fs8.writeFileSync(path12.join(outDir, "404.html"), default404HTML);
     console.log("\uD83D\uDCE6 Generated 404.html (default)");
   }
   console.log("");