@zenithbuild/cli 0.7.4 → 0.7.7

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/payload.js

@@ -18,6 +18,10 @@ function serializeInlineScriptJson(payload) {
         .replace(/\u2029/g, '\\u2029');
 }
 export function injectImageRuntimePayload(html, payload) {
+    // Only inject if the HTML contains Zenith image markers or unsafeHTML
+    if (!/data-zx-(data-zenith-image|unsafeHTML)/.test(html)) {
+        return html;
+    }
     const safePayload = createImageRuntimePayload(payload?.config || {}, payload?.localImages || {}, payload?.mode || 'passthrough', payload?.basePath || '/');
     const globalName = imageRuntimeGlobalName();
     const serialized = serializeInlineScriptJson(safePayload);

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

@@ -16,16 +16,25 @@
 // ---------------------------------------------------------------------------
 import { readFileSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
-import { join, relative, sep, basename, extname, dirname } from 'node:path';
+import { join, relative, sep, basename, extname, dirname, resolve } 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
  */
 /**
@@ -38,6 +47,11 @@ import { composeServerScriptEnvelope, resolveAdjacentServerModules } from './ser
  */
 export async function generateManifest(pagesDir, extension = '.zen', options = {}) {
     const entries = await _scanDir(pagesDir, pagesDir, extension, options.compilerOpts || {});
+    const apiAliasState = _resolveSrcApiAliasState(pagesDir);
+    if (apiAliasState) {
+        const aliasEntries = await _scanResourceDir(apiAliasState.aliasDir, apiAliasState.srcDir);
+        entries.push(...aliasEntries);
+    }
     // Validate: no repeated param names in any single route
     for (const entry of entries) {
         _validateParams(entry.path);
@@ -75,17 +89,60 @@ 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 }) {
+async function _scanResourceDir(dir, root) {
+    /** @type {ManifestEntry[]} */
+    const entries = [];
+    let items;
+    try {
+        items = await readdir(dir);
+    }
+    catch {
+        return entries;
+    }
+    items.sort();
+    for (const item of items) {
+        const fullPath = join(dir, item);
+        const info = await stat(fullPath);
+        if (info.isDirectory()) {
+            const nested = await _scanResourceDir(fullPath, root);
+            entries.push(...nested);
+        }
+        else if (isResourceRouteFile(item)) {
+            entries.push(analyzeResourceRouteModule(fullPath, root));
+        }
+    }
+    return entries;
+}
+function _resolveSrcApiAliasState(pagesDir) {
+    const resolvedPagesDir = resolve(pagesDir);
+    const srcDir = dirname(resolvedPagesDir);
+    if (basename(srcDir) !== 'src') {
+        return null;
+    }
+    const aliasDir = join(srcDir, 'api');
+    if (aliasDir === resolvedPagesDir ||
+        aliasDir.startsWith(`${resolvedPagesDir}${sep}`)) {
+        return null;
+    }
+    return {
+        aliasDir,
+        srcDir
+    };
+}
+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 +153,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 +387,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/create-preview-server.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Create and start a preview server.
+ *
+ * @param {{ distDir: string, port?: number, host?: string, logger?: object | null, config?: object, projectRoot?: string }} options
+ * @returns {Promise<{ server: import('http').Server, port: number, close: () => void }>}
+ */
+export function createPreviewServer(options: {
+    distDir: string;
+    port?: number;
+    host?: string;
+    logger?: object | null;
+    config?: object;
+    projectRoot?: string;
+}): Promise<{
+    server: import("http").Server;
+    port: number;
+    close: () => void;
+}>;

package/dist/preview/create-preview-server.js

@@ -0,0 +1,71 @@
+import { createServer } from 'node:http';
+import { resolve } from 'node:path';
+import { normalizeBasePath } from '../base-path.js';
+import { resolveBuildAdapter } from '../adapters/resolve-adapter.js';
+import { isConfigKeyExplicit, isLoadedConfig, loadConfig, validateConfig } from '../config.js';
+import { createTrustedOriginResolver } from '../request-origin.js';
+import { supportsTargetRouteCheck } from '../route-check-support.js';
+import { createSilentLogger } from '../ui/logger.js';
+import { createPreviewRequestHandler } from './request-handler.js';
+/**
+ * Create and start a preview server.
+ *
+ * @param {{ distDir: string, port?: number, host?: string, logger?: object | null, config?: object, projectRoot?: string }} options
+ * @returns {Promise<{ server: import('http').Server, port: number, close: () => void }>}
+ */
+export async function createPreviewServer(options) {
+    const resolvedProjectRoot = options?.projectRoot ? resolve(options.projectRoot) : resolve(options.distDir, '..');
+    const loadedConfig = await loadConfig(resolvedProjectRoot);
+    const resolvedConfig = options?.config && typeof options.config === 'object'
+        ? (() => {
+            const overrideConfig = isLoadedConfig(options.config)
+                ? options.config
+                : validateConfig(options.config);
+            const mergedConfig = { ...loadedConfig };
+            for (const key of Object.keys(overrideConfig)) {
+                if (isConfigKeyExplicit(overrideConfig, key)) {
+                    mergedConfig[key] = overrideConfig[key];
+                }
+            }
+            return mergedConfig;
+        })()
+        : loadedConfig;
+    const { distDir, port = 4000, host = '127.0.0.1', logger: providedLogger = null } = options;
+    const projectRoot = resolvedProjectRoot;
+    const config = resolvedConfig;
+    const logger = providedLogger || createSilentLogger();
+    const verboseLogging = logger.mode?.logLevel === 'verbose';
+    const configuredBasePath = normalizeBasePath(config.basePath || '/');
+    const resolvedTarget = resolveBuildAdapter(config).target;
+    const routeCheckEnabled = supportsTargetRouteCheck(resolvedTarget);
+    const isStaticExportTarget = resolvedTarget === 'static-export';
+    let actualPort = port;
+    const resolveServerOrigin = createTrustedOriginResolver({
+        host,
+        getPort: () => actualPort,
+        label: 'preview server'
+    });
+    const server = createServer(createPreviewRequestHandler({
+        distDir,
+        projectRoot,
+        config,
+        logger,
+        verboseLogging,
+        configuredBasePath,
+        routeCheckEnabled,
+        isStaticExportTarget,
+        serverOrigin: resolveServerOrigin
+    }));
+    return new Promise((resolveServer) => {
+        server.listen(port, host, () => {
+            actualPort = server.address().port;
+            resolveServer({
+                server,
+                port: actualPort,
+                close: () => {
+                    server.close();
+                }
+            });
+        });
+    });
+}

package/dist/preview/manifest.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @typedef {{
+ *   path: string;
+ *   output: string;
+ *   server_script?: string | null;
+ *   server_script_path?: string | null;
+ *   prerender?: boolean;
+ *   route_id?: string;
+ *   pattern?: string;
+ *   params_shape?: Record<string, string>;
+ *   has_guard?: boolean;
+ *   has_load?: boolean;
+ *   guard_module_ref?: string | null;
+ *   load_module_ref?: string | null;
+ * }} PreviewRoute
+ */
+/**
+ * @param {string} distDir
+ * @returns {Promise<PreviewRoute[]>}
+ */
+export function loadRouteManifest(distDir: string): Promise<PreviewRoute[]>;
+export function loadRouteSurfaceState(distDir: any, fallbackBasePath?: string): Promise<{
+    basePath: string;
+    pageRoutes: any;
+    resourceRoutes: any[];
+}>;
+export const matchRoute: typeof matchManifestRoute;
+export type PreviewRoute = {
+    path: string;
+    output: string;
+    server_script?: string | null;
+    server_script_path?: string | null;
+    prerender?: boolean;
+    route_id?: string;
+    pattern?: string;
+    params_shape?: Record<string, string>;
+    has_guard?: boolean;
+    has_load?: boolean;
+    guard_module_ref?: string | null;
+    load_module_ref?: string | null;
+};
+import { matchRoute as matchManifestRoute } from '../server/resolve-request-route.js';

package/dist/preview/manifest.js

@@ -0,0 +1,57 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { normalizeBasePath } from '../base-path.js';
+import { loadResourceRouteManifest } from '../resource-manifest.js';
+import { compareRouteSpecificity, matchRoute as matchManifestRoute } from '../server/resolve-request-route.js';
+/**
+ * @typedef {{
+ *   path: string;
+ *   output: string;
+ *   server_script?: string | null;
+ *   server_script_path?: string | null;
+ *   prerender?: boolean;
+ *   route_id?: string;
+ *   pattern?: string;
+ *   params_shape?: Record<string, string>;
+ *   has_guard?: boolean;
+ *   has_load?: boolean;
+ *   guard_module_ref?: string | null;
+ *   load_module_ref?: string | null;
+ * }} PreviewRoute
+ */
+/**
+ * @param {string} distDir
+ * @returns {Promise<PreviewRoute[]>}
+ */
+export async function loadRouteManifest(distDir) {
+    const state = await loadRouteSurfaceState(distDir, '/');
+    return state.pageRoutes;
+}
+export async function loadRouteSurfaceState(distDir, fallbackBasePath = '/') {
+    const manifestPath = join(distDir, 'assets', 'router-manifest.json');
+    const resourceState = await loadResourceRouteManifest(distDir, normalizeBasePath(fallbackBasePath || '/'));
+    try {
+        const source = await readFile(manifestPath, 'utf8');
+        const parsed = JSON.parse(source);
+        const routes = Array.isArray(parsed?.routes) ? parsed.routes : [];
+        const basePath = normalizeBasePath(parsed?.base_path || resourceState.basePath || fallbackBasePath || '/');
+        return {
+            basePath,
+            pageRoutes: routes
+                .filter((entry) => entry &&
+                typeof entry === 'object' &&
+                typeof entry.path === 'string' &&
+                typeof entry.output === 'string')
+                .sort((a, b) => compareRouteSpecificity(a.path, b.path)),
+            resourceRoutes: Array.isArray(resourceState.routes) ? resourceState.routes : []
+        };
+    }
+    catch {
+        return {
+            basePath: normalizeBasePath(resourceState.basePath || fallbackBasePath || '/'),
+            pageRoutes: [],
+            resourceRoutes: Array.isArray(resourceState.routes) ? resourceState.routes : []
+        };
+    }
+}
+export const matchRoute = matchManifestRoute;

package/dist/preview/paths.d.ts

@@ -0,0 +1,3 @@
+export function toStaticFilePath(distDir: any, pathname: any): string | null;
+export function resolveWithinDist(distDir: any, requestPath: any): string | null;
+export function fileExists(fullPath: any): Promise<boolean>;