@zenithbuild/cli 0.7.4 → 0.7.5

package/dist/dev-server.js

@@ -22,10 +22,11 @@ import { createStartupProfiler } from './startup-profile.js';
 import { createSilentLogger } from './ui/logger.js';
 import { readChangeFingerprint } from './dev-watch.js';
 import { createTrustedOriginResolver, publicHost } from './request-origin.js';
-import { encodeRequestBodyBase64, readRequestBodyBuffer } from './request-body.js';
+import { readRequestBodyBuffer } from './request-body.js';
+import { buildResourceResponseDescriptor } from './resource-response.js';
 import { supportsTargetRouteCheck } from './route-check-support.js';
 import { clientFacingRouteMessage, defaultRouteDenyMessage, logServerException, sanitizeRouteResult } from './server-error.js';
-import { executeServerRoute, injectSsrPayload, loadRouteManifest, resolveWithinDist, toStaticFilePath } from './preview.js';
+import { executeServerRoute, injectSsrPayload, loadRouteSurfaceState, resolveWithinDist, toStaticFilePath } from './preview.js';
 import { materializeImageMarkup } from './images/materialize.js';
 import { injectImageRuntimePayload } from './images/payload.js';
 import { handleImageRequest } from './images/service.js';
@@ -46,6 +47,12 @@ const MIME_TYPES = {
 const IMAGE_RUNTIME_TAG_RE = new RegExp('<' + 'script\\b[^>]*\\bid=(["\'])zenith-image-runtime\\1[^>]*>[\\s\\S]*?<\\/' + 'script>', 'i');
 const EVENT_STREAM_MIME = ['text', 'event-stream'].join('/');
 const LEGACY_DEV_STREAM_PATH = ['/__zenith', '_hmr'].join('');
+function appendSetCookieHeaders(headers, setCookies = []) {
+    if (Array.isArray(setCookies) && setCookies.length > 0) {
+        headers['Set-Cookie'] = setCookies.slice();
+    }
+    return headers;
+}
 // Note: V0 HMR script injection has been moved to the runtime client.
 // This server purely hosts the V1 HMR contract endpoints.
 /**
@@ -60,7 +67,9 @@ export async function createDevServer(options) {
     const logger = providedLogger || createSilentLogger();
     const buildSession = createDevBuildSession({ pagesDir, outDir, config, logger });
     const configuredBasePath = normalizeBasePath(config.basePath || '/');
-    const routeCheckEnabled = supportsTargetRouteCheck(resolveBuildAdapter(config).target);
+    const resolvedTarget = resolveBuildAdapter(config).target;
+    const routeCheckEnabled = supportsTargetRouteCheck(resolvedTarget);
+    const isStaticExportTarget = resolvedTarget === 'static-export';
     const resolvedPagesDir = resolve(pagesDir);
     const resolvedOutDir = resolve(outDir);
     const resolvedOutDirTmp = resolve(dirname(resolvedOutDir), `${basename(resolvedOutDir)}.tmp`);
@@ -102,7 +111,7 @@ export async function createDevServer(options) {
         getPort: () => actualPort,
         label: 'dev server'
     });
-    let currentRoutes = [];
+    let currentRouteState = { pageRoutes: [], resourceRoutes: [] };
     const rebuildDebounceMs = 5;
     const queuedRebuildDebounceMs = 5;
     function _publicHost() {
@@ -371,22 +380,26 @@ export async function createDevServer(options) {
         return true;
     }
     async function _loadRoutesForRequests() {
-        if (buildStatus === 'building' && Array.isArray(currentRoutes) && currentRoutes.length > 0) {
-            return currentRoutes;
+        if (buildStatus === 'building' &&
+            ((Array.isArray(currentRouteState.pageRoutes) && currentRouteState.pageRoutes.length > 0) ||
+                (Array.isArray(currentRouteState.resourceRoutes) && currentRouteState.resourceRoutes.length > 0))) {
+            return currentRouteState;
         }
         try {
-            const routes = await loadRouteManifest(outDir);
-            if (Array.isArray(routes) && routes.length > 0) {
-                currentRoutes = routes;
-                return routes;
+            const routeState = await loadRouteSurfaceState(outDir, configuredBasePath);
+            if ((Array.isArray(routeState.pageRoutes) && routeState.pageRoutes.length > 0) ||
+                (Array.isArray(routeState.resourceRoutes) && routeState.resourceRoutes.length > 0)) {
+                currentRouteState = routeState;
+                return routeState;
             }
         }
         catch (error) {
-            if (!(Array.isArray(currentRoutes) && currentRoutes.length > 0)) {
+            if (!(Array.isArray(currentRouteState.pageRoutes) && currentRouteState.pageRoutes.length > 0) &&
+                !(Array.isArray(currentRouteState.resourceRoutes) && currentRouteState.resourceRoutes.length > 0)) {
                 throw error;
             }
         }
-        return currentRoutes;
+        return currentRouteState;
     }
     function _broadcastEvent(type, payload = {}) {
         const eventBuildId = Number.isInteger(payload.buildId) ? payload.buildId : buildId;
@@ -419,7 +432,7 @@ export async function createDevServer(options) {
             logger.build('Initial build (id=0)', { onceKey: 'dev-initial-build' });
             const initialBuild = await buildSession.build();
             const cssReady = await _syncCssStateFromBuild(initialBuild, buildId);
-            currentRoutes = await loadRouteManifest(outDir);
+            currentRouteState = await loadRouteSurfaceState(outDir, configuredBasePath);
             buildStatus = 'ok';
             buildError = null;
             lastBuildMs = Date.now();
@@ -438,7 +451,8 @@ export async function createDevServer(options) {
                 status: buildStatus,
                 durationMs,
                 cssReady,
-                routes: Array.isArray(currentRoutes) ? currentRoutes.length : 0
+                routes: (Array.isArray(currentRouteState.pageRoutes) ? currentRouteState.pageRoutes.length : 0) +
+                    (Array.isArray(currentRouteState.resourceRoutes) ? currentRouteState.resourceRoutes.length : 0)
             });
         }
         catch (err) {
@@ -579,6 +593,9 @@ export async function createDevServer(options) {
             return;
         }
         if (pathname === imageEndpointPath(configuredBasePath)) {
+            if (isStaticExportTarget) {
+                throw new Error('not found');
+            }
             await handleImageRequest(req, res, {
                 requestUrl: url,
                 projectRoot,
@@ -629,7 +646,7 @@ export async function createDevServer(options) {
                 const canonicalTargetUrl = new URL(targetUrl.toString());
                 canonicalTargetUrl.pathname = canonicalTargetPath;
                 const routes = await _loadRoutesForRequests();
-                const resolvedCheck = resolveRequestRoute(canonicalTargetUrl, routes);
+                const resolvedCheck = resolveRequestRoute(canonicalTargetUrl, routes.pageRoutes || []);
                 if (!resolvedCheck.matched || !resolvedCheck.route) {
                     res.writeHead(404, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ error: 'route_not_found' }));
@@ -722,9 +739,14 @@ export async function createDevServer(options) {
             }
             const requestExt = extname(canonicalPath);
             if (requestExt && requestExt !== '.html') {
-                const assetPath = join(outDir, canonicalPath);
+                const assetPath = isStaticExportTarget
+                    ? resolveWithinDist(outDir, pathname)
+                    : join(outDir, canonicalPath);
                 resolvedPathFor404 = assetPath;
                 staticRootFor404 = outDir;
+                if (!assetPath) {
+                    throw new Error('not found');
+                }
                 const asset = await _readFileForRequest(assetPath);
                 const mime = MIME_TYPES[requestExt] || 'application/octet-stream';
                 res.writeHead(200, { 'Content-Type': mime });
@@ -734,9 +756,40 @@ export async function createDevServer(options) {
             const routes = await _loadRoutesForRequests();
             const canonicalUrl = new URL(url.toString());
             canonicalUrl.pathname = canonicalPath;
-            const resolved = resolveRequestRoute(canonicalUrl, routes);
+            const resolvedResource = resolveRequestRoute(canonicalUrl, routes.resourceRoutes || []);
+            if (resolvedResource.matched && resolvedResource.route) {
+                const requestMethod = req.method || 'GET';
+                const requestBodyBuffer = requestMethod === 'GET' || requestMethod === 'HEAD'
+                    ? null
+                    : await readRequestBodyBuffer(req);
+                const execution = await executeServerRoute({
+                    source: resolvedResource.route.server_script || '',
+                    sourcePath: resolvedResource.route.server_script_path || '',
+                    params: resolvedResource.params,
+                    requestUrl: url.toString(),
+                    requestMethod,
+                    requestHeaders: req.headers,
+                    requestBodyBuffer,
+                    routePattern: resolvedResource.route.path,
+                    routeFile: resolvedResource.route.server_script_path || '',
+                    routeId: resolvedResource.route.route_id || '',
+                    routeKind: 'resource'
+                });
+                const descriptor = buildResourceResponseDescriptor(execution?.result, configuredBasePath, Array.isArray(execution?.setCookies) ? execution.setCookies : []);
+                res.writeHead(descriptor.status, appendSetCookieHeaders(descriptor.headers, descriptor.setCookies));
+                if ((req.method || 'GET').toUpperCase() === 'HEAD') {
+                    res.end();
+                    return;
+                }
+                res.end(descriptor.body);
+                return;
+            }
+            const resolved = resolveRequestRoute(canonicalUrl, routes.pageRoutes || []);
             let filePath = null;
-            if (resolved.matched && resolved.route) {
+            if (isStaticExportTarget) {
+                filePath = toStaticFilePath(outDir, pathname);
+            }
+            else if (resolved.matched && resolved.route) {
                 if (verboseLogging) {
                     logger.router(`${req.method || 'GET'} ${pathname} -> ${resolved.route.path} params=${JSON.stringify(resolved.params)}`);
                 }
@@ -768,7 +821,7 @@ export async function createDevServer(options) {
                         requestUrl: url.toString(),
                         requestMethod,
                         requestHeaders: req.headers,
-                        requestBodyBase64: encodeRequestBodyBase64(requestBodyBuffer),
+                        requestBodyBuffer,
                         routePattern: resolved.route.path,
                         routeFile: resolved.route.server_script_path || '',
                         routeId: resolved.route.route_id || ''
@@ -786,22 +839,23 @@ export async function createDevServer(options) {
                 }
                 const trace = routeExecution?.trace || { guard: 'none', action: 'none', load: 'none' };
                 const routeId = resolved.route.route_id || '';
+                const setCookies = Array.isArray(routeExecution?.setCookies) ? routeExecution.setCookies : [];
                 if (verboseLogging) {
                     logger.router(`${routeId || resolved.route.path} guard=${trace.guard} action=${trace.action} load=${trace.load}`);
                 }
                 const result = routeExecution?.result;
                 if (result && result.kind === 'redirect') {
                     const status = Number.isInteger(result.status) ? result.status : 302;
-                    res.writeHead(status, {
+                    res.writeHead(status, appendSetCookieHeaders({
                         Location: appLocalRedirectLocation(result.location, configuredBasePath),
                         'Cache-Control': 'no-store'
-                    });
+                    }, setCookies));
                     res.end('');
                     return;
                 }
                 if (result && result.kind === 'deny') {
                     const status = Number.isInteger(result.status) ? result.status : 403;
-                    res.writeHead(status, { 'Content-Type': 'text/plain; charset=utf-8' });
+                    res.writeHead(status, appendSetCookieHeaders({ 'Content-Type': 'text/plain; charset=utf-8' }, setCookies));
                     res.end(clientFacingRouteMessage(status, result.message));
                     return;
                 }
@@ -825,9 +879,9 @@ export async function createDevServer(options) {
             if (!IMAGE_RUNTIME_TAG_RE.test(content)) {
                 content = injectImageRuntimePayload(content, buildSession.getImageRuntimePayload());
             }
-            res.writeHead(Number.isInteger(routeExecution?.status) ? routeExecution.status : 200, {
+            res.writeHead(Number.isInteger(routeExecution?.status) ? routeExecution.status : 200, appendSetCookieHeaders({
                 'Content-Type': 'text/html'
-            });
+            }, Array.isArray(routeExecution?.setCookies) ? routeExecution.setCookies : []));
             res.end(content);
         }
         catch (error) {
@@ -950,7 +1004,7 @@ export async function createDevServer(options) {
                 const buildResult = await buildSession.build({ changedFiles, logger });
                 const cssReady = await _syncCssStateFromBuild(buildResult, cycleBuildId);
                 if (!onlyCss) {
-                    currentRoutes = await loadRouteManifest(outDir);
+                    currentRouteState = await loadRouteSurfaceState(outDir, configuredBasePath);
                 }
                 const cssChanged = cssReady && (currentCssAssetPath !== previousCssAssetPath ||
                     currentCssContent !== previousCssContent);

package/dist/download-result.d.ts

@@ -0,0 +1,14 @@
+export function buildAttachmentContentDisposition(filename: any): string;
+export function createDownloadResult(body: any, options?: {}): {
+    kind: string;
+    body: any;
+    bodyEncoding: string;
+    bodySize: number;
+    filename: string;
+    contentType: string;
+    status: number;
+};
+export function assertValidDownloadResult(value: any, where?: string): void;
+export function decodeDownloadResultBody(result: any, where?: string): Buffer<ArrayBuffer>;
+export const DOWNLOAD_PAYLOAD_LIMIT_BYTES: number;
+export const DOWNLOAD_DEFAULT_CONTENT_TYPE: "application/octet-stream";

package/dist/download-result.js

@@ -0,0 +1,148 @@
+export const DOWNLOAD_PAYLOAD_LIMIT_BYTES = 5 * 1024 * 1024;
+export const DOWNLOAD_DEFAULT_CONTENT_TYPE = 'application/octet-stream';
+const CONTROL_CHAR_RE = /[\0-\x1F\x7F]/;
+const PATH_SEPARATOR_RE = /[\\/]/;
+function formatWhere(where = 'download(...)') {
+    return String(where || 'download(...)');
+}
+function normalizeFilename(filename, where = 'download(...)') {
+    const label = formatWhere(where);
+    const value = String(filename ?? '').trim();
+    if (!value) {
+        throw new Error(`[Zenith] ${label}: download filename is required.`);
+    }
+    if (CONTROL_CHAR_RE.test(value) || PATH_SEPARATOR_RE.test(value)) {
+        throw new Error(`[Zenith] ${label}: download filename must not contain path separators or control characters.`);
+    }
+    return value;
+}
+function normalizeContentType(contentType, where = 'download(...)') {
+    const label = formatWhere(where);
+    if (contentType === undefined || contentType === null) {
+        return DOWNLOAD_DEFAULT_CONTENT_TYPE;
+    }
+    const value = String(contentType).trim();
+    if (!value) {
+        throw new Error(`[Zenith] ${label}: download contentType must be a non-empty string when provided.`);
+    }
+    if (CONTROL_CHAR_RE.test(value)) {
+        throw new Error(`[Zenith] ${label}: download contentType must not contain control characters.`);
+    }
+    return value;
+}
+function isBlobLike(value) {
+    return (typeof Blob !== 'undefined' && value instanceof Blob)
+        || (typeof File !== 'undefined' && value instanceof File);
+}
+function encodeBuffer(buffer, encoding) {
+    return encoding === 'utf8'
+        ? buffer.toString('utf8')
+        : buffer.toString('base64');
+}
+function decodeBody(body, bodyEncoding, where = 'download(...)') {
+    const label = formatWhere(where);
+    if (typeof body !== 'string') {
+        throw new Error(`[Zenith] ${label}: download body must be a string after normalization.`);
+    }
+    if (bodyEncoding === 'utf8') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (bodyEncoding === 'base64') {
+        return Buffer.from(body, 'base64');
+    }
+    throw new Error(`[Zenith] ${label}: download bodyEncoding must be "utf8" or "base64".`);
+}
+function normalizeBody(body, where = 'download(...)') {
+    const label = formatWhere(where);
+    if (isBlobLike(body)) {
+        throw new Error(`[Zenith] ${label}: download body must be string, Uint8Array, ArrayBuffer, or Buffer-compatible bytes.`);
+    }
+    if (typeof body === 'string') {
+        const size = Buffer.byteLength(body, 'utf8');
+        if (size > DOWNLOAD_PAYLOAD_LIMIT_BYTES) {
+            throw new Error(`[Zenith] ${label}: download payload exceeds ${DOWNLOAD_PAYLOAD_LIMIT_BYTES} bytes.`);
+        }
+        return {
+            body: body,
+            bodyEncoding: 'utf8',
+            bodySize: size
+        };
+    }
+    if (body instanceof ArrayBuffer) {
+        const buffer = Buffer.from(body);
+        if (buffer.byteLength > DOWNLOAD_PAYLOAD_LIMIT_BYTES) {
+            throw new Error(`[Zenith] ${label}: download payload exceeds ${DOWNLOAD_PAYLOAD_LIMIT_BYTES} bytes.`);
+        }
+        return {
+            body: encodeBuffer(buffer, 'base64'),
+            bodyEncoding: 'base64',
+            bodySize: buffer.byteLength
+        };
+    }
+    if (ArrayBuffer.isView(body)) {
+        const buffer = Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+        if (buffer.byteLength > DOWNLOAD_PAYLOAD_LIMIT_BYTES) {
+            throw new Error(`[Zenith] ${label}: download payload exceeds ${DOWNLOAD_PAYLOAD_LIMIT_BYTES} bytes.`);
+        }
+        return {
+            body: encodeBuffer(buffer, 'base64'),
+            bodyEncoding: 'base64',
+            bodySize: buffer.byteLength
+        };
+    }
+    throw new Error(`[Zenith] ${label}: download body must be string, Uint8Array, ArrayBuffer, or Buffer-compatible bytes.`);
+}
+function buildAsciiFilename(filename) {
+    const replaced = Array.from(String(filename || '')).map((char) => {
+        const code = char.charCodeAt(0);
+        if (code < 0x20 || code > 0x7E || char === '"' || char === '\\') {
+            return '_';
+        }
+        return char;
+    }).join('');
+    return replaced || 'download';
+}
+export function buildAttachmentContentDisposition(filename) {
+    const safeFilename = normalizeFilename(filename, 'download result');
+    const asciiFilename = buildAsciiFilename(safeFilename);
+    const encodedFilename = encodeURIComponent(safeFilename)
+        .replace(/['()]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)
+        .replace(/\*/g, '%2A');
+    return `attachment; filename="${asciiFilename}"; filename*=UTF-8''${encodedFilename}`;
+}
+export function createDownloadResult(body, options = {}) {
+    const filename = normalizeFilename(options?.filename, 'download(...)');
+    const contentType = normalizeContentType(options?.contentType, 'download(...)');
+    const normalized = normalizeBody(body, 'download(...)');
+    return {
+        kind: 'download',
+        body: normalized.body,
+        bodyEncoding: normalized.bodyEncoding,
+        bodySize: normalized.bodySize,
+        filename,
+        contentType,
+        status: 200
+    };
+}
+export function assertValidDownloadResult(value, where = 'download result') {
+    const label = formatWhere(where);
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`[Zenith] ${label}: download result must be an object.`);
+    }
+    normalizeFilename(value.filename, label);
+    normalizeContentType(value.contentType, label);
+    if (value.status !== 200) {
+        throw new Error(`[Zenith] ${label}: download status is fixed to 200 in this milestone.`);
+    }
+    if (!Number.isInteger(value.bodySize) || value.bodySize < 0 || value.bodySize > DOWNLOAD_PAYLOAD_LIMIT_BYTES) {
+        throw new Error(`[Zenith] ${label}: download bodySize must be an integer between 0 and ${DOWNLOAD_PAYLOAD_LIMIT_BYTES}.`);
+    }
+    const buffer = decodeBody(value.body, value.bodyEncoding, label);
+    if (buffer.byteLength !== value.bodySize) {
+        throw new Error(`[Zenith] ${label}: download bodySize does not match the normalized body.`);
+    }
+}
+export function decodeDownloadResultBody(result, where = 'download result') {
+    assertValidDownloadResult(result, where);
+    return decodeBody(result.body, result.bodyEncoding, where);
+}

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/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,17 +84,20 @@ 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, actionPath } = resolveAdjacentServerModules(fullPath);
@@ -96,12 +108,17 @@ function buildManifestEntry({ fullPath, root, routePath, compilerOpts }) {
         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) {
@@ -325,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, action: string, load: string }, status?: number }>}
+ * @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, requestBodyBase64, 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;
@@ -62,6 +69,7 @@ export function executeServerRoute({ source, sourcePath, params, requestUrl, req
         load: string;
     };
     status?: number;
+    setCookies?: string[];
 }>;
 /**
  * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, routePattern?: string, routeFile?: string, routeId?: string }} input