@zenithbuild/cli 0.7.4 → 0.7.5

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,10 @@ const SERVER_RUNTIME_FILES = [
         from: new URL('./server-contract.js', import.meta.url),
         to: 'server-contract.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 +39,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 +173,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 +187,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 +203,7 @@ async function compileImportedModule({ projectRoot, modulesRoot, sourcePath, ts,
         const compiledDependencyPath = await compileImportedModule({
             projectRoot,
             modulesRoot,
+            serverDir,
             sourcePath: resolvedPath,
             ts,
             seen
@@ -186,12 +214,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 +236,7 @@ async function writeRouteModulePackage({ projectRoot, routeDir, route }) {
         const compiledDependencyPath = await compileImportedModule({
             projectRoot,
             modulesRoot,
+            serverDir,
             sourcePath: resolvedPath,
             ts,
             seen
@@ -238,8 +273,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 +290,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 +303,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 +328,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');

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

@@ -7,7 +7,7 @@ import { appLocalRedirectLocation, imageEndpointPath, normalizeBasePath, routeCh
 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 { executeRouteRequest, renderResourceRouteRequest, renderRouteRequest } from './route-render.js';
 import { resolveRequestRoute } from './resolve-request-route.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -97,9 +97,23 @@ async function createWebRequest(req, url) {
     }
     return new Request(url.toString(), init);
 }
+function getSetCookieValues(response) {
+    if (typeof response?.headers?.getSetCookie === 'function') {
+        return response.headers.getSetCookie();
+    }
+    const value = response?.headers?.get?.('set-cookie');
+    return typeof value === 'string' && value.length > 0 ? [value] : [];
+}
 async function sendFetchResponse(res, response, method) {
     res.statusCode = response.status;
+    const setCookies = getSetCookieValues(response);
+    if (setCookies.length > 0) {
+        res.setHeader('set-cookie', setCookies);
+    }
     for (const [key, value] of response.headers.entries()) {
+        if (key.toLowerCase() === 'set-cookie') {
+            continue;
+        }
         res.setHeader(key, value);
     }
     if (String(method || 'GET').toUpperCase() === 'HEAD') {
@@ -155,13 +169,16 @@ async function loadRuntimeContext(options = {}) {
             base_path: '/'
         });
         const serverManifest = await readJson(join(serverDir, 'manifest.json'), { routes: [] });
+        const allServerRoutes = Array.isArray(serverManifest.routes) ? serverManifest.routes : [];
         return {
             distDir,
             serverDir,
             staticDir: resolve(serverDir, config.static_dir || '../static'),
             buildManifest,
             buildRoutes: Array.isArray(buildManifest.routes) ? buildManifest.routes : [],
-            serverRoutes: Array.isArray(serverManifest.routes) ? serverManifest.routes : [],
+            serverRoutes: allServerRoutes,
+            pageServerRoutes: allServerRoutes.filter((route) => route?.route_kind !== 'resource'),
+            resourceServerRoutes: allServerRoutes.filter((route) => route?.route_kind === 'resource'),
             images: config.images || {},
             basePath: normalizeBasePath(config.base_path || '/')
         };
@@ -206,7 +223,7 @@ async function handleRouteCheck(req, res, url, context) {
     }
     let result = { kind: 'allow' };
     let routeId = buildResolved.route.path || '';
-    const serverResolved = resolveRequestRoute(canonicalTargetUrl, context.serverRoutes);
+    const serverResolved = resolveRequestRoute(canonicalTargetUrl, context.pageServerRoutes);
     if (serverResolved.matched && serverResolved.route) {
         routeId = serverResolved.route.route_id || serverResolved.route.name || serverResolved.route.path || routeId;
         try {
@@ -275,7 +292,20 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
         await sendStaticFile(res, assetPath, req.method);
         return;
     }
-    const serverResolved = resolveRequestRoute(canonicalUrl, context.serverRoutes);
+    const resourceResolved = resolveRequestRoute(canonicalUrl, context.resourceServerRoutes);
+    if (resourceResolved.matched && resourceResolved.route) {
+        const routeDir = join(context.serverDir, 'routes', resourceResolved.route.name);
+        const request = await createWebRequest(req, url);
+        const response = await renderResourceRouteRequest({
+            request,
+            route: resourceResolved.route,
+            params: resourceResolved.params,
+            routeModulePath: join(routeDir, 'route', 'entry.js')
+        });
+        await sendFetchResponse(res, response, req.method);
+        return;
+    }
+    const serverResolved = resolveRequestRoute(canonicalUrl, context.pageServerRoutes);
     if (serverResolved.matched && serverResolved.route) {
         const routeDir = join(context.serverDir, 'routes', serverResolved.route.name);
         const request = await createWebRequest(req, url);

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, action: string, load: string }, status?: number }>}
+ * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
 export function executeRouteRequest(options: {
     request: Request;
@@ -34,6 +34,7 @@ export function executeRouteRequest(options: {
         load: string;
     };
     status?: number;
+    setCookies?: string[];
 }>;
 /**
  * @param {{
@@ -62,3 +63,26 @@ export function renderRouteRequest(options: {
     imageManifestPath?: string | null;
     imageConfig?: Record<string, unknown>;
 }): Promise<Response>;
+/**
+ * @param {{
+ *   request: Request,
+ *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null, route_kind?: string | null, base_path?: string | null },
+ *   params: Record<string, string>,
+ *   routeModulePath: string
+ * }} options
+ * @returns {Promise<Response>}
+ */
+export function renderResourceRouteRequest(options: {
+    request: Request;
+    route: {
+        path: string;
+        params?: string[];
+        route_id?: string | null;
+        server_script_path?: string | null;
+        file?: string | null;
+        route_kind?: string | null;
+        base_path?: string | null;
+    };
+    params: Record<string, string>;
+    routeModulePath: string;
+}): Promise<Response>;

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

@@ -1,10 +1,12 @@
 import { readFile } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
+import { attachRouteAuth } from '../auth/route-auth.js';
 import { appLocalRedirectLocation, normalizeBasePath, prependBasePath } from '../base-path.js';
 import { createImageRuntimePayload, injectImageRuntimePayload } from '../images/payload.js';
 import { materializeImageMarkup } from '../images/materialize.js';
+import { buildResourceResponseDescriptor } from '../resource-response.js';
 import { clientFacingRouteMessage, defaultRouteDenyMessage, logServerException } from '../server-error.js';
-import { allow, data, deny, invalid, redirect, resolveRouteResult } from '../server-contract.js';
+import { allow, data, deny, download, invalid, json, redirect, resolveRouteResult, text } from '../server-contract.js';
 const MODULE_CACHE = new Map();
 const INTERNAL_QUERY_PREFIX = '__zenith_param_';
 function parseCookies(rawCookieHeader) {
@@ -41,12 +43,29 @@ function escapeInlineJson(payload) {
         .replace(/\u2028/g, '\\u2028')
         .replace(/\u2029/g, '\\u2029');
 }
-function createTextResponse(status, message) {
+function appendSetCookieHeaders(headers, setCookies = []) {
+    for (const value of Array.isArray(setCookies) ? setCookies : []) {
+        headers.append('Set-Cookie', value);
+    }
+    return headers;
+}
+function createTextResponse(status, message, setCookies = []) {
+    const headers = new Headers({
+        'Content-Type': 'text/plain; charset=utf-8'
+    });
+    appendSetCookieHeaders(headers, setCookies);
     return new Response(message || defaultRouteDenyMessage(status), {
         status,
-        headers: {
-            'Content-Type': 'text/plain; charset=utf-8'
-        }
+        headers
+    });
+}
+function createResourceResponse(result, basePath, setCookies = []) {
+    const descriptor = buildResourceResponseDescriptor(result, basePath, setCookies);
+    const headers = new Headers(descriptor.headers);
+    appendSetCookieHeaders(headers, descriptor.setCookies);
+    return new Response(descriptor.body, {
+        status: descriptor.status,
+        headers
     });
 }
 function injectSsrPayload(html, payload) {
@@ -140,9 +159,9 @@ async function loadRouteExports(routeModulePath) {
     MODULE_CACHE.set(cacheKey, value);
     return value;
 }
-function createRouteContext({ request, route, params, publicUrl }) {
+function createRouteContext({ request, route, params, publicUrl, guardOnly = false }) {
     const requestHeaders = Object.fromEntries(request.headers.entries());
-    return {
+    const ctx = {
         params: { ...params },
         url: publicUrl,
         headers: { ...requestHeaders },
@@ -156,20 +175,22 @@ function createRouteContext({ request, route, params, publicUrl }) {
         },
         env: {},
         action: null,
-        auth: {
-            async getSession() {
-                return null;
-            },
-            async requireSession() {
-                throw redirect('/login', 302);
-            }
-        },
         allow,
         redirect,
         deny,
         invalid,
-        data
+        data,
+        json,
+        text,
+        download
     };
+    attachRouteAuth(ctx, {
+        requestUrl: publicUrl,
+        guardOnly,
+        redirect,
+        deny
+    });
+    return ctx;
 }
 /**
  * @param {{
@@ -179,24 +200,26 @@ function createRouteContext({ request, route, params, publicUrl }) {
  *   routeModulePath: string,
  *   guardOnly?: boolean
  * }} options
- * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number }>}
+ * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
 export async function executeRouteRequest(options) {
     const { request, route, params, routeModulePath, guardOnly = false } = options;
     const publicUrl = buildPublicUrl(request.url, route, params);
-    const ctx = createRouteContext({ request, route, params, publicUrl });
+    const ctx = createRouteContext({ request, route, params, publicUrl, guardOnly });
     const exports = await loadRouteExports(routeModulePath);
     const resolved = await resolveRouteResult({
         exports,
         ctx,
         filePath: route.file || route.server_script_path || route.path,
-        guardOnly
+        guardOnly,
+        routeKind: route.route_kind === 'resource' ? 'resource' : 'page'
     });
     return {
         publicUrl,
         result: resolved.result,
         trace: resolved.trace,
-        status: resolved.status
+        status: resolved.status,
+        setCookies: Array.isArray(resolved.setCookies) ? resolved.setCookies : []
     };
 }
 /**
@@ -214,24 +237,26 @@ export async function executeRouteRequest(options) {
 export async function renderRouteRequest(options) {
     const { request, route, params, routeModulePath, shellHtmlPath, imageManifestPath = null, imageConfig = {} } = options;
     try {
-        const { publicUrl, result, status } = await executeRouteRequest({
+        const { publicUrl, result, status, setCookies = [] } = await executeRouteRequest({
             request,
             route,
             params,
             routeModulePath
         });
         if (result.kind === 'redirect') {
+            const headers = new Headers({
+                Location: appLocalRedirectLocation(result.location, route.base_path || '/'),
+                'Cache-Control': 'no-store'
+            });
+            appendSetCookieHeaders(headers, setCookies);
             return new Response('', {
                 status: Number.isInteger(result.status) ? result.status : 302,
-                headers: {
-                    Location: appLocalRedirectLocation(result.location, route.base_path || '/'),
-                    'Cache-Control': 'no-store'
-                }
+                headers
             });
         }
         if (result.kind === 'deny') {
             const status = Number.isInteger(result.status) ? result.status : 403;
-            return createTextResponse(status, clientFacingRouteMessage(status, result.message));
+            return createTextResponse(status, clientFacingRouteMessage(status, result.message), setCookies);
         }
         const ssrPayload = result.kind === 'data' && result.data && typeof result.data === 'object' && !Array.isArray(result.data)
             ? result.data
@@ -248,11 +273,13 @@ export async function renderRouteRequest(options) {
         });
         html = injectSsrPayload(html, ssrPayload);
         html = injectImageRuntimePayload(html, imagePayload);
+        const headers = new Headers({
+            'Content-Type': 'text/html; charset=utf-8'
+        });
+        appendSetCookieHeaders(headers, setCookies);
         return new Response(html, {
             status: Number.isInteger(status) ? status : 200,
-            headers: {
-                'Content-Type': 'text/html; charset=utf-8'
-            }
+            headers
         });
     }
     catch (error) {
@@ -260,3 +287,28 @@ export async function renderRouteRequest(options) {
         return createTextResponse(500, defaultRouteDenyMessage(500));
     }
 }
+/**
+ * @param {{
+ *   request: Request,
+ *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null, route_kind?: string | null, base_path?: string | null },
+ *   params: Record<string, string>,
+ *   routeModulePath: string
+ * }} options
+ * @returns {Promise<Response>}
+ */
+export async function renderResourceRouteRequest(options) {
+    const { request, route, params, routeModulePath } = options;
+    try {
+        const { result, setCookies = [] } = await executeRouteRequest({
+            request,
+            route: { ...route, route_kind: 'resource' },
+            params,
+            routeModulePath
+        });
+        return createResourceResponse(result, route.base_path || '/', setCookies);
+    }
+    catch (error) {
+        logServerException('node resource route render failed', error);
+        return createTextResponse(500, defaultRouteDenyMessage(500));
+    }
+}

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

@@ -1,12 +1,12 @@
 /**
  * @param {{
  *   sourceFile: string,
- *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string } | null,
+ *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string, export_paths?: string[] } | null,
  *   adjacentGuardPath?: string | null,
  *   adjacentLoadPath?: string | null,
  *   adjacentActionPath?: string | null
  * }} input
- * @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 }}
+ * @returns {{ serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string, export_paths?: string[] } | null, guardPath: string | null, loadPath: string | null, actionPath: string | null }}
  */
 export function composeServerScriptEnvelope({ sourceFile, inlineServerScript, adjacentGuardPath, adjacentLoadPath, adjacentActionPath }: {
     sourceFile: string;
@@ -17,6 +17,7 @@ export function composeServerScriptEnvelope({ sourceFile, inlineServerScript, ad
         has_load: boolean;
         has_action: boolean;
         source_path: string;
+        export_paths?: string[];
     } | null;
     adjacentGuardPath?: string | null;
     adjacentLoadPath?: string | null;
@@ -29,6 +30,7 @@ export function composeServerScriptEnvelope({ sourceFile, inlineServerScript, ad
         has_load: boolean;
         has_action: boolean;
         source_path: string;
+        export_paths?: string[];
     } | null;
     guardPath: string | null;
     loadPath: string | null;

package/dist/server-script-composition.js

@@ -65,12 +65,12 @@ function classifyInlineServerSource(source) {
 /**
  * @param {{
  *   sourceFile: string,
- *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string } | null,
+ *   inlineServerScript?: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string, export_paths?: string[] } | null,
  *   adjacentGuardPath?: string | null,
  *   adjacentLoadPath?: string | null,
  *   adjacentActionPath?: string | null
  * }} input
- * @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 }}
+ * @returns {{ serverScript: { source: string, prerender: boolean, has_guard: boolean, has_load: boolean, has_action: boolean, source_path: string, export_paths?: string[] } | null, guardPath: string | null, loadPath: string | null, actionPath: string | null }}
  */
 export function composeServerScriptEnvelope({ sourceFile, inlineServerScript = null, adjacentGuardPath = null, adjacentLoadPath = null, adjacentActionPath = null }) {
     const inlineSource = String(inlineServerScript?.source || '').trim();
@@ -128,7 +128,10 @@ export function composeServerScriptEnvelope({ sourceFile, inlineServerScript = n
             has_guard: inlineHasGuard || Boolean(adjacentGuardPath),
             has_load: inlineHasLoad || Boolean(adjacentLoadPath),
             has_action: inlineHasAction || Boolean(adjacentActionPath),
-            source_path: sourceFile
+            source_path: sourceFile,
+            export_paths: Array.isArray(inlineServerScript?.export_paths)
+                ? [...inlineServerScript.export_paths]
+                : []
         },
         guardPath: adjacentGuardPath,
         loadPath: adjacentLoadPath,

package/dist/static-export-paths.d.ts

@@ -0,0 +1,3 @@
+export function extractStaticExportPaths(source: any, sourceFile: any): string[] | null;
+export function validateStaticExportPaths(routePath: any, exportPaths: any, sourceFile: any): string[];
+export function toStaticHtmlFilePath(pathname: any): string;