@zenithbuild/cli 0.7.9 → 0.7.11

package/dist/resource-route-module.js

@@ -1,27 +1,10 @@
 import { readFileSync } from 'node:fs';
 import { relative, sep } from 'node:path';
+import { readRouteHandlerExport } from './route-handler-export-analysis.js';
 const RESOURCE_EXTENSIONS = ['.resource.ts', '.resource.js', '.resource.mts', '.resource.cts', '.resource.mjs', '.resource.cjs'];
 const FORBIDDEN_RESOURCE_EXPORT_RE = /\bexport\s+const\s+(?:data|prerender|exportPaths|ssr_data|props|ssr)\b/;
-function readSingleExport(source, name) {
-    const fnMatch = source.match(new RegExp(`\\bexport\\s+(?:async\\s+)?function\\s+${name}\\s*\\(([^)]*)\\)`));
-    const constParenMatch = source.match(new RegExp(`\\bexport\\s+const\\s+${name}\\s*=\\s*(?:async\\s*)?\\(([^)]*)\\)\\s*=>`));
-    const constSingleArgMatch = source.match(new RegExp(`\\bexport\\s+const\\s+${name}\\s*=\\s*(?:async\\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=>`));
-    const matchCount = Number(Boolean(fnMatch)) +
-        Number(Boolean(constParenMatch)) +
-        Number(Boolean(constSingleArgMatch));
-    return {
-        fnMatch,
-        constParenMatch,
-        constSingleArgMatch,
-        hasExport: matchCount > 0,
-        matchCount
-    };
-}
 function assertSingleCtxArg(sourceFile, name, exportMatch) {
-    const singleArg = String(exportMatch.constSingleArgMatch?.[1] || '').trim();
-    const paramsText = String((exportMatch.fnMatch || exportMatch.constParenMatch)?.[1] || '').trim();
-    const arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
-    if (arity !== 1) {
+    if (exportMatch.arity !== null && exportMatch.arity !== 1) {
         throw new Error(`Zenith resource route contract violation:\n` +
             `  File: ${sourceFile}\n` +
             `  Reason: ${name}(ctx) must accept exactly one argument\n` +
@@ -80,9 +63,9 @@ export function analyzeResourceRouteModule(fullPath, root) {
             `  Reason: resource routes may only export guard(ctx), load(ctx), and action(ctx)\n` +
             `  Example: remove page-only exports such as data/prerender/exportPaths`);
     }
-    const guardExport = readSingleExport(source, 'guard');
-    const loadExport = readSingleExport(source, 'load');
-    const actionExport = readSingleExport(source, 'action');
+    const guardExport = readRouteHandlerExport(source, 'guard');
+    const loadExport = readRouteHandlerExport(source, 'load');
+    const actionExport = readRouteHandlerExport(source, 'action');
     for (const [name, exportMatch] of [
         ['guard', guardExport],
         ['load', loadExport],

package/dist/route-classification.d.ts

@@ -0,0 +1,10 @@
+export function classifyPageRoute({ file, serverScript }: {
+    file: any;
+    serverScript: any;
+}): {
+    prerender: boolean;
+    renderMode: string;
+    hasGuard: boolean;
+    hasLoad: boolean;
+    hasAction: boolean;
+};

package/dist/route-classification.js

@@ -0,0 +1,17 @@
+export function classifyPageRoute({ file, serverScript }) {
+    const hasGuard = serverScript?.has_guard === true;
+    const hasLoad = serverScript?.has_load === true;
+    const hasAction = serverScript?.has_action === true;
+    const prerender = serverScript?.prerender === true;
+    if (prerender && (hasGuard || hasLoad || hasAction)) {
+        throw new Error(`[zenith] Build failed for ${file}: protected routes require SSR/runtime. ` +
+            'Cannot prerender a static route with a `guard`, `load`, or `action` function.');
+    }
+    return {
+        prerender,
+        renderMode: serverScript && !prerender ? 'server' : 'prerender',
+        hasGuard,
+        hasLoad,
+        hasAction
+    };
+}

package/dist/route-handler-export-analysis.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @param {string} source
+ * @param {'guard' | 'load' | 'action'} name
+ * @returns {{
+ *   fnMatch: RegExpMatchArray | null,
+ *   constParenMatch: RegExpMatchArray | null,
+ *   constSingleArgMatch: RegExpMatchArray | null,
+ *   constMiddlewareMatch: RegExpMatchArray | null,
+ *   hasExport: boolean,
+ *   matchCount: number,
+ *   arity: number | null
+ * }}
+ */
+export function readRouteHandlerExport(source: string, name: "guard" | "load" | "action"): {
+    fnMatch: RegExpMatchArray | null;
+    constParenMatch: RegExpMatchArray | null;
+    constSingleArgMatch: RegExpMatchArray | null;
+    constMiddlewareMatch: RegExpMatchArray | null;
+    hasExport: boolean;
+    matchCount: number;
+    arity: number | null;
+};

package/dist/route-handler-export-analysis.js

@@ -0,0 +1,41 @@
+function routeHandlerExportPattern(name, tail) {
+    return new RegExp(`\\bexport\\s+const\\s+${name}\\s*=\\s*${tail}`);
+}
+/**
+ * @param {string} source
+ * @param {'guard' | 'load' | 'action'} name
+ * @returns {{
+ *   fnMatch: RegExpMatchArray | null,
+ *   constParenMatch: RegExpMatchArray | null,
+ *   constSingleArgMatch: RegExpMatchArray | null,
+ *   constMiddlewareMatch: RegExpMatchArray | null,
+ *   hasExport: boolean,
+ *   matchCount: number,
+ *   arity: number | null
+ * }}
+ */
+export function readRouteHandlerExport(source, name) {
+    const fnMatch = source.match(new RegExp(`\\bexport\\s+(?:async\\s+)?function\\s+${name}\\s*\\(([^)]*)\\)`));
+    const constParenMatch = source.match(routeHandlerExportPattern(name, '(?:async\\s*)?\\(([^)]*)\\)\\s*=>'));
+    const constSingleArgMatch = source.match(routeHandlerExportPattern(name, '(?:async\\s*)?([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*=>'));
+    const constMiddlewareMatch = source.match(routeHandlerExportPattern(name, 'withMiddleware\\s*\\('));
+    const matchCount = Number(Boolean(fnMatch)) +
+        Number(Boolean(constParenMatch)) +
+        Number(Boolean(constSingleArgMatch)) +
+        Number(Boolean(constMiddlewareMatch));
+    let arity = null;
+    if (!constMiddlewareMatch) {
+        const singleArg = String(constSingleArgMatch?.[1] || '').trim();
+        const paramsText = String((fnMatch || constParenMatch)?.[1] || '').trim();
+        arity = singleArg ? 1 : paramsText.length === 0 ? 0 : paramsText.split(',').length;
+    }
+    return {
+        fnMatch,
+        constParenMatch,
+        constSingleArgMatch,
+        constMiddlewareMatch,
+        hasExport: matchCount > 0,
+        matchCount,
+        arity
+    };
+}

package/dist/server-output.js

@@ -4,6 +4,7 @@ import { createRequire } from 'node:module';
 import { basename, dirname, extname, join, relative, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { loadResourceRouteManifest } from './resource-manifest.js';
+import { assignServerRouteNames } from './server-route-names.js';
 const PACKAGE_REQUIRE = createRequire(import.meta.url);
 const RELATIVE_SPECIFIER_RE = /((?:import|export)\s+(?:[^'"]*?\s+from\s+)?|import\s*\()\s*(['"])([^'"]+)\2/g;
 const SERVER_RUNTIME_FILES = [
@@ -44,6 +45,10 @@ const SERVER_RUNTIME_FILES = [
         from: new URL('./images/shared.js', import.meta.url),
         to: 'images/shared.js'
     },
+    {
+        from: new URL('./images/remote-fetch.js', import.meta.url),
+        to: 'images/remote-fetch.js'
+    },
     {
         from: new URL('./images/runtime.js', import.meta.url),
         to: 'images/runtime.js'
@@ -69,20 +74,6 @@ const SPECIAL_SERVER_SPECIFIERS = new Map([
     ['zenith:server-contract', 'server-contract.js'],
     ['zenith:route-auth', 'auth/route-auth.js']
 ]);
-function normalizeRouteName(routePath) {
-    if (routePath === '/') {
-        return 'index';
-    }
-    return routePath
-        .replace(/^\//, '')
-        .replace(/\/+/g, '_')
-        .replace(/:/g, 'param_')
-        .replace(/\*/g, 'splat_')
-        .replace(/\?/g, 'opt')
-        .replace(/[^a-zA-Z0-9_]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '');
-}
 function resolveTypeScriptApi(projectRoot) {
     try {
         const projectRequire = createRequire(join(projectRoot, '__zenith_server_output_loader__.js'));
@@ -298,8 +289,7 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
     await copyRuntimeFiles(serverDir);
     const imageManifestSource = join(staticDir, '_zenith', 'image', 'manifest.json');
     const emittedRoutes = [];
-    for (const route of serverRoutes) {
-        const name = normalizeRouteName(route.path);
+    for (const { route, name } of assignServerRouteNames(serverRoutes)) {
         const routeDir = join(serverDir, 'routes', name);
         await mkdir(routeDir, { recursive: true });
         if (route.route_kind !== 'resource') {

package/dist/server-route-names.d.ts

@@ -0,0 +1,2 @@
+export function normalizeRouteName(routePath: any): any;
+export function assignServerRouteNames(routes: any): any;

package/dist/server-route-names.js

@@ -0,0 +1,38 @@
+import { createHash } from 'node:crypto';
+export function normalizeRouteName(routePath) {
+    if (routePath === '/') {
+        return 'index';
+    }
+    return routePath
+        .replace(/^\//, '')
+        .replace(/\/+/g, '_')
+        .replace(/:/g, 'param_')
+        .replace(/\*/g, 'splat_')
+        .replace(/\?/g, 'opt')
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'route';
+}
+function routeNameHash(route) {
+    return createHash('sha256')
+        .update(`${route.route_kind || 'page'}:${route.path || ''}`)
+        .digest('hex')
+        .slice(0, 8);
+}
+export function assignServerRouteNames(routes) {
+    const used = new Set();
+    return routes.map((route) => {
+        const baseName = normalizeRouteName(route.path);
+        let name = baseName;
+        if (used.has(name)) {
+            name = `${baseName}_${routeNameHash(route)}`;
+        }
+        let suffix = 2;
+        while (used.has(name)) {
+            name = `${baseName}_${routeNameHash(route)}_${suffix}`;
+            suffix += 1;
+        }
+        used.add(name);
+        return { route, name };
+    });
+}

package/dist/server-runtime/node-server.js

@@ -11,6 +11,7 @@ import { executeRouteRequest, renderResourceRouteRequest, renderRouteRequest } f
 import { resolveRequestRoute } from './resolve-request-route.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const PUBLIC_ORIGIN_ENV = 'ZENITH_PUBLIC_ORIGIN';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'application/javascript; charset=utf-8',
@@ -375,8 +376,9 @@ function createNodeRequestHandler(context, resolveServerOrigin) {
 }
 export async function createRequestHandler(options = {}) {
     const context = await loadRuntimeContext(options);
+    const publicOrigin = options.publicOrigin ?? process.env[PUBLIC_ORIGIN_ENV];
     const resolveServerOrigin = createTrustedOriginResolver({
-        publicOrigin: options.publicOrigin,
+        publicOrigin,
         host: options.host || '127.0.0.1',
         port: Number.isInteger(options.port) ? options.port : undefined,
         label: 'createRequestHandler()'
@@ -388,8 +390,9 @@ export async function createNodeServer(options = {}) {
     const { port = 3000, host = '127.0.0.1' } = options;
     const context = await loadRuntimeContext(options);
     let actualPort = Number.isInteger(port) && port > 0 ? port : 0;
+    const publicOrigin = options.publicOrigin ?? process.env[PUBLIC_ORIGIN_ENV];
     const resolveServerOrigin = createTrustedOriginResolver({
-        publicOrigin: options.publicOrigin,
+        publicOrigin,
         host,
         getPort: () => actualPort,
         label: 'createNodeServer()'

package/dist/types/generate-env-dts.js

@@ -1,54 +1,12 @@
 import { writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+import { renderZenithEnvDts } from './zenith-env-dts.js';
 /**
  * @param {string} projectRoot
  * @returns {Promise<void>}
  */
 export async function generateEnvDts(projectRoot) {
-    const content = `// .zenith/zenith-env.d.ts
-// Auto-generated by Zenith. Do not edit.
-
-export {};
-
-declare global {
-  namespace Zenith {
-    type Params = Record<string, string>;
-
-    interface LoadContext {
-      params: Params;
-      url: URL;
-      request: Request;
-      route: {
-        id: string;
-        file: string;
-        pattern: string;
-      };
-    }
-
-    interface ErrorState {
-      status?: number;
-      code?: string;
-      message: string;
-    }
-
-    type PageData = Record<string, unknown> & {
-      __zenith_error?: ErrorState;
-    };
-
-    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<T> | T;
-
-    type Renderable =
-      | string
-      | number
-      | boolean
-      | null
-      | undefined
-      | Renderable[]
-      | { __zenith_fragment: true };
-  }
-}
-`;
     const outPath = join(projectRoot, '.zenith', 'zenith-env.d.ts');
     await mkdir(dirname(outPath), { recursive: true });
-    await writeFile(outPath, content, 'utf8');
+    await writeFile(outPath, renderZenithEnvDts(), 'utf8');
 }

package/dist/types/zenith-env-dts.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {string}
+ */
+export function renderZenithEnvDts(): string;

package/dist/types/zenith-env-dts.js

@@ -0,0 +1,96 @@
+/**
+ * @returns {string}
+ */
+export function renderZenithEnvDts() {
+    return [
+        '// Auto-generated by Zenith CLI. Do not edit manually.',
+        'export {};',
+        '',
+        'declare global {',
+        '  namespace Zenith {',
+        '    type Params = Record<string, string>;',
+        '',
+        '    interface ErrorState {',
+        '      status?: number;',
+        '      code?: string;',
+        '      message: string;',
+        '    }',
+        '',
+        '    type PageData = Record<string, unknown> & { __zenith_error?: ErrorState };',
+        '',
+        '    interface RouteMeta {',
+        '      id: string;',
+        '      file: string;',
+        '      pattern: string;',
+        '    }',
+        '',
+        '    type RouteSession = Record<string, unknown>;',
+        '',
+        '    type RequireSessionOptions =',
+        '      | { redirectTo: string; status?: 302 | 303 | 307 }',
+        '      | { deny: 401 | 403 | 404; message?: string };',
+        '',
+        '    type ActionState =',
+        '      | null',
+        '      | { ok: true; status: 200; data: unknown }',
+        '      | { ok: false; status: 400 | 422; data: unknown };',
+        '',
+        '    type AllowResult = { kind: "allow" };',
+        '    type RedirectResult = { kind: "redirect"; location: string; status: number };',
+        '    type DenyResult = { kind: "deny"; status: 401 | 403 | 404; message?: string };',
+        '    type DataResult<T extends PageData = PageData> = { kind: "data"; data: T };',
+        '    type InvalidResult<T = unknown> = { kind: "invalid"; data: T; status: 400 | 422 };',
+        '    type JsonResult<T = unknown> = { kind: "json"; data: T; status: number };',
+        '    type TextResult = { kind: "text"; body: string; status: number };',
+        '    type RouteDownloadBody = string | Uint8Array | ArrayBuffer;',
+        '    type RouteDownloadOptions = { filename: string; contentType?: string };',
+        '    type DownloadResult = { kind: "download"; body: string; bodyEncoding: "utf8" | "base64"; bodySize: number; filename: string; contentType: string; status: 200 };',
+        '',
+        '    interface LoadContext {',
+        '      params: Params;',
+        '      url: URL;',
+        '      headers: Record<string, string>;',
+        '      cookies: Record<string, string>;',
+        '      request: Request;',
+        '      method: string;',
+        '      route: RouteMeta;',
+        '      env: Record<string, unknown>;',
+        '      action: ActionState;',
+        '      auth: {',
+        '        getSession(): Promise<RouteSession | null>;',
+        '        requireSession(options: RequireSessionOptions): Promise<RouteSession>;',
+        '        signIn(sessionObject: RouteSession): Promise<void>;',
+        '        signOut(): Promise<void>;',
+        '      };',
+        '      allow(): AllowResult;',
+        '      redirect(location: string, status?: number): RedirectResult;',
+        '      deny(status: 401 | 403 | 404, message?: string): DenyResult;',
+        '      data<T extends PageData = PageData>(payload: T): DataResult<T>;',
+        '      invalid<T = unknown>(payload: T, status?: 400 | 422): InvalidResult<T>;',
+        '      json<T = unknown>(payload: T, status?: number): JsonResult<T>;',
+        '      text(body: string, status?: number): TextResult;',
+        '      download(body: RouteDownloadBody, options: RouteDownloadOptions): DownloadResult;',
+        '    }',
+        '',
+        '    type PageRouteResult<T extends PageData = PageData> = T | DataResult<T> | RedirectResult | DenyResult;',
+        '    type Load<T extends PageData = PageData> = (ctx: LoadContext) => Promise<PageRouteResult<T>> | PageRouteResult<T>;',
+        '',
+        '    interface Fragment {',
+        '      __zenith_fragment: true;',
+        '      mount: (anchor: Node | null) => void;',
+        '      unmount: () => void;',
+        '    }',
+        '',
+        '    type Renderable =',
+        '      | string',
+        '      | number',
+        '      | boolean',
+        '      | null',
+        '      | undefined',
+        '      | Renderable[]',
+        '      | Fragment;',
+        '  }',
+        '}',
+        ''
+    ].join('\n');
+}

package/package.json

@@ -1,13 +1,10 @@
 {
   "name": "@zenithbuild/cli",
-  "version": "0.7.9",
+  "version": "0.7.11",
   "description": "Deterministic project orchestrator for Zenith framework",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",
-  "bin": {
-    "zenith": "./dist/index.js"
-  },
   "exports": {
     ".": "./dist/index.js"
   },
@@ -38,8 +35,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@zenithbuild/compiler": "0.7.9",
-    "@zenithbuild/bundler": "0.7.9",
+    "@zenithbuild/compiler": "0.7.11",
+    "@zenithbuild/bundler": "0.7.11",
     "picocolors": "^1.1.1",
     "sharp": "^0.34.4"
   },