@zenithbuild/cli 0.7.3 → 0.7.5

package/dist/images/materialize.js

@@ -1,29 +1,9 @@
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-const RUNTIME_EXPORTS = {
-    hydrate: () => () => { },
-    signal: (value) => value,
-    state: (value) => value,
-    ref: () => ({ current: null }),
-    zeneffect: () => () => { },
-    zenEffect: () => () => { },
-    zenMount: () => { },
-    zenWindow: () => undefined,
-    zenDocument: () => undefined,
-    zenOn: () => () => { },
-    zenResize: () => () => { },
-    collectRefs: (...refs) => refs.filter(Boolean)
-};
+import { renderImageHtmlWithPayload, replaceImageMarkers, serializeImageProps } from './runtime.js';
 function escapeRegex(value) {
     return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
 }
-function escapeHtml(value) {
-    return String(value ?? '')
-        .replace(/&/g, '&')
-        .replace(/"/g, '"')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;');
-}
 function parseMarkerSelector(selector) {
     const match = selector.match(/^\[([^\]=]+)=["']([^"']+)["']\]$/);
     if (!match)
@@ -41,7 +21,7 @@ function upsertAttributeMarkup(attributes, attrName, value) {
     if (value === null || value === undefined || value === false || value === '') {
         return attributes.replace(attrPattern, '');
     }
-    const serialized = ` ${trimmedName}="${escapeHtml(value)}"`;
+    const serialized = ` ${trimmedName}="${String(value)}"`;
     if (attrPattern.test(attributes)) {
         return attributes.replace(attrPattern, serialized);
     }
@@ -52,7 +32,7 @@ function applyAttributeMarker(html, selector, attrName, value) {
     if (!parsed)
         return html;
     const markerRe = new RegExp(`<([A-Za-z][\\w:-]*)([^>]*\\s${escapeRegex(parsed.attrName)}=(["'])${escapeRegex(parsed.attrValue)}\\3[^>]*)>`, 'g');
-    return html.replace(markerRe, (match, tagName, attrs) => {
+    return html.replace(markerRe, (_match, tagName, attrs) => {
         const nextAttrs = upsertAttributeMarkup(String(attrs || ''), attrName, value);
         return `<${tagName}${nextAttrs}>`;
     });
@@ -65,95 +45,33 @@ function applyInnerHtmlMarker(html, selector, value) {
     const replacement = value === null || value === undefined || value === false ? '' : String(value);
     return html.replace(markerRe, (_match, tagName, attrs) => `<${tagName}${attrs}>${replacement}</${tagName}>`);
 }
-function stripModuleSyntax(source) {
-    let next = source.replace(/^import\s+[^;]+;\s*$/gm, '');
-    if (/(^|\n)\s*import\s+/m.test(next)) {
-        throw new Error('[Zenith:Image] Cannot materialize page asset with unresolved imports');
-    }
-    next = next.replace(/^export\s+default\s+function\s+/gm, 'function ');
-    next = next.replace(/^export\s+function\s+/gm, 'function ');
-    next = next.replace(/^export\s+const\s+/gm, 'const ');
-    next = next.replace(/^export\s+let\s+/gm, 'let ');
-    next = next.replace(/^export\s+var\s+/gm, 'var ');
-    next = next.replace(/\bexport\s*\{[^}]*\};?/g, '');
-    return next;
-}
-async function evaluatePageModule(assetPath, payload, ssrData, routePathname) {
-    const source = stripModuleSyntax(await readFile(assetPath, 'utf8'));
-    const runtimeNames = Object.keys(RUNTIME_EXPORTS);
-    const evaluator = new Function('runtime', 'payload', 'ssrData', 'routePathname', [
-        '"use strict";',
-        `const { ${runtimeNames.join(', ')} } = runtime;`,
-        'const document = {};',
-        'const location = { pathname: routePathname || "/" };',
-        'const Document = class ZenithServerDocument {};',
-        'const globalThis = {',
-        '  __zenith_image_runtime: payload,',
-        '  document,',
-        '  location,',
-        '  Document',
-        '};',
-        'if (ssrData && typeof ssrData === "object" && !Array.isArray(ssrData)) {',
-        '  globalThis.__zenith_ssr_data = ssrData;',
-        '}',
-        'globalThis.globalThis = globalThis;',
-        'globalThis.window = globalThis;',
-        'globalThis.self = globalThis;',
-        source,
-        'return {',
-        '  __zenith_markers: typeof __zenith_markers !== "undefined" ? __zenith_markers : [],',
-        '  __zenith_expression_bindings: typeof __zenith_expression_bindings !== "undefined" ? __zenith_expression_bindings : [],',
-        '  __zenith_expr_fns: typeof __zenith_expr_fns !== "undefined" ? __zenith_expr_fns : []',
-        '};'
-    ].join('\n'));
-    return evaluator(RUNTIME_EXPORTS, payload, ssrData, routePathname);
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
-function buildExpressionContext(ssrData) {
-    return {
-        signalMap: new Map(),
-        params: {},
-        props: {},
-        ssrData: ssrData || {},
-        componentBindings: {},
-        zenhtml: null,
-        fragment: null
-    };
+function hasUnmaterializedImageMarkers(html) {
+    const matches = html.match(/<span\b[^>]*\bdata-zx-(?:data-zenith-image|unsafeHTML)=(["'])[^"']+\1[^>]*>/gi) || [];
+    return matches.some((tag) => /\sdata-zenith-image=/.test(tag) === false);
 }
 export async function materializeImageMarkup(options) {
-    const { html, pageAssetPath, payload, ssrData = null, routePathname = '/' } = options;
-    if (!pageAssetPath || !html.includes('data-zx-data-zenith-image')) {
-        return html;
-    }
-    const namespace = await evaluatePageModule(pageAssetPath, payload, ssrData, routePathname);
-    if (!namespace) {
-        return html;
-    }
-    const markers = Array.isArray(namespace.__zenith_markers) ? namespace.__zenith_markers : [];
-    const bindings = Array.isArray(namespace.__zenith_expression_bindings) ? namespace.__zenith_expression_bindings : [];
-    const exprFns = Array.isArray(namespace.__zenith_expr_fns) ? namespace.__zenith_expr_fns : [];
-    if (markers.length === 0 || bindings.length === 0 || exprFns.length === 0) {
+    const { html, payload, imageMaterialization = [] } = options;
+    const entries = Array.isArray(imageMaterialization) ? imageMaterialization : [];
+    if (typeof html !== 'string' || html.length === 0) {
         return html;
     }
-    const markerByIndex = new Map(markers.map((marker) => [marker.index, marker]));
     let nextHtml = html;
-    const context = buildExpressionContext(ssrData);
-    for (const binding of bindings) {
-        const marker = markerByIndex.get(Number(binding.marker_index));
-        const exprFn = Number.isInteger(binding.fn_index) ? exprFns[binding.fn_index] : null;
-        if (!marker ||
-            typeof exprFn !== 'function' ||
-            marker.kind !== 'attr' ||
-            typeof marker.selector !== 'string' ||
-            marker.selector.includes('data-zx-data-zenith-image') === false &&
-                marker.selector.includes('data-zx-innerHTML') === false) {
+    for (const entry of entries) {
+        if (!entry || typeof entry.selector !== 'string' || !isPlainObject(entry.props)) {
             continue;
         }
-        const value = exprFn(context);
-        if (marker.attr === 'innerHTML') {
-            nextHtml = applyInnerHtmlMarker(nextHtml, marker.selector, value);
-            continue;
-        }
-        nextHtml = applyAttributeMarker(nextHtml, marker.selector, marker.attr || '', value);
+        const encodedProps = serializeImageProps(entry.props);
+        const renderedHtml = renderImageHtmlWithPayload(entry.props, payload);
+        nextHtml = applyAttributeMarker(nextHtml, entry.selector, 'data-zenith-image', encodedProps);
+        nextHtml = applyInnerHtmlMarker(nextHtml, entry.selector, renderedHtml);
+    }
+    nextHtml = replaceImageMarkers(nextHtml, payload);
+    if (hasUnmaterializedImageMarkers(nextHtml)) {
+        throw new Error('[Zenith:Image] Unresolved Image markers require a compiler-owned image materialization artifact. ' +
+            'Dynamic image props are currently unsupported.');
     }
     return nextHtml;
 }
@@ -175,11 +93,9 @@ export async function materializeImageMarkupInHtmlFiles(options) {
             continue;
         }
         const outputPath = typeof route.output === 'string' ? route.output.replace(/^\//, '') : '';
-        const assetPath = typeof route.page_asset === 'string' ? route.page_asset.replace(/^\//, '') : '';
-        if (!outputPath || !assetPath)
+        if (!outputPath)
             continue;
         const fullHtmlPath = join(distDir, outputPath);
-        const fullAssetPath = join(distDir, assetPath);
         let html = '';
         try {
             html = await readFile(fullHtmlPath, 'utf8');
@@ -189,9 +105,8 @@ export async function materializeImageMarkupInHtmlFiles(options) {
         }
         const nextHtml = await materializeImageMarkup({
             html,
-            pageAssetPath: fullAssetPath,
             payload,
-            routePathname: typeof route.path === 'string' ? route.path : '/'
+            imageMaterialization: Array.isArray(route.image_materialization) ? route.image_materialization : []
         });
         if (nextHtml !== html) {
             await writeFile(fullHtmlPath, nextHtml, 'utf8');

package/dist/images/router-manifest.d.ts

@@ -0,0 +1 @@
+export function injectImageMaterializationIntoRouterManifest(distDir: any, envelopes: any): Promise<void>;

package/dist/images/router-manifest.js

@@ -0,0 +1,49 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export async function injectImageMaterializationIntoRouterManifest(distDir, envelopes) {
+    const manifestPath = join(distDir, 'assets', 'router-manifest.json');
+    let parsed;
+    try {
+        parsed = JSON.parse(await readFile(manifestPath, 'utf8'));
+    }
+    catch {
+        return;
+    }
+    const routes = Array.isArray(parsed?.routes) ? parsed.routes : null;
+    if (!routes) {
+        return;
+    }
+    const serverMetadataByRoute = new Map();
+    for (const envelope of Array.isArray(envelopes) ? envelopes : []) {
+        const route = typeof envelope?.route === 'string' ? envelope.route : '';
+        if (!route) {
+            continue;
+        }
+        const routeIr = envelope?.ir && typeof envelope.ir === 'object' ? envelope.ir : {};
+        serverMetadataByRoute.set(route, {
+            guard_module_ref: routeIr.guard_module_ref || null,
+            load_module_ref: routeIr.load_module_ref || null,
+            action_module_ref: routeIr.action_module_ref || null,
+            has_guard: routeIr.has_guard === true,
+            has_load: routeIr.has_load === true,
+            has_action: routeIr.has_action === true
+        });
+    }
+    for (const route of routes) {
+        const routePath = typeof route?.path === 'string' ? route.path : '';
+        if (!routePath) {
+            continue;
+        }
+        const serverMetadata = serverMetadataByRoute.get(routePath);
+        if (!serverMetadata) {
+            continue;
+        }
+        route.guard_module_ref = serverMetadata.guard_module_ref;
+        route.load_module_ref = serverMetadata.load_module_ref;
+        route.action_module_ref = serverMetadata.action_module_ref;
+        route.has_guard = serverMetadata.has_guard;
+        route.has_load = serverMetadata.has_load;
+        route.has_action = serverMetadata.has_action;
+    }
+    await writeFile(manifestPath, `${JSON.stringify(parsed, null, 2)}\n`, 'utf8');
+}

package/dist/images/service.d.ts

@@ -1,4 +1,16 @@
 export function buildImageArtifacts(options: any): Promise<{
     manifest: {};
 }>;
-export function handleImageRequest(req: any, res: any, options: any): Promise<boolean>;
+/**
+ * @param {Request | { url?: string } | null | undefined} request
+ * @param {{ requestUrl?: URL | string, projectRoot: string, config?: Record<string, unknown> }} options
+ * @returns {Promise<Response>}
+ */
+export function handleImageFetchRequest(request: Request | {
+    url?: string;
+} | null | undefined, options: {
+    requestUrl?: URL | string;
+    projectRoot: string;
+    config?: Record<string, unknown>;
+}): Promise<Response>;
+export function handleImageRequest(_req: any, res: any, options: any): Promise<boolean>;

package/dist/images/service.js

@@ -220,7 +220,29 @@ function remoteCachePaths(cacheDir, cacheKey) {
         metaPath: join(cacheDir, `${cacheKey}.json`)
     };
 }
-export async function handleImageRequest(req, res, options) {
+function createJsonResponse(status, payload) {
+    return new Response(JSON.stringify(payload), {
+        status,
+        headers: {
+            'Content-Type': 'application/json'
+        }
+    });
+}
+function createBufferResponse(status, contentType, buffer, cacheSeconds) {
+    return new Response(buffer, {
+        status,
+        headers: {
+            'Content-Type': contentType,
+            'Cache-Control': `public, max-age=${cacheSeconds}`
+        }
+    });
+}
+async function sendResponse(res, response) {
+    res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
+    const body = await response.arrayBuffer();
+    res.end(Buffer.from(body));
+}
+async function createImageResponse(options) {
     const { requestUrl, projectRoot, config: rawConfig } = options;
     const config = normalizeImageConfig(rawConfig);
     const url = requestUrl instanceof URL ? requestUrl : new URL(String(requestUrl));
@@ -230,14 +252,10 @@ export async function handleImageRequest(req, res, options) {
     const format = normalizeImageFormat(url.searchParams.get('f') || '');
     const quality = Number.isInteger(requestedQuality) && requestedQuality > 0 ? requestedQuality : config.quality;
     if (!remoteUrl) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'missing_url' }));
-        return true;
+        return createJsonResponse(400, { error: 'missing_url' });
     }
     if (!Number.isInteger(width) || width <= 0) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'invalid_width' }));
-        return true;
+        return createJsonResponse(400, { error: 'invalid_width' });
     }
     try {
         const remote = await validateRemoteTarget(remoteUrl, config);
@@ -253,8 +271,7 @@ export async function handleImageRequest(req, res, options) {
             const contentType = typeof parsedMeta?.contentType === 'string'
                 ? parsedMeta.contentType
                 : mimeTypeForFormat(format || 'jpg');
-            sendBuffer(res, 200, contentType, cached, config.minimumCacheTTL);
-            return true;
+            return createBufferResponse(200, contentType, cached, config.minimumCacheTTL);
         }
         const response = await fetch(remote, {
             headers: {
@@ -288,15 +305,28 @@ export async function handleImageRequest(req, res, options) {
                 format: targetFormat
             }, null, 2)}\n`, 'utf8')
         ]);
-        sendBuffer(res, 200, mimeTypeForFormat(targetFormat), output, config.minimumCacheTTL);
-        return true;
+        return createBufferResponse(200, mimeTypeForFormat(targetFormat), output, config.minimumCacheTTL);
     }
     catch (error) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({
+        return createJsonResponse(400, {
             error: 'image_request_failed',
             message: error instanceof Error ? error.message : String(error)
-        }));
-        return true;
+        });
     }
 }
+/**
+ * @param {Request | { url?: string } | null | undefined} request
+ * @param {{ requestUrl?: URL | string, projectRoot: string, config?: Record<string, unknown> }} options
+ * @returns {Promise<Response>}
+ */
+export async function handleImageFetchRequest(request, options) {
+    return createImageResponse({
+        ...options,
+        requestUrl: request?.url || options?.requestUrl
+    });
+}
+export async function handleImageRequest(_req, res, options) {
+    const response = await createImageResponse(options);
+    await sendResponse(res, response);
+    return true;
+}

package/dist/index.js

@@ -88,9 +88,15 @@ export async function cli(args, cwd) {
         printUsage(logger);
         process.exit(0);
     }
-    if (!command || !COMMANDS.includes(command)) {
+    if (!command) {
         printUsage(logger);
-        process.exit(command ? 1 : 0);
+        process.exit(0);
+    }
+    if (!COMMANDS.includes(command)) {
+        logger.print(`Unknown command: ${command}`);
+        logger.print('');
+        printUsage(logger);
+        process.exit(1);
     }
     const projectRoot = resolve(cwd || process.cwd());
     const config = await loadConfig(projectRoot);

package/dist/manifest.d.ts

@@ -2,9 +2,16 @@
  * @typedef {{
  *   path: string,
  *   file: string,
+ *   route_kind?: 'page' | 'resource',
  *   path_kind: 'static' | 'dynamic',
  *   render_mode: 'prerender' | 'server',
- *   params: string[]
+ *   params: string[],
+ *   server_script?: string,
+ *   server_script_path?: string,
+ *   has_guard?: boolean,
+ *   has_load?: boolean,
+ *   has_action?: boolean,
+ *   export_paths?: string[]
  * }} ManifestEntry
  */
 /**
@@ -29,7 +36,14 @@ export function serializeManifest(entries: ManifestEntry[]): string;
 export type ManifestEntry = {
     path: string;
     file: string;
+    route_kind?: "page" | "resource";
     path_kind: "static" | "dynamic";
     render_mode: "prerender" | "server";
     params: string[];
+    server_script?: string;
+    server_script_path?: string;
+    has_guard?: boolean;
+    has_load?: boolean;
+    has_action?: boolean;
+    export_paths?: string[];
 };

package/dist/manifest.js

@@ -18,14 +18,23 @@ import { readFileSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
 import { join, relative, sep, basename, extname, dirname } from 'node:path';
 import { extractServerScript } from './build/server-script.js';
+import { analyzeResourceRouteModule, isResourceRouteFile } from './resource-route-module.js';
 import { composeServerScriptEnvelope, resolveAdjacentServerModules } from './server-script-composition.js';
+import { validateStaticExportPaths } from './static-export-paths.js';
 /**
  * @typedef {{
  *   path: string,
  *   file: string,
+ *   route_kind?: 'page' | 'resource',
  *   path_kind: 'static' | 'dynamic',
  *   render_mode: 'prerender' | 'server',
- *   params: string[]
+ *   params: string[],
+ *   server_script?: string,
+ *   server_script_path?: string,
+ *   has_guard?: boolean,
+ *   has_load?: boolean,
+ *   has_action?: boolean,
+ *   export_paths?: string[]
  * }} ManifestEntry
  */
 /**
@@ -75,32 +84,41 @@ async function _scanDir(dir, root, ext, compilerOpts) {
         }
         else if (item.endsWith(ext)) {
             const routePath = _fileToRoute(fullPath, root, ext);
-            entries.push(buildManifestEntry({
+            entries.push(buildPageManifestEntry({
                 fullPath,
                 root,
                 routePath,
                 compilerOpts
             }));
         }
+        else if (isResourceRouteFile(item)) {
+            entries.push(analyzeResourceRouteModule(fullPath, root));
+        }
     }
     return entries;
 }
-function buildManifestEntry({ fullPath, root, routePath, compilerOpts }) {
+function buildPageManifestEntry({ fullPath, root, routePath, compilerOpts }) {
     const rawSource = readFileSync(fullPath, 'utf8');
     const inlineServerScript = extractServerScript(rawSource, fullPath, compilerOpts).serverScript;
-    const { guardPath, loadPath } = resolveAdjacentServerModules(fullPath);
+    const { guardPath, loadPath, actionPath } = resolveAdjacentServerModules(fullPath);
     const composed = composeServerScriptEnvelope({
         sourceFile: fullPath,
         inlineServerScript,
         adjacentGuardPath: guardPath,
-        adjacentLoadPath: loadPath
+        adjacentLoadPath: loadPath,
+        adjacentActionPath: actionPath
     });
+    const exportPaths = Array.isArray(composed.serverScript?.export_paths)
+        ? validateStaticExportPaths(routePath, composed.serverScript.export_paths, fullPath)
+        : [];
     return {
         path: routePath,
         file: relative(root, fullPath),
+        route_kind: 'page',
         path_kind: _isDynamic(routePath) ? 'dynamic' : 'static',
         render_mode: composed.serverScript && composed.serverScript.prerender !== true ? 'server' : 'prerender',
-        params: extractRouteParams(routePath)
+        params: extractRouteParams(routePath),
+        ...(exportPaths.length > 0 ? { export_paths: exportPaths } : {})
     };
 }
 function extractRouteParams(routePath) {
@@ -324,7 +342,9 @@ function segmentWeight(segment) {
  * @returns {string}
  */
 export function serializeManifest(entries) {
-    const lines = entries.map((e) => {
+    const lines = entries
+        .filter((entry) => entry?.route_kind !== 'resource')
+        .map((e) => {
         const hasParams = _isDynamic(e.path);
         const loader = hasParams
             ? `(params) => import('./pages/${e.file}')`

package/dist/preview.d.ts

@@ -37,20 +37,27 @@ export function createPreviewServer(options: {
  * @returns {Promise<PreviewRoute[]>}
  */
 export function loadRouteManifest(distDir: string): Promise<PreviewRoute[]>;
+export function loadRouteSurfaceState(distDir: any, fallbackBasePath?: string): Promise<{
+    basePath: string;
+    pageRoutes: any;
+    resourceRoutes: any[];
+}>;
 /**
- * @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 } }>}
+ * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, requestBodyBuffer?: Buffer | null, routePattern?: string, routeFile?: string, routeId?: string, routeKind?: 'page' | 'resource' }} input
+ * @returns {Promise<{ result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
-export function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, routePattern, routeFile, routeId, guardOnly }: {
+export function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, requestBodyBuffer, routePattern, routeFile, routeId, routeKind, guardOnly }: {
     source: string;
     sourcePath: string;
     params: Record<string, string>;
     requestUrl?: string;
     requestMethod?: string;
     requestHeaders?: Record<string, string | string[] | undefined>;
+    requestBodyBuffer?: Buffer | null;
     routePattern?: string;
     routeFile?: string;
     routeId?: string;
+    routeKind?: "page" | "resource";
 }): Promise<{
     result: {
         kind: string;
@@ -58,10 +65,12 @@ export function executeServerRoute({ source, sourcePath, params, requestUrl, req
     };
     trace: {
         guard: string;
+        action: string;
         load: string;
     };
+    status?: number;
+    setCookies?: string[];
 }>;
-export function defaultRouteDenyMessage(status: any): "Unauthorized" | "Forbidden" | "Not Found" | "Internal Server Error";
 /**
  * @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>}