@zenithbuild/cli 0.7.2 → 0.7.4

package/dist/server-contract.js

@@ -1,10 +1,10 @@
 // server-contract.js — Zenith CLI V0
 // ---------------------------------------------------------------------------
 // Shared validation and payload resolution logic for <script server> blocks.
-const NEW_KEYS = new Set(['data', 'load', 'guard', 'prerender']);
+const NEW_KEYS = new Set(['data', 'load', 'guard', 'action', 'prerender']);
 const LEGACY_KEYS = new Set(['ssr_data', 'props', 'ssr', 'prerender']);
-const ALLOWED_KEYS = new Set(['data', 'load', 'guard', 'prerender', 'ssr_data', 'props', 'ssr']);
-const ROUTE_RESULT_KINDS = new Set(['allow', 'redirect', 'deny', 'data']);
+const ALLOWED_KEYS = new Set(['data', 'load', 'guard', 'action', 'prerender', 'ssr_data', 'props', 'ssr']);
+const ROUTE_RESULT_KINDS = new Set(['allow', 'redirect', 'deny', 'data', 'invalid']);
 export function allow() {
     return { kind: 'allow' };
 }
@@ -25,6 +25,13 @@ export function deny(status = 403, message = undefined) {
 export function data(payload) {
     return { kind: 'data', data: payload };
 }
+export function invalid(payload, status = 400) {
+    return {
+        kind: 'invalid',
+        data: payload,
+        status: Number.isInteger(status) ? status : 400
+    };
+}
 function isRouteResultLike(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return false;
@@ -57,6 +64,44 @@ function assertValidRouteResultShape(value, where, allowedKinds) {
             throw new Error(`[Zenith] ${where}: deny message must be a string when provided.`);
         }
     }
+    if (kind === 'invalid') {
+        if (!Number.isInteger(value.status) || (value.status !== 400 && value.status !== 422)) {
+            throw new Error(`[Zenith] ${where}: invalid status must be 400 or 422.`);
+        }
+    }
+}
+function assertOneArgRouteFunction({ filePath, exportName, value }) {
+    if (typeof value !== 'function') {
+        throw new Error(`[Zenith] ${filePath}: "${exportName}" must be a function.`);
+    }
+    if (value.length !== 1) {
+        throw new Error(`[Zenith] ${filePath}: "${exportName}(ctx)" must take exactly 1 argument.`);
+    }
+    const fnStr = value.toString();
+    const paramsMatch = fnStr.match(/^[^{=]+\(([^)]*)\)/);
+    if (paramsMatch && paramsMatch[1].includes('...')) {
+        throw new Error(`[Zenith] ${filePath}: "${exportName}(ctx)" must not contain rest parameters.`);
+    }
+}
+function buildActionState(result) {
+    if (!result || typeof result !== 'object') {
+        return null;
+    }
+    if (result.kind === 'data') {
+        return {
+            ok: true,
+            status: 200,
+            data: result.data
+        };
+    }
+    if (result.kind === 'invalid') {
+        return {
+            ok: false,
+            status: Number.isInteger(result.status) ? result.status : 400,
+            data: result.data
+        };
+    }
+    return null;
 }
 export function validateServerExports({ exports, filePath }) {
     const exportKeys = Object.keys(exports);
@@ -67,7 +112,8 @@ export function validateServerExports({ exports, filePath }) {
     const hasData = 'data' in exports;
     const hasLoad = 'load' in exports;
     const hasGuard = 'guard' in exports;
-    const hasNew = hasData || hasLoad;
+    const hasAction = 'action' in exports;
+    const hasNew = hasData || hasLoad || hasAction;
     const hasLegacy = ('ssr_data' in exports) || ('props' in exports) || ('ssr' in exports);
     if (hasData && hasLoad) {
         throw new Error(`[Zenith] ${filePath}: cannot export both "data" and "load". Choose one.`);
@@ -78,31 +124,14 @@ export function validateServerExports({ exports, filePath }) {
     if ('prerender' in exports && typeof exports.prerender !== 'boolean') {
         throw new Error(`[Zenith] ${filePath}: "prerender" must be a boolean.`);
     }
-    if (hasLoad && typeof exports.load !== 'function') {
-        throw new Error(`[Zenith] ${filePath}: "load" must be a function.`);
-    }
     if (hasLoad) {
-        if (exports.load.length !== 1) {
-            throw new Error(`[Zenith] ${filePath}: "load(ctx)" must take exactly 1 argument.`);
-        }
-        const fnStr = exports.load.toString();
-        const paramsMatch = fnStr.match(/^[^{=]+\(([^)]*)\)/);
-        if (paramsMatch && paramsMatch[1].includes('...')) {
-            throw new Error(`[Zenith] ${filePath}: "load(ctx)" must not contain rest parameters.`);
-        }
-    }
-    if (hasGuard && typeof exports.guard !== 'function') {
-        throw new Error(`[Zenith] ${filePath}: "guard" must be a function.`);
+        assertOneArgRouteFunction({ filePath, exportName: 'load', value: exports.load });
     }
     if (hasGuard) {
-        if (exports.guard.length !== 1) {
-            throw new Error(`[Zenith] ${filePath}: "guard(ctx)" must take exactly 1 argument.`);
-        }
-        const fnStr = exports.guard.toString();
-        const paramsMatch = fnStr.match(/^[^{=]+\(([^)]*)\)/);
-        if (paramsMatch && paramsMatch[1].includes('...')) {
-            throw new Error(`[Zenith] ${filePath}: "guard(ctx)" must not contain rest parameters.`);
-        }
+        assertOneArgRouteFunction({ filePath, exportName: 'guard', value: exports.guard });
+    }
+    if (hasAction) {
+        assertOneArgRouteFunction({ filePath, exportName: 'action', value: exports.action });
     }
 }
 export function assertJsonSerializable(value, where = 'payload') {
@@ -160,8 +189,15 @@ export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = f
     validateServerExports({ exports, filePath });
     const trace = {
         guard: 'none',
+        action: 'none',
         load: 'none'
     };
+    let responseStatus = 200;
+    const requestMethod = String(ctx?.method || ctx?.request?.method || 'GET').toUpperCase();
+    const isActionRequest = !guardOnly && requestMethod === 'POST';
+    if (ctx && typeof ctx === 'object') {
+        ctx.action = null;
+    }
     if ('guard' in exports) {
         const guardRaw = await exports.guard(ctx);
         const guardResult = guardRaw == null ? allow() : guardRaw;
@@ -177,6 +213,32 @@ export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = f
     if (guardOnly) {
         return { result: allow(), trace };
     }
+    if (isActionRequest && 'action' in exports) {
+        const actionRaw = await exports.action(ctx);
+        let actionResult = null;
+        if (isRouteResultLike(actionRaw)) {
+            actionResult = actionRaw;
+            assertValidRouteResultShape(actionResult, `${filePath}: action(ctx) return`, new Set(['data', 'invalid', 'redirect', 'deny']));
+            if (actionResult.kind === 'data' || actionResult.kind === 'invalid') {
+                assertJsonSerializable(actionResult.data, `${filePath}: action(ctx) return`);
+            }
+        }
+        else {
+            assertJsonSerializable(actionRaw, `${filePath}: action(ctx) return`);
+            actionResult = data(actionRaw);
+        }
+        trace.action = actionResult.kind;
+        if (actionResult.kind === 'redirect' || actionResult.kind === 'deny') {
+            return { result: actionResult, trace };
+        }
+        const actionState = buildActionState(actionResult);
+        if (ctx && typeof ctx === 'object') {
+            ctx.action = actionState;
+        }
+        if (actionState && actionState.ok === false) {
+            responseStatus = actionState.status;
+        }
+    }
     let payload;
     if ('load' in exports) {
         const loadRaw = await exports.load(ctx);
@@ -190,34 +252,42 @@ export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = f
             loadResult = data(loadRaw);
         }
         trace.load = loadResult.kind;
-        return { result: loadResult, trace };
+        return { result: loadResult, trace, status: loadResult.kind === 'data' ? responseStatus : undefined };
     }
     if ('data' in exports) {
         payload = exports.data;
         assertJsonSerializable(payload, `${filePath}: data export`);
         trace.load = 'data';
-        return { result: data(payload), trace };
+        return { result: data(payload), trace, status: responseStatus };
     }
     // legacy fallback
     if ('ssr_data' in exports) {
         payload = exports.ssr_data;
         assertJsonSerializable(payload, `${filePath}: ssr_data export`);
         trace.load = 'data';
-        return { result: data(payload), trace };
+        return { result: data(payload), trace, status: responseStatus };
     }
     if ('props' in exports) {
         payload = exports.props;
         assertJsonSerializable(payload, `${filePath}: props export`);
         trace.load = 'data';
-        return { result: data(payload), trace };
+        return { result: data(payload), trace, status: responseStatus };
     }
     if ('ssr' in exports) {
         payload = exports.ssr;
         assertJsonSerializable(payload, `${filePath}: ssr export`);
         trace.load = 'data';
-        return { result: data(payload), trace };
+        return { result: data(payload), trace, status: responseStatus };
+    }
+    if (isActionRequest && ctx?.action) {
+        trace.load = 'data';
+        return {
+            result: data({ action: ctx.action }),
+            trace,
+            status: responseStatus
+        };
     }
-    return { result: data({}), trace };
+    return { result: data({}), trace, status: responseStatus };
 }
 export async function resolveServerPayload({ exports, ctx, filePath }) {
     const resolved = await resolveRouteResult({ exports, ctx, filePath });

package/dist/server-error.d.ts

@@ -0,0 +1,4 @@
+export function defaultRouteDenyMessage(status: any): "Unauthorized" | "Forbidden" | "Not Found" | "Internal Server Error";
+export function clientFacingRouteMessage(status: any, message: any): string;
+export function sanitizeRouteResult(result: any): any;
+export function logServerException(scope: any, error: any): void;

package/dist/server-error.js

@@ -0,0 +1,34 @@
+export function defaultRouteDenyMessage(status) {
+    if (status === 401)
+        return 'Unauthorized';
+    if (status === 403)
+        return 'Forbidden';
+    if (status === 404)
+        return 'Not Found';
+    return 'Internal Server Error';
+}
+export function clientFacingRouteMessage(status, message) {
+    const resolvedStatus = Number.isInteger(status) ? status : 500;
+    if (resolvedStatus >= 500) {
+        return defaultRouteDenyMessage(resolvedStatus);
+    }
+    const resolvedMessage = typeof message === 'string' ? message : '';
+    return resolvedMessage || defaultRouteDenyMessage(resolvedStatus);
+}
+export function sanitizeRouteResult(result) {
+    if (!result || typeof result !== 'object' || Array.isArray(result) || result.kind !== 'deny') {
+        return result;
+    }
+    const status = Number.isInteger(result.status) ? result.status : 403;
+    return {
+        ...result,
+        status,
+        message: clientFacingRouteMessage(status, result.message)
+    };
+}
+export function logServerException(scope, error) {
+    const details = error instanceof Error
+        ? (typeof error.stack === 'string' && error.stack.length > 0 ? error.stack : error.message)
+        : String(error);
+    console.error(`[Zenith:Server] ${scope}\n${details}`);
+}

package/dist/server-output.d.ts

@@ -17,8 +17,10 @@ export function writeServerOutput({ coreOutputDir, staticDir, projectRoot, confi
         server_script_path: any;
         guard_module_ref: any;
         load_module_ref: any;
+        action_module_ref: any;
         has_guard: boolean;
         has_load: boolean;
+        has_action: boolean;
         params: string[];
         image_manifest_file: string | null;
         image_config: any;

package/dist/server-output.js

@@ -29,6 +29,14 @@ const SERVER_RUNTIME_FILES = [
     {
         from: new URL('./images/shared.js', import.meta.url),
         to: 'images/shared.js'
+    },
+    {
+        from: new URL('./images/runtime.js', import.meta.url),
+        to: 'images/runtime.js'
+    },
+    {
+        from: new URL('./server-error.js', import.meta.url),
+        to: 'server-error.js'
     }
 ];
 function normalizeRouteName(routePath) {
@@ -270,12 +278,17 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             server_script_path: route.server_script_path || null,
             guard_module_ref: route.guard_module_ref || null,
             load_module_ref: route.load_module_ref || null,
+            action_module_ref: route.action_module_ref || null,
             has_guard: route.has_guard === true,
             has_load: route.has_load === true,
+            has_action: route.has_action === true,
             params: extractRouteParams(route.path),
             image_manifest_file: imageManifestFile,
             image_config: config?.images || {}
         };
+        if (Array.isArray(route.image_materialization) && route.image_materialization.length > 0) {
+            meta.image_materialization = route.image_materialization;
+        }
         await writeFile(join(routeDir, 'route.json'), `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
         emittedRoutes.push(meta);
     }

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

@@ -5,6 +5,8 @@ import { dirname, extname, join, normalize, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { appLocalRedirectLocation, imageEndpointPath, normalizeBasePath, routeCheckPath, stripBasePath } from '../base-path.js';
 import { handleImageRequest } from '../images/service.js';
+import { createTrustedOriginResolver } from '../request-origin.js';
+import { defaultRouteDenyMessage, logServerException, sanitizeRouteResult } from '../server-error.js';
 import { executeRouteRequest, renderRouteRequest } from './route-render.js';
 import { resolveRequestRoute } from './resolve-request-route.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -68,18 +70,6 @@ function toStaticFilePath(staticDir, pathname) {
     }
     return resolveWithinRoot(staticDir, resolvedPath);
 }
-function publicHost(host) {
-    if (host === '0.0.0.0' || host === '::') {
-        return '127.0.0.1';
-    }
-    return host;
-}
-function createRequestBase(req, fallbackOrigin) {
-    if (typeof req.headers.host === 'string' && req.headers.host.length > 0) {
-        return `http://${req.headers.host}`;
-    }
-    return fallbackOrigin;
-}
 async function createWebRequest(req, url) {
     const init = {
         method: req.method || 'GET',
@@ -232,10 +222,11 @@ async function handleRouteCheck(req, res, url, context) {
             result = normalizeRouteCheckResult(execution.result, targetUrl, context.basePath);
         }
         catch (error) {
+            logServerException('node route-check failed', error);
             result = {
                 kind: 'deny',
                 status: 500,
-                message: String(error)
+                message: defaultRouteDenyMessage(500)
             };
         }
     }
@@ -247,13 +238,13 @@ async function handleRouteCheck(req, res, url, context) {
         Vary: 'Cookie'
     });
     res.end(JSON.stringify({
-        result,
+        result: sanitizeRouteResult(result),
         routeId,
         to: targetUrl.toString()
     }));
 }
 async function handleNodeRequest(req, res, context, serverOrigin) {
-    const url = new URL(req.url || '/', createRequestBase(req, serverOrigin));
+    const url = new URL(req.url || '/', serverOrigin);
     const canonicalPath = stripBasePath(url.pathname, context.basePath);
     if (url.pathname === routeCheckPath(context.basePath)) {
         await handleRouteCheck(req, res, url, context);
@@ -294,9 +285,6 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
             params: serverResolved.params,
             routeModulePath: join(routeDir, 'route', 'entry.js'),
             shellHtmlPath: join(routeDir, 'route', 'page.html'),
-            pageAssetPath: serverResolved.route.page_asset_file
-                ? join(routeDir, 'route', serverResolved.route.page_asset_file)
-                : null,
             imageManifestPath: serverResolved.route.image_manifest_file
                 ? join(routeDir, 'route', serverResolved.route.image_manifest_file)
                 : null,
@@ -321,32 +309,50 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
     res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
     res.end('404 Not Found');
 }
-export async function createRequestHandler(options = {}) {
-    const context = await loadRuntimeContext(options);
-    const host = publicHost(options.host || '127.0.0.1');
-    const port = Number.isInteger(options.port) ? options.port : 3000;
-    const serverOrigin = `http://${host}:${port}`;
+function createNodeRequestHandler(context, resolveServerOrigin) {
     return async (req, res) => {
         try {
-            await handleNodeRequest(req, res, context, serverOrigin);
+            await handleNodeRequest(req, res, context, resolveServerOrigin());
         }
         catch (error) {
+            logServerException('node request handler failed', error);
             res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
-            res.end(String(error));
+            res.end(defaultRouteDenyMessage(500));
         }
     };
 }
+export async function createRequestHandler(options = {}) {
+    const context = await loadRuntimeContext(options);
+    const resolveServerOrigin = createTrustedOriginResolver({
+        publicOrigin: options.publicOrigin,
+        host: options.host || '127.0.0.1',
+        port: Number.isInteger(options.port) ? options.port : undefined,
+        label: 'createRequestHandler()'
+    });
+    resolveServerOrigin();
+    return createNodeRequestHandler(context, resolveServerOrigin);
+}
 export async function createNodeServer(options = {}) {
     const { port = 3000, host = '127.0.0.1' } = options;
-    const handler = await createRequestHandler({ ...options, port, host });
+    const context = await loadRuntimeContext(options);
+    let actualPort = Number.isInteger(port) && port > 0 ? port : 0;
+    const resolveServerOrigin = createTrustedOriginResolver({
+        publicOrigin: options.publicOrigin,
+        host,
+        getPort: () => actualPort,
+        label: 'createNodeServer()'
+    });
+    const handler = createNodeRequestHandler(context, resolveServerOrigin);
     const server = createServer((req, res) => {
         void handler(req, res);
     });
     return new Promise((resolveServer) => {
         server.listen(port, host, () => {
+            const address = server.address();
+            actualPort = address && typeof address === 'object' ? address.port : port;
             resolveServer({
                 server,
-                port: server.address().port,
+                port: actualPort,
                 close: () => server.close()
             });
         });

package/dist/server-runtime/route-render.d.ts

@@ -8,7 +8,7 @@ export function extractInternalParams(requestUrl: any, route: any): {};
  *   routeModulePath: string,
  *   guardOnly?: boolean
  * }} options
- * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, load: string } }>}
+ * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number }>}
  */
 export function executeRouteRequest(options: {
     request: Request;
@@ -30,8 +30,10 @@ export function executeRouteRequest(options: {
     };
     trace: {
         guard: string;
+        action: string;
         load: string;
     };
+    status?: number;
 }>;
 /**
  * @param {{
@@ -40,7 +42,6 @@ export function executeRouteRequest(options: {
  *   params: Record<string, string>,
  *   routeModulePath: string,
  *   shellHtmlPath: string,
- *   pageAssetPath?: string | null,
  *   imageManifestPath?: string | null,
  *   imageConfig?: Record<string, unknown>
  * }} options
@@ -58,7 +59,6 @@ export function renderRouteRequest(options: {
     params: Record<string, string>;
     routeModulePath: string;
     shellHtmlPath: string;
-    pageAssetPath?: string | null;
     imageManifestPath?: string | null;
     imageConfig?: Record<string, unknown>;
 }): Promise<Response>;

package/dist/server-runtime/route-render.js

@@ -3,7 +3,8 @@ import { pathToFileURL } from 'node:url';
 import { appLocalRedirectLocation, normalizeBasePath, prependBasePath } from '../base-path.js';
 import { createImageRuntimePayload, injectImageRuntimePayload } from '../images/payload.js';
 import { materializeImageMarkup } from '../images/materialize.js';
-import { allow, data, deny, redirect, resolveRouteResult } from '../server-contract.js';
+import { clientFacingRouteMessage, defaultRouteDenyMessage, logServerException } from '../server-error.js';
+import { allow, data, deny, invalid, redirect, resolveRouteResult } from '../server-contract.js';
 const MODULE_CACHE = new Map();
 const INTERNAL_QUERY_PREFIX = '__zenith_param_';
 function parseCookies(rawCookieHeader) {
@@ -40,18 +41,6 @@ function escapeInlineJson(payload) {
         .replace(/\u2028/g, '\\u2028')
         .replace(/\u2029/g, '\\u2029');
 }
-function defaultRouteDenyMessage(status) {
-    if (status === 401) {
-        return 'Unauthorized';
-    }
-    if (status === 403) {
-        return 'Forbidden';
-    }
-    if (status === 404) {
-        return 'Not Found';
-    }
-    return 'Internal Server Error';
-}
 function createTextResponse(status, message) {
     return new Response(message || defaultRouteDenyMessage(status), {
         status,
@@ -166,6 +155,7 @@ function createRouteContext({ request, route, params, publicUrl }) {
             file: route.file || route.server_script_path || route.route_id || route.path
         },
         env: {},
+        action: null,
         auth: {
             async getSession() {
                 return null;
@@ -177,6 +167,7 @@ function createRouteContext({ request, route, params, publicUrl }) {
         allow,
         redirect,
         deny,
+        invalid,
         data
     };
 }
@@ -188,7 +179,7 @@ function createRouteContext({ request, route, params, publicUrl }) {
  *   routeModulePath: string,
  *   guardOnly?: boolean
  * }} options
- * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, load: string } }>}
+ * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number }>}
  */
 export async function executeRouteRequest(options) {
     const { request, route, params, routeModulePath, guardOnly = false } = options;
@@ -204,7 +195,8 @@ export async function executeRouteRequest(options) {
     return {
         publicUrl,
         result: resolved.result,
-        trace: resolved.trace
+        trace: resolved.trace,
+        status: resolved.status
     };
 }
 /**
@@ -214,16 +206,15 @@ export async function executeRouteRequest(options) {
  *   params: Record<string, string>,
  *   routeModulePath: string,
  *   shellHtmlPath: string,
- *   pageAssetPath?: string | null,
  *   imageManifestPath?: string | null,
  *   imageConfig?: Record<string, unknown>
  * }} options
  * @returns {Promise<Response>}
  */
 export async function renderRouteRequest(options) {
-    const { request, route, params, routeModulePath, shellHtmlPath, pageAssetPath = null, imageManifestPath = null, imageConfig = {} } = options;
+    const { request, route, params, routeModulePath, shellHtmlPath, imageManifestPath = null, imageConfig = {} } = options;
     try {
-        const { publicUrl, result } = await executeRouteRequest({
+        const { publicUrl, result, status } = await executeRouteRequest({
             request,
             route,
             params,
@@ -240,7 +231,7 @@ export async function renderRouteRequest(options) {
         }
         if (result.kind === 'deny') {
             const status = Number.isInteger(result.status) ? result.status : 403;
-            return createTextResponse(status, result.message || defaultRouteDenyMessage(status));
+            return createTextResponse(status, clientFacingRouteMessage(status, result.message));
         }
         const ssrPayload = result.kind === 'data' && result.data && typeof result.data === 'object' && !Array.isArray(result.data)
             ? result.data
@@ -248,26 +239,24 @@ export async function renderRouteRequest(options) {
         const localImages = await loadImageManifest(imageManifestPath);
         const imagePayload = createImageRuntimePayload(imageConfig, localImages, 'passthrough', route.base_path || '/');
         let html = await readFile(shellHtmlPath, 'utf8');
-        if (pageAssetPath) {
-            html = await materializeImageMarkup({
-                html,
-                pageAssetPath,
-                payload: imagePayload,
-                ssrData: ssrPayload,
-                routePathname: publicUrl.pathname
-            });
-        }
+        html = await materializeImageMarkup({
+            html,
+            payload: imagePayload,
+            imageMaterialization: Array.isArray(route.image_materialization)
+                ? route.image_materialization
+                : []
+        });
         html = injectSsrPayload(html, ssrPayload);
         html = injectImageRuntimePayload(html, imagePayload);
         return new Response(html, {
-            status: 200,
+            status: Number.isInteger(status) ? status : 200,
             headers: {
                 'Content-Type': 'text/html; charset=utf-8'
             }
         });
     }
     catch (error) {
-        const message = String(error);
-        return createTextResponse(500, message || defaultRouteDenyMessage(500));
+        logServerException('node route render failed', error);
+        return createTextResponse(500, defaultRouteDenyMessage(500));
     }
 }

package/dist/server-script-composition.d.ts

@@ -1,39 +1,45 @@
 /**
  * @param {{
  *   sourceFile: string,
- *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null,
+ *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string } | null,
  *   adjacentGuardPath?: string | null,
- *   adjacentLoadPath?: string | null
+ *   adjacentLoadPath?: string | null,
+ *   adjacentActionPath?: string | null
  * }} input
- * @returns {{ serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, source_path: string } | null, guardPath: string | null, loadPath: string | null }}
+ * @returns {{ serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string } | null, guardPath: string | null, loadPath: string | null, actionPath: string | null }}
  */
-export function composeServerScriptEnvelope({ sourceFile, inlineServerScript, adjacentGuardPath, adjacentLoadPath }: {
+export function composeServerScriptEnvelope({ sourceFile, inlineServerScript, adjacentGuardPath, adjacentLoadPath, adjacentActionPath }: {
     sourceFile: string;
     inlineServerScript?: {
         source: string;
         prerender: boolean;
         has_guard: boolean;
         has_load: boolean;
+        has_action: boolean;
         source_path: string;
     } | null;
     adjacentGuardPath?: string | null;
     adjacentLoadPath?: string | null;
+    adjacentActionPath?: string | null;
 }): {
     serverScript: {
         source: string;
         prerender: boolean;
         has_guard: boolean;
         has_load: boolean;
+        has_action: boolean;
         source_path: string;
     } | null;
     guardPath: string | null;
     loadPath: string | null;
+    actionPath: string | null;
 };
 /**
  * @param {string} sourceFile
- * @returns {{ guardPath: string | null, loadPath: string | null }}
+ * @returns {{ guardPath: string | null, loadPath: string | null, actionPath: string | null }}
  */
 export function resolveAdjacentServerModules(sourceFile: string): {
     guardPath: string | null;
     loadPath: string | null;
+    actionPath: string | null;
 };