@zenithbuild/cli 0.7.4 → 0.7.7

package/dist/server-contract.js

@@ -1,304 +1,12 @@
 // server-contract.js — Zenith CLI V0
 // ---------------------------------------------------------------------------
 // Shared validation and payload resolution logic for <script server> blocks.
-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', 'action', 'prerender', 'ssr_data', 'props', 'ssr']);
-const ROUTE_RESULT_KINDS = new Set(['allow', 'redirect', 'deny', 'data', 'invalid']);
-export function allow() {
-    return { kind: 'allow' };
-}
-export function redirect(location, status = 302) {
-    return {
-        kind: 'redirect',
-        location: String(location || ''),
-        status: Number.isInteger(status) ? status : 302
-    };
-}
-export function deny(status = 403, message = undefined) {
-    return {
-        kind: 'deny',
-        status: Number.isInteger(status) ? status : 403,
-        message: typeof message === 'string' ? 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;
-    }
-    const kind = value.kind;
-    return typeof kind === 'string' && ROUTE_RESULT_KINDS.has(kind);
-}
-function assertValidRouteResultShape(value, where, allowedKinds) {
-    if (!isRouteResultLike(value)) {
-        throw new Error(`[Zenith] ${where}: invalid route result. Expected object with kind.`);
-    }
-    const kind = value.kind;
-    if (!allowedKinds.has(kind)) {
-        throw new Error(`[Zenith] ${where}: kind "${kind}" is not allowed here (allowed: ${Array.from(allowedKinds).join(', ')}).`);
-    }
-    if (kind === 'redirect') {
-        if (typeof value.location !== 'string' || value.location.length === 0) {
-            throw new Error(`[Zenith] ${where}: redirect requires non-empty string location.`);
-        }
-        if (value.status !== undefined && (!Number.isInteger(value.status) || value.status < 300 || value.status > 399)) {
-            throw new Error(`[Zenith] ${where}: redirect status must be an integer 3xx.`);
-        }
-    }
-    if (kind === 'deny') {
-        if (!Number.isInteger(value.status) ||
-            (value.status !== 401 && value.status !== 403 && value.status !== 404)) {
-            throw new Error(`[Zenith] ${where}: deny status must be 401, 403, or 404.`);
-        }
-        if (value.message !== undefined && typeof value.message !== 'string') {
-            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);
-    const illegalKeys = exportKeys.filter(k => !ALLOWED_KEYS.has(k));
-    if (illegalKeys.length > 0) {
-        throw new Error(`[Zenith] ${filePath}: illegal export(s): ${illegalKeys.join(', ')}`);
-    }
-    const hasData = 'data' in exports;
-    const hasLoad = 'load' in exports;
-    const hasGuard = 'guard' in exports;
-    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.`);
-    }
-    if (hasNew && hasLegacy) {
-        throw new Error(`[Zenith] ${filePath}: cannot mix new ("data"/"load") with legacy ("ssr_data"/"props"/"ssr") exports.`);
-    }
-    if ('prerender' in exports && typeof exports.prerender !== 'boolean') {
-        throw new Error(`[Zenith] ${filePath}: "prerender" must be a boolean.`);
-    }
-    if (hasLoad) {
-        assertOneArgRouteFunction({ filePath, exportName: 'load', value: exports.load });
-    }
-    if (hasGuard) {
-        assertOneArgRouteFunction({ filePath, exportName: 'guard', value: exports.guard });
-    }
-    if (hasAction) {
-        assertOneArgRouteFunction({ filePath, exportName: 'action', value: exports.action });
-    }
-}
-export function assertJsonSerializable(value, where = 'payload') {
-    const seen = new Set();
-    function walk(v, path) {
-        const t = typeof v;
-        if (v === null)
-            return;
-        if (t === 'string' || t === 'number' || t === 'boolean')
-            return;
-        if (t === 'bigint' || t === 'function' || t === 'symbol') {
-            throw new Error(`[Zenith] ${where}: non-serializable ${t} at ${path}`);
-        }
-        if (t === 'undefined') {
-            throw new Error(`[Zenith] ${where}: undefined is not allowed at ${path}`);
-        }
-        if (v instanceof Date) {
-            throw new Error(`[Zenith] ${where}: Date is not allowed at ${path} (convert to ISO string)`);
-        }
-        if (v instanceof Map || v instanceof Set) {
-            throw new Error(`[Zenith] ${where}: Map/Set not allowed at ${path}`);
-        }
-        if (t === 'object') {
-            if (seen.has(v))
-                throw new Error(`[Zenith] ${where}: circular reference at ${path}`);
-            seen.add(v);
-            if (Array.isArray(v)) {
-                if (path === '$') {
-                    throw new Error(`[Zenith] ${where}: top-level payload must be a plain object, not an array at ${path}`);
-                }
-                for (let i = 0; i < v.length; i++)
-                    walk(v[i], `${path}[${i}]`);
-                return;
-            }
-            const proto = Object.getPrototypeOf(v);
-            const isPlainObject = proto === null ||
-                proto === Object.prototype ||
-                (proto && proto.constructor && proto.constructor.name === 'Object');
-            if (!isPlainObject) {
-                throw new Error(`[Zenith] ${where}: non-plain object at ${path}`);
-            }
-            for (const k of Object.keys(v)) {
-                if (k === '__proto__' || k === 'constructor' || k === 'prototype') {
-                    throw new Error(`[Zenith] ${where}: forbidden prototype pollution key "${k}" at ${path}.${k}`);
-                }
-                walk(v[k], `${path}.${k}`);
-            }
-            return;
-        }
-        throw new Error(`[Zenith] ${where}: unsupported type at ${path}`);
-    }
-    walk(value, '$');
-}
-export async function resolveRouteResult({ exports, ctx, filePath, guardOnly = false }) {
-    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;
-        if (guardResult.kind === 'data') {
-            throw new Error(`[Zenith] ${filePath}: guard(ctx) returned data(payload) which is a critical invariant violation. guard() can only return allow(), redirect(), or deny(). Use load(ctx) for data injection.`);
-        }
-        assertValidRouteResultShape(guardResult, `${filePath}: guard(ctx) return`, new Set(['allow', 'redirect', 'deny']));
-        trace.guard = guardResult.kind;
-        if (guardResult.kind === 'redirect' || guardResult.kind === 'deny') {
-            return { result: guardResult, trace };
-        }
-    }
-    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);
-        let loadResult = null;
-        if (isRouteResultLike(loadRaw)) {
-            loadResult = loadRaw;
-            assertValidRouteResultShape(loadResult, `${filePath}: load(ctx) return`, new Set(['data', 'redirect', 'deny']));
-        }
-        else {
-            assertJsonSerializable(loadRaw, `${filePath}: load(ctx) return`);
-            loadResult = data(loadRaw);
-        }
-        trace.load = loadResult.kind;
-        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, 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, status: responseStatus };
-    }
-    if ('props' in exports) {
-        payload = exports.props;
-        assertJsonSerializable(payload, `${filePath}: props export`);
-        trace.load = 'data';
-        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, status: responseStatus };
-    }
-    if (isActionRequest && ctx?.action) {
-        trace.load = 'data';
-        return {
-            result: data({ action: ctx.action }),
-            trace,
-            status: responseStatus
-        };
-    }
-    return { result: data({}), trace, status: responseStatus };
-}
-export async function resolveServerPayload({ exports, ctx, filePath }) {
-    const resolved = await resolveRouteResult({ exports, ctx, filePath });
-    if (!resolved || !resolved.result || typeof resolved.result !== 'object') {
-        return {};
-    }
-    if (resolved.result.kind === 'data') {
-        return resolved.result.data;
-    }
-    if (resolved.result.kind === 'allow') {
-        return {};
-    }
-    throw new Error(`[Zenith] ${filePath}: resolveServerPayload() expected data but received ${resolved.result.kind}. Use resolveRouteResult() for guard/load flows.`);
-}
+//
+// This file is intentionally a thin composition/export surface.
+// ---------------------------------------------------------------------------
+import { withMiddleware } from './server-middleware.js';
+export { allow, redirect, deny, data, invalid, json, text, download, stream, sse } from './server-contract/result-helpers.js';
+export { validateServerExports } from './server-contract/export-validation.js';
+export { assertJsonSerializable } from './server-contract/json-serializable.js';
+export { resolveRouteResult, resolveServerPayload } from './server-contract/resolve.js';
+export { withMiddleware };

package/dist/server-error.d.ts

@@ -1,4 +1,4 @@
-export function defaultRouteDenyMessage(status: any): "Unauthorized" | "Forbidden" | "Not Found" | "Internal Server Error";
+export function defaultRouteDenyMessage(status: any): "Unauthorized" | "Forbidden" | "Not Found" | "Method Not Allowed" | "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

@@ -5,6 +5,8 @@ export function defaultRouteDenyMessage(status) {
         return 'Forbidden';
     if (status === 404)
         return 'Not Found';
+    if (status === 405)
+        return 'Method Not Allowed';
     return 'Internal Server Error';
 }
 export function clientFacingRouteMessage(status, message) {

package/dist/server-middleware.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Compose route middleware left-to-right:
+ * withMiddleware(handler, a, b) === a(b(handler))
+ *
+ * @template {(ctx: unknown) => unknown} T
+ * @param {T} handler
+ * @param {...((next: T) => T)} middleware
+ * @returns {T}
+ */
+export function withMiddleware<T extends (ctx: unknown) => unknown>(handler: T, ...middleware: ((next: T) => T)[]): T;

package/dist/server-middleware.js

@@ -0,0 +1,30 @@
+const WITH_MIDDLEWARE_PREFIX = '[Zenith] withMiddleware(handler, ...middleware)';
+function assertFunction(value, message) {
+    if (typeof value !== 'function') {
+        throw new Error(message);
+    }
+}
+/**
+ * Compose route middleware left-to-right:
+ * withMiddleware(handler, a, b) === a(b(handler))
+ *
+ * @template {(ctx: unknown) => unknown} T
+ * @param {T} handler
+ * @param {...((next: T) => T)} middleware
+ * @returns {T}
+ */
+export function withMiddleware(handler, ...middleware) {
+    assertFunction(handler, `${WITH_MIDDLEWARE_PREFIX}: handler must be a function.`);
+    if (middleware.length === 0) {
+        return handler;
+    }
+    let composed = handler;
+    for (let index = middleware.length - 1; index >= 0; index -= 1) {
+        const candidate = middleware[index];
+        assertFunction(candidate, `${WITH_MIDDLEWARE_PREFIX}: middleware at index ${index} must be a function.`);
+        const wrapped = candidate(composed);
+        assertFunction(wrapped, `${WITH_MIDDLEWARE_PREFIX}: middleware at index ${index} must return a function.`);
+        composed = wrapped;
+    }
+    return /** @type {T} */ (composed);
+}

package/dist/server-output.d.ts

@@ -9,6 +9,7 @@ export function writeServerOutput({ coreOutputDir, staticDir, projectRoot, confi
     routes: {
         name: any;
         path: any;
+        route_kind: any;
         output: any;
         base_path: string;
         page_asset: any;
@@ -21,7 +22,7 @@ export function writeServerOutput({ coreOutputDir, staticDir, projectRoot, confi
         has_guard: boolean;
         has_load: boolean;
         has_action: boolean;
-        params: string[];
+        params: any[];
         image_manifest_file: string | null;
         image_config: any;
     }[];

package/dist/server-output.js

@@ -3,6 +3,7 @@ import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
 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';
 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 = [
@@ -14,6 +15,19 @@ const SERVER_RUNTIME_FILES = [
         from: new URL('./server-contract.js', import.meta.url),
         to: 'server-contract.js'
     },
+    {
+        from: new URL('./server-contract', import.meta.url),
+        to: 'server-contract',
+        recursive: true
+    },
+    {
+        from: new URL('./server-middleware.js', import.meta.url),
+        to: 'server-middleware.js'
+    },
+    {
+        from: new URL('./auth/route-auth.js', import.meta.url),
+        to: 'auth/route-auth.js'
+    },
     {
         from: new URL('./base-path.js', import.meta.url),
         to: 'base-path.js'
@@ -34,11 +48,27 @@ const SERVER_RUNTIME_FILES = [
         from: new URL('./images/runtime.js', import.meta.url),
         to: 'images/runtime.js'
     },
+    {
+        from: new URL('./images/service.js', import.meta.url),
+        to: 'images/service.js'
+    },
     {
         from: new URL('./server-error.js', import.meta.url),
         to: 'server-error.js'
+    },
+    {
+        from: new URL('./resource-response.js', import.meta.url),
+        to: 'resource-response.js'
+    },
+    {
+        from: new URL('./download-result.js', import.meta.url),
+        to: 'download-result.js'
     }
 ];
+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';
@@ -152,7 +182,7 @@ function outputPathForSource(projectRoot, modulesRoot, sourcePath) {
         : relativePath.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
     return join(modulesRoot, nextRelative);
 }
-async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts, seen }) {
+async function compileImportedModule({ projectRoot, modulesRoot, serverDir, sourcePath, ts, seen }) {
     if (seen.has(sourcePath)) {
         return outputPathForSource(projectRoot, modulesRoot, sourcePath);
     }
@@ -166,6 +196,12 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
     const source = await readFile(sourcePath, 'utf8');
     let output = transpileSource(ts, source, sourcePath);
     for (const specifier of gatherSpecifiers(output)) {
+        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
+        if (specialSpecifierPath) {
+            const nextSpecifier = relative(dirname(outPath), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
+            output = replaceSpecifier(output, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+            continue;
+        }
         if (!isRelativeSpecifier(specifier)) {
             continue;
         }
@@ -176,6 +212,7 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
         const compiledDependencyPath = await compileImportedModule({
             projectRoot,
             modulesRoot,
+            serverDir,
             sourcePath: resolvedPath,
             ts,
             seen
@@ -186,12 +223,18 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
     await writeFile(outPath, output, 'utf8');
     return outPath;
 }
-async function writeRouteModulePackage({ projectRoot, routeDir, route }) {
+async function writeRouteModulePackage({ projectRoot, serverDir, routeDir, route }) {
     const ts = resolveTypeScriptApi(projectRoot);
     const modulesRoot = join(routeDir, 'modules');
     const seen = new Set();
     let entryOutput = transpileSource(ts, route.server_script || '', route.server_script_path || 'route-entry.ts');
     for (const specifier of gatherSpecifiers(entryOutput)) {
+        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
+        if (specialSpecifierPath) {
+            const nextSpecifier = relative(join(routeDir, 'route'), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
+            entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
+            continue;
+        }
         if (!isRelativeSpecifier(specifier)) {
             continue;
         }
@@ -202,6 +245,7 @@ async function writeRouteModulePackage({ projectRoot, routeDir, route }) {
         const compiledDependencyPath = await compileImportedModule({
             projectRoot,
             modulesRoot,
+            serverDir,
             sourcePath: resolvedPath,
             ts,
             seen
@@ -217,7 +261,10 @@ async function copyRuntimeFiles(serverDir) {
     for (const file of SERVER_RUNTIME_FILES) {
         const targetPath = join(serverDir, file.to);
         await mkdir(dirname(targetPath), { recursive: true });
-        await cp(file.from, targetPath, { force: true });
+        await cp(file.from, targetPath, {
+            force: true,
+            recursive: file.recursive === true
+        });
     }
 }
 async function copyOptionalFile(sourcePath, targetPath) {
@@ -238,8 +285,15 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
     catch {
         routerManifest = { routes: [] };
     }
-    const routes = Array.isArray(routerManifest.routes) ? routerManifest.routes : [];
-    const serverRoutes = routes.filter((route) => route.server_script && route.prerender !== true);
+    const resourceManifest = await loadResourceRouteManifest(staticDir, basePath);
+    const pageRoutes = Array.isArray(routerManifest.routes) ? routerManifest.routes : [];
+    const serverRoutes = pageRoutes
+        .filter((route) => route.server_script && route.prerender !== true)
+        .map((route) => ({ ...route, route_kind: 'page' }))
+        .concat((Array.isArray(resourceManifest.routes) ? resourceManifest.routes : []).map((route) => ({
+        ...route,
+        route_kind: 'resource'
+    })));
     await mkdir(serverDir, { recursive: true });
     await copyRuntimeFiles(serverDir);
     const imageManifestSource = join(staticDir, '_zenith', 'image', 'manifest.json');
@@ -248,8 +302,10 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
         const name = normalizeRouteName(route.path);
         const routeDir = join(serverDir, 'routes', name);
         await mkdir(routeDir, { recursive: true });
-        const htmlSourcePath = join(staticDir, String(route.output || '').replace(/^\//, ''));
-        await copyOptionalFile(htmlSourcePath, join(routeDir, 'route', 'page.html'));
+        if (route.route_kind !== 'resource') {
+            const htmlSourcePath = join(staticDir, String(route.output || '').replace(/^\//, ''));
+            await copyOptionalFile(htmlSourcePath, join(routeDir, 'route', 'page.html'));
+        }
         let pageAssetFile = null;
         if (typeof route.page_asset === 'string' && route.page_asset.length > 0) {
             const assetSourcePath = join(staticDir, route.page_asset.replace(/^\//, ''));
@@ -259,18 +315,20 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             }
         }
         let imageManifestFile = null;
-        if (await copyOptionalFile(imageManifestSource, join(routeDir, 'route', 'image-manifest.json'))) {
+        if (route.route_kind !== 'resource' && await copyOptionalFile(imageManifestSource, join(routeDir, 'route', 'image-manifest.json'))) {
             imageManifestFile = 'image-manifest.json';
         }
         await writeRouteModulePackage({
             projectRoot,
+            serverDir,
             routeDir,
             route
         });
         const meta = {
             name,
             path: route.path,
-            output: route.output,
+            route_kind: route.route_kind || 'page',
+            output: route.output || null,
             base_path: basePath,
             page_asset: route.page_asset || null,
             page_asset_file: pageAssetFile,
@@ -282,11 +340,13 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             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,
+            params: Array.isArray(route.params) && route.params.length > 0
+                ? [...route.params]
+                : extractRouteParams(route.path),
+            image_manifest_file: route.route_kind === 'resource' ? null : imageManifestFile,
             image_config: config?.images || {}
         };
-        if (Array.isArray(route.image_materialization) && route.image_materialization.length > 0) {
+        if (route.route_kind !== 'resource' && 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');