@zenithbuild/cli 0.6.6 → 0.6.9

package/dist/index.js

@@ -9,27 +9,24 @@
 //
 // Minimal arg parsing. No heavy dependencies.
 // ---------------------------------------------------------------------------
-
 import { resolve, join, dirname } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { createZenithLogger } from './ui/logger.js';
-
 const COMMANDS = ['dev', 'build', 'preview'];
 const DEFAULT_VERSION = '0.0.0';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-
 function getCliVersion() {
     try {
         const pkgPath = join(__dirname, '..', 'package.json');
         const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
         return typeof pkg.version === 'string' ? pkg.version : DEFAULT_VERSION;
-    } catch {
+    }
+    catch {
         return DEFAULT_VERSION;
     }
 }
-
 function printUsage(logger) {
     logger.heading('V0');
     logger.print('Usage:');
@@ -42,12 +39,10 @@ function printUsage(logger) {
     logger.print('  -v, --version     Print Zenith CLI version');
     logger.print('');
 }
-
 function resolvePort(args, fallback) {
     if (!Array.isArray(args) || args.length === 0) {
         return fallback;
     }
-
     const flagIndex = args.findIndex((arg) => arg === '--port' || arg === '-p');
     if (flagIndex >= 0 && args[flagIndex + 1]) {
         const parsed = Number.parseInt(args[flagIndex + 1], 10);
@@ -55,7 +50,6 @@ function resolvePort(args, fallback) {
             return parsed;
         }
     }
-
     const positional = args.find((arg) => /^[0-9]+$/.test(arg));
     if (positional) {
         const parsed = Number.parseInt(positional, 10);
@@ -63,10 +57,8 @@ function resolvePort(args, fallback) {
             return parsed;
         }
     }
-
     return fallback;
 }
-
 /**
  * Load zenith.config.js from project root.
  *
@@ -78,11 +70,11 @@ async function loadConfig(projectRoot) {
     try {
         const mod = await import(configPath);
         return mod.default || {};
-    } catch {
+    }
+    catch {
         return {};
     }
 }
-
 /**
  * CLI entry point.
  *
@@ -93,29 +85,24 @@ export async function cli(args, cwd) {
     const logger = createZenithLogger(process);
     const command = args[0];
     const cliVersion = getCliVersion();
-
     if (args.includes('--version') || args.includes('-v')) {
         logger.print(`zenith ${cliVersion}`);
         process.exit(0);
     }
-
     if (args.includes('--help') || args.includes('-h')) {
         printUsage(logger);
         process.exit(0);
     }
-
     if (!command || !COMMANDS.includes(command)) {
         printUsage(logger);
         process.exit(command ? 1 : 0);
     }
-
     const projectRoot = resolve(cwd || process.cwd());
     const rootPagesDir = join(projectRoot, 'pages');
     const srcPagesDir = join(projectRoot, 'src', 'pages');
     const pagesDir = existsSync(rootPagesDir) ? rootPagesDir : srcPagesDir;
     const outDir = join(projectRoot, 'dist');
     const config = await loadConfig(projectRoot);
-
     if (command === 'build' || command === 'dev') {
         const { maybeWarnAboutZenithVersionMismatch } = await import('./version-check.js');
         await maybeWarnAboutZenithVersionMismatch({
@@ -124,7 +111,6 @@ export async function cli(args, cwd) {
             command
         });
     }
-
     if (command === 'build') {
         const { build } = await import('./build.js');
         logger.build('Building…');
@@ -132,7 +118,6 @@ export async function cli(args, cwd) {
         logger.ok(`Built ${result.pages} page(s), ${result.assets.length} asset(s)`);
         logger.summary([{ label: 'Output', value: './dist' }], 'BUILD');
     }
-
     if (command === 'dev') {
         const { createDevServer } = await import('./dev-server.js');
         const port = process.env.ZENITH_DEV_PORT
@@ -142,7 +127,6 @@ export async function cli(args, cwd) {
         logger.dev('Starting dev server…');
         const dev = await createDevServer({ pagesDir, outDir, port, host, config, logger });
         logger.ok(`http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${dev.port}`);
-
         // Graceful shutdown
         process.on('SIGINT', () => {
             dev.close();
@@ -153,7 +137,6 @@ export async function cli(args, cwd) {
             process.exit(0);
         });
     }
-
     if (command === 'preview') {
         const { createPreviewServer } = await import('./preview.js');
         const port = resolvePort(args.slice(1), 4000);
@@ -161,7 +144,6 @@ export async function cli(args, cwd) {
         logger.dev('Starting preview server…');
         const preview = await createPreviewServer({ distDir: outDir, port, host, logger });
         logger.ok(`http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${preview.port}`);
-
         process.on('SIGINT', () => {
             preview.close();
             process.exit(0);
@@ -172,13 +154,9 @@ export async function cli(args, cwd) {
         });
     }
 }
-
 // Auto-run if called directly
-const isDirectRun = process.argv[1] && (
-    process.argv[1].endsWith('/index.js') ||
-    process.argv[1].endsWith('/zenith')
-);
-
+const isDirectRun = process.argv[1] && (process.argv[1].endsWith('/index.js') ||
+    process.argv[1].endsWith('/zenith'));
 if (isDirectRun) {
     cli(process.argv.slice(2)).catch((error) => {
         const logger = createZenithLogger(process);

package/dist/manifest.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @typedef {{ path: string, file: string }} ManifestEntry
+ */
+/**
+ * Scan a pages directory and produce a deterministic RouteManifest.
+ *
+ * @param {string} pagesDir - Absolute path to /pages directory
+ * @param {string} [extension='.zen'] - File extension to scan for
+ * @returns {Promise<ManifestEntry[]>}
+ */
+export function generateManifest(pagesDir: string, extension?: string): Promise<ManifestEntry[]>;
+/**
+ * Generate a JavaScript module string from manifest entries.
+ * Used for writing the manifest file to disk.
+ *
+ * @param {ManifestEntry[]} entries
+ * @returns {string}
+ */
+export function serializeManifest(entries: ManifestEntry[]): string;
+export type ManifestEntry = {
+    path: string;
+    file: string;
+};

package/dist/manifest.js

@@ -14,14 +14,11 @@
 //   - Deterministic precedence: static > :param > *catchall
 //   - Tie-breaker: lexicographic route path
 // ---------------------------------------------------------------------------
-
 import { readdir, stat } from 'node:fs/promises';
 import { join, relative, sep, basename, extname, dirname } from 'node:path';
-
 /**
  * @typedef {{ path: string, file: string }} ManifestEntry
  */
-
 /**
  * Scan a pages directory and produce a deterministic RouteManifest.
  *
@@ -31,16 +28,13 @@ import { join, relative, sep, basename, extname, dirname } from 'node:path';
  */
 export async function generateManifest(pagesDir, extension = '.zen') {
     const entries = await _scanDir(pagesDir, pagesDir, extension);
-
     // Validate: no repeated param names in any single route
     for (const entry of entries) {
         _validateParams(entry.path);
     }
-
     // Sort: static first, dynamic after, alpha within each category
     return _sortEntries(entries);
 }
-
 /**
  * Recursively scan a directory for page files.
  *
@@ -52,33 +46,29 @@ export async function generateManifest(pagesDir, extension = '.zen') {
 async function _scanDir(dir, root, ext) {
     /** @type {ManifestEntry[]} */
     const entries = [];
-
     let items;
     try {
         items = await readdir(dir);
-    } catch {
+    }
+    catch {
         return entries;
     }
-
     // Sort items for deterministic traversal
     items.sort();
-
     for (const item of items) {
         const fullPath = join(dir, item);
         const info = await stat(fullPath);
-
         if (info.isDirectory()) {
             const nested = await _scanDir(fullPath, root, ext);
             entries.push(...nested);
-        } else if (item.endsWith(ext)) {
+        }
+        else if (item.endsWith(ext)) {
             const routePath = _fileToRoute(fullPath, root, ext);
             entries.push({ path: routePath, file: relative(root, fullPath) });
         }
     }
-
     return entries;
 }
-
 /**
  * Convert a file path to a route path.
  *
@@ -97,10 +87,8 @@ async function _scanDir(dir, root, ext) {
 function _fileToRoute(filePath, root, ext) {
     const rel = relative(root, filePath);
     const withoutExt = rel.slice(0, -ext.length);
-
     // Normalize path separators
     const segments = withoutExt.split(sep).filter(Boolean);
-
     // Convert segments
     const routeSegments = segments.map((seg) => {
         // [[...param]] → *param? (optional catch-all)
@@ -108,13 +96,11 @@ function _fileToRoute(filePath, root, ext) {
         if (optionalCatchAllMatch) {
             return '*' + optionalCatchAllMatch[1] + '?';
         }
-
         // [...param] → *param (required catch-all)
         const catchAllMatch = seg.match(/^\[\.\.\.([a-zA-Z_][a-zA-Z0-9_]*)\]$/);
         if (catchAllMatch) {
             return '*' + catchAllMatch[1];
         }
-
         // [param] → :param
         const paramMatch = seg.match(/^\[([a-zA-Z_][a-zA-Z0-9_]*)\]$/);
         if (paramMatch) {
@@ -122,16 +108,13 @@ function _fileToRoute(filePath, root, ext) {
         }
         return seg;
     });
-
     // Remove trailing 'index'
     if (routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === 'index') {
         routeSegments.pop();
     }
-
     const route = '/' + routeSegments.join('/');
     return route;
 }
-
 /**
  * Validate that a route path has no repeated param names.
  *
@@ -141,7 +124,6 @@ function _fileToRoute(filePath, root, ext) {
 function _validateParams(routePath) {
     const segments = routePath.split('/').filter(Boolean);
     const paramNames = new Set();
-
     for (let i = 0; i < segments.length; i++) {
         const seg = segments[i];
         if (seg.startsWith(':') || seg.startsWith('*')) {
@@ -151,20 +133,15 @@ function _validateParams(routePath) {
             const name = optionalCatchAll ? rawName.slice(0, -1) : rawName;
             const label = isCatchAll ? `*${rawName}` : `:${name}`;
             if (paramNames.has(name)) {
-                throw new Error(
-                    `[Zenith CLI] Repeated param name '${label}' in route '${routePath}'`
-                );
+                throw new Error(`[Zenith CLI] Repeated param name '${label}' in route '${routePath}'`);
             }
             if (isCatchAll && i !== segments.length - 1) {
-                throw new Error(
-                    `[Zenith CLI] Catch-all segment '${label}' must be the last segment in route '${routePath}'`
-                );
+                throw new Error(`[Zenith CLI] Catch-all segment '${label}' must be the last segment in route '${routePath}'`);
             }
             paramNames.add(name);
         }
     }
 }
-
 /**
  * Check if a route contains any dynamic segments.
  *
@@ -174,7 +151,6 @@ function _validateParams(routePath) {
 function _isDynamic(routePath) {
     return routePath.split('/').some((seg) => seg.startsWith(':') || seg.startsWith('*'));
 }
-
 /**
  * Sort manifest entries by deterministic route precedence.
  *
@@ -184,7 +160,6 @@ function _isDynamic(routePath) {
 function _sortEntries(entries) {
     return [...entries].sort((a, b) => compareRouteSpecificity(a.path, b.path));
 }
-
 /**
  * Deterministic route precedence:
  *   static segment > param segment > catch-all segment.
@@ -195,9 +170,10 @@ function _sortEntries(entries) {
  * @returns {number}
  */
 function compareRouteSpecificity(a, b) {
-    if (a === '/' && b !== '/') return -1;
-    if (b === '/' && a !== '/') return 1;
-
+    if (a === '/' && b !== '/')
+        return -1;
+    if (b === '/' && a !== '/')
+        return 1;
     const aSegs = a.split('/').filter(Boolean);
     const bSegs = b.split('/').filter(Boolean);
     const aClass = routeClass(aSegs);
@@ -205,9 +181,7 @@ function compareRouteSpecificity(a, b) {
     if (aClass !== bClass) {
         return bClass - aClass;
     }
-
     const max = Math.min(aSegs.length, bSegs.length);
-
     for (let i = 0; i < max; i++) {
         const aWeight = segmentWeight(aSegs[i]);
         const bWeight = segmentWeight(bSegs[i]);
@@ -215,14 +189,11 @@ function compareRouteSpecificity(a, b) {
             return bWeight - aWeight;
         }
     }
-
     if (aSegs.length !== bSegs.length) {
         return bSegs.length - aSegs.length;
     }
-
     return a.localeCompare(b);
 }
-
 /**
  * @param {string[]} segments
  * @returns {number}
@@ -233,26 +204,30 @@ function routeClass(segments) {
     for (const segment of segments) {
         if (segment.startsWith('*')) {
             hasCatchAll = true;
-        } else if (segment.startsWith(':')) {
+        }
+        else if (segment.startsWith(':')) {
             hasParam = true;
         }
     }
-    if (!hasParam && !hasCatchAll) return 3;
-    if (hasCatchAll) return 1;
+    if (!hasParam && !hasCatchAll)
+        return 3;
+    if (hasCatchAll)
+        return 1;
     return 2;
 }
-
 /**
  * @param {string | undefined} segment
  * @returns {number}
  */
 function segmentWeight(segment) {
-    if (!segment) return 0;
-    if (segment.startsWith('*')) return 1;
-    if (segment.startsWith(':')) return 2;
+    if (!segment)
+        return 0;
+    if (segment.startsWith('*'))
+        return 1;
+    if (segment.startsWith(':'))
+        return 2;
     return 3;
 }
-
 /**
  * Generate a JavaScript module string from manifest entries.
  * Used for writing the manifest file to disk.
@@ -268,6 +243,5 @@ export function serializeManifest(entries) {
             : `() => import('./pages/${e.file}')`;
         return `  { path: '${e.path}', load: ${loader} }`;
     });
-
     return `export default [\n${lines.join(',\n')}\n];\n`;
 }

package/dist/preview.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Create and start a preview server.
+ *
+ * @param {{ distDir: string, port?: number, host?: string, logger?: object | null }} options
+ * @returns {Promise<{ server: import('http').Server, port: number, close: () => void }>}
+ */
+export function createPreviewServer(options: {
+    distDir: string;
+    port?: number;
+    host?: string;
+    logger?: object | null;
+}): Promise<{
+    server: import("http").Server;
+    port: number;
+    close: () => void;
+}>;
+/**
+ * @typedef {{
+ *   path: string;
+ *   output: string;
+ *   server_script?: string | null;
+ *   server_script_path?: string | null;
+ *   prerender?: boolean;
+ *   route_id?: string;
+ *   pattern?: string;
+ *   params_shape?: Record<string, string>;
+ *   has_guard?: boolean;
+ *   has_load?: boolean;
+ *   guard_module_ref?: string | null;
+ *   load_module_ref?: string | null;
+ * }} PreviewRoute
+ */
+/**
+ * @param {string} distDir
+ * @returns {Promise<PreviewRoute[]>}
+ */
+export function loadRouteManifest(distDir: string): Promise<PreviewRoute[]>;
+/**
+ * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, routePattern?: string, routeFile?: string, routeId?: string }} input
+ * @returns {Promise<{ result: { kind: string, [key: string]: unknown }, trace: { guard: string, load: string } }>}
+ */
+export function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, routePattern, routeFile, routeId, guardOnly }: {
+    source: string;
+    sourcePath: string;
+    params: Record<string, string>;
+    requestUrl?: string;
+    requestMethod?: string;
+    requestHeaders?: Record<string, string | string[] | undefined>;
+    routePattern?: string;
+    routeFile?: string;
+    routeId?: string;
+}): Promise<{
+    result: {
+        kind: string;
+        [key: string]: unknown;
+    };
+    trace: {
+        guard: string;
+        load: string;
+    };
+}>;
+/**
+ * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, routePattern?: string, routeFile?: string, routeId?: string }} input
+ * @returns {Promise<Record<string, unknown> | null>}
+ */
+export function executeServerScript(input: {
+    source: string;
+    sourcePath: string;
+    params: Record<string, string>;
+    requestUrl?: string;
+    requestMethod?: string;
+    requestHeaders?: Record<string, string | string[] | undefined>;
+    routePattern?: string;
+    routeFile?: string;
+    routeId?: string;
+}): Promise<Record<string, unknown> | null>;
+/**
+ * @param {string} html
+ * @param {Record<string, unknown>} payload
+ * @returns {string}
+ */
+export function injectSsrPayload(html: string, payload: Record<string, unknown>): string;
+export function toStaticFilePath(distDir: any, pathname: any): string | null;
+export function resolveWithinDist(distDir: any, requestPath: any): string | null;
+export const matchRoute: typeof matchManifestRoute;
+export type PreviewRoute = {
+    path: string;
+    output: string;
+    server_script?: string | null;
+    server_script_path?: string | null;
+    prerender?: boolean;
+    route_id?: string;
+    pattern?: string;
+    params_shape?: Record<string, string>;
+    has_guard?: boolean;
+    has_load?: boolean;
+    guard_module_ref?: string | null;
+    load_module_ref?: string | null;
+};
+import { matchRoute as matchManifestRoute } from './server/resolve-request-route.js';