@zenithbuild/cli 0.7.0 → 0.7.2

package/dist/adapters/adapter-vercel.js

@@ -0,0 +1,99 @@
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { compareRouteSpecificity } from '../server/resolve-request-route.js';
+import { createVercelBasePathAssetRoutes, createVercelRouteSource } from './route-rules.js';
+function buildVercelServerDest(route) {
+    const base = `/__zenith/${route.name}`;
+    if (!Array.isArray(route.params) || route.params.length === 0) {
+        return base;
+    }
+    const query = route.params.map((param, index) => `__zenith_param_${param}=$${index + 1}`).join('&');
+    return `${base}?${query}`;
+}
+function buildVercelConfig(buildManifest, serverRoutes) {
+    const routes = [...createVercelBasePathAssetRoutes(buildManifest.base_path)];
+    for (const route of [...serverRoutes].sort((left, right) => compareRouteSpecificity(left.path, right.path))) {
+        routes.push({
+            src: createVercelRouteSource(route.path, buildManifest.base_path),
+            dest: buildVercelServerDest(route)
+        });
+    }
+    routes.push({ handle: 'filesystem' });
+    for (const route of buildManifest.routes.filter((entry) => entry.render_mode === 'prerender' && entry.path_kind === 'dynamic')) {
+        routes.push({
+            src: createVercelRouteSource(route.path, buildManifest.base_path),
+            dest: route.html
+        });
+    }
+    return {
+        version: 3,
+        routes
+    };
+}
+function createFunctionSource(route) {
+    return [
+        "import { fileURLToPath } from 'node:url';",
+        "import { dirname, join } from 'node:path';",
+        "import { renderRouteRequest, extractInternalParams } from './runtime/route-render.js';",
+        '',
+        'const __dirname = dirname(fileURLToPath(import.meta.url));',
+        `const route = ${JSON.stringify(route, null, 2)};`,
+        '',
+        'export default {',
+        '  async fetch(request) {',
+        '    const params = extractInternalParams(request.url, route);',
+        '    return renderRouteRequest({',
+        '      request,',
+        '      route,',
+        '      params,',
+        "      routeModulePath: join(__dirname, 'route', 'entry.js'),",
+        "      shellHtmlPath: join(__dirname, 'route', 'page.html'),",
+        `      pageAssetPath: ${route.page_asset_file ? "join(__dirname, 'route', " + JSON.stringify(route.page_asset_file) + ')' : 'null'},`,
+        `      imageManifestPath: ${route.image_manifest_file ? "join(__dirname, 'route', " + JSON.stringify(route.image_manifest_file) + ')' : 'null'},`,
+        `      imageConfig: ${JSON.stringify(route.image_config || {}, null, 2)}`,
+        '    });',
+        '  }',
+        '};',
+        ''
+    ].join('\n');
+}
+async function loadServerManifest(coreOutput) {
+    try {
+        const parsed = JSON.parse(await readFile(join(coreOutput, 'server', 'manifest.json'), 'utf8'));
+        return Array.isArray(parsed.routes) ? parsed.routes : [];
+    }
+    catch {
+        return [];
+    }
+}
+export const vercelAdapter = {
+    name: 'vercel',
+    validateRoutes() { },
+    async adapt(options) {
+        const staticDir = join(options.coreOutput, 'static');
+        // Route meaning is fixed upstream in the manifest/server package.
+        // The adapter only maps already-classified output into Vercel's layout.
+        const serverRoutes = await loadServerManifest(options.coreOutput);
+        await rm(options.outDir, { recursive: true, force: true });
+        await mkdir(join(options.outDir, 'static'), { recursive: true });
+        await cp(staticDir, join(options.outDir, 'static'), { recursive: true, force: true });
+        for (const route of serverRoutes) {
+            const functionDir = join(options.outDir, 'functions', '__zenith', `${route.name}.func`);
+            await mkdir(functionDir, { recursive: true });
+            await cp(join(options.coreOutput, 'server', 'runtime'), join(functionDir, 'runtime'), { recursive: true, force: true });
+            await cp(join(options.coreOutput, 'server', 'images'), join(functionDir, 'images'), { recursive: true, force: true });
+            await cp(join(options.coreOutput, 'server', 'base-path.js'), join(functionDir, 'base-path.js'), { force: true });
+            await cp(join(options.coreOutput, 'server', 'server-contract.js'), join(functionDir, 'server-contract.js'), { force: true });
+            await cp(join(options.coreOutput, 'server', 'routes', route.name), functionDir, { recursive: true, force: true });
+            await writeFile(join(functionDir, 'package.json'), '{\n  "type": "module"\n}\n', 'utf8');
+            await writeFile(join(functionDir, 'index.js'), createFunctionSource(route), 'utf8');
+            await writeFile(join(functionDir, '.vc-config.json'), `${JSON.stringify({
+                runtime: 'nodejs22.x',
+                handler: 'index.js',
+                launcherType: 'Nodejs',
+                shouldAddHelpers: true
+            }, null, 2)}\n`, 'utf8');
+        }
+        await writeFile(join(options.outDir, 'config.json'), `${JSON.stringify(buildVercelConfig(options.manifest, serverRoutes), null, 2)}\n`, 'utf8');
+    }
+};

package/dist/adapters/resolve-adapter.d.ts

@@ -0,0 +1,5 @@
+export function resolveBuildAdapter(config?: {}): {
+    target: any;
+    adapter: any;
+    mode: string;
+};

package/dist/adapters/resolve-adapter.js

@@ -0,0 +1,84 @@
+import { isConfigKeyExplicit, isLoadedConfig } from '../config.js';
+import { netlifyAdapter } from './adapter-netlify.js';
+import { nodeAdapter } from './adapter-node.js';
+import { netlifyStaticAdapter } from './adapter-netlify-static.js';
+import { staticAdapter } from './adapter-static.js';
+import { KNOWN_TARGETS } from './adapter-types.js';
+import { vercelAdapter } from './adapter-vercel.js';
+import { vercelStaticAdapter } from './adapter-vercel-static.js';
+const LEGACY_ADAPTER = {
+    name: 'legacy',
+    validateRoutes() {
+        // Internal build() callers without loaded config stay on the pre-target contract.
+    },
+    adapt: staticAdapter.adapt
+};
+function validateAdapterShape(adapter) {
+    if (!adapter || typeof adapter !== 'object' || Array.isArray(adapter)) {
+        throw new Error('[Zenith:Config] Key "adapter" must be a plain object');
+    }
+    if (typeof adapter.name !== 'string' || adapter.name.trim().length === 0) {
+        throw new Error('[Zenith:Config] Key "adapter.name" must be a non-empty string');
+    }
+    if (typeof adapter.validateRoutes !== 'function') {
+        throw new Error('[Zenith:Config] Key "adapter.validateRoutes" must be a function');
+    }
+    if (typeof adapter.adapt !== 'function') {
+        throw new Error('[Zenith:Config] Key "adapter.adapt" must be a function');
+    }
+    return adapter;
+}
+function resolveTargetAdapter(target) {
+    if (target === 'static') {
+        return staticAdapter;
+    }
+    if (target === 'vercel-static') {
+        return vercelStaticAdapter;
+    }
+    if (target === 'netlify-static') {
+        return netlifyStaticAdapter;
+    }
+    if (target === 'vercel') {
+        return vercelAdapter;
+    }
+    if (target === 'netlify') {
+        return netlifyAdapter;
+    }
+    if (target === 'node') {
+        return nodeAdapter;
+    }
+    if (KNOWN_TARGETS.includes(target)) {
+        throw new Error(`[Zenith:Build] Target "${target}" is not supported yet.`);
+    }
+    throw new Error(`[Zenith:Config] Unsupported target: "${target}"`);
+}
+export function resolveBuildAdapter(config = {}) {
+    const targetExplicit = isConfigKeyExplicit(config, 'target');
+    const adapterExplicit = isConfigKeyExplicit(config, 'adapter') && config.adapter !== null && config.adapter !== undefined;
+    if (targetExplicit && adapterExplicit) {
+        throw new Error('[Zenith:Config] Keys "target" and "adapter" are mutually exclusive');
+    }
+    if (adapterExplicit) {
+        const adapter = validateAdapterShape(config.adapter);
+        return {
+            target: adapter.name,
+            adapter,
+            mode: 'adapter'
+        };
+    }
+    if (targetExplicit || isLoadedConfig(config)) {
+        const target = typeof config.target === 'string' && config.target.trim().length > 0
+            ? config.target.trim()
+            : 'static';
+        return {
+            target,
+            adapter: resolveTargetAdapter(target),
+            mode: 'target'
+        };
+    }
+    return {
+        target: 'legacy',
+        adapter: LEGACY_ADAPTER,
+        mode: 'legacy'
+    };
+}

package/dist/adapters/route-rules.d.ts

@@ -0,0 +1,7 @@
+export function createNetlifyBasePathAssetRules(basePath: any): string[];
+export function createNetlifyRewriteRules(route: any, basePath?: string): string[];
+export function createVercelBasePathAssetRoutes(basePath: any): {
+    src: string;
+    dest: string;
+}[];
+export function createVercelRouteSource(routePath: any, basePath?: string): string;

package/dist/adapters/route-rules.js

@@ -0,0 +1,88 @@
+import { normalizeBasePath, prependBasePath } from '../base-path.js';
+function splitRouteSegments(routePath) {
+    return String(routePath || '').split('/').filter(Boolean);
+}
+function escapeRegex(value) {
+    return String(value).replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&');
+}
+function buildNetlifyPatternSegment(segment) {
+    if (segment.startsWith(':')) {
+        return segment;
+    }
+    return segment;
+}
+export function createNetlifyBasePathAssetRules(basePath) {
+    const normalizedBasePath = normalizeBasePath(basePath);
+    if (normalizedBasePath === '/') {
+        return [];
+    }
+    return [
+        `${prependBasePath(normalizedBasePath, '/assets/*')} /assets/:splat 200`,
+        `${prependBasePath(normalizedBasePath, '/_zenith/image/local/*')} /_zenith/image/local/:splat 200`
+    ];
+}
+export function createNetlifyRewriteRules(route, basePath = '/') {
+    const segments = splitRouteSegments(route.path);
+    if (segments.length === 0) {
+        return [`${prependBasePath(basePath, '/')} ${route.html} 200`];
+    }
+    const terminal = segments[segments.length - 1];
+    const prefixSegments = segments.slice(0, -1).map(buildNetlifyPatternSegment);
+    const prefix = prefixSegments.length > 0 ? `/${prefixSegments.join('/')}` : '';
+    if (terminal.startsWith('*') && terminal.endsWith('?')) {
+        const exactPath = prefix || '/';
+        const splatPath = prefix ? `${prefix}/*` : '/*';
+        return [
+            `${prependBasePath(basePath, exactPath)} ${route.html} 200`,
+            `${prependBasePath(basePath, splatPath)} ${route.html} 200`
+        ];
+    }
+    if (terminal.startsWith('*')) {
+        const splatPath = prefix ? `${prefix}/*` : '/*';
+        return [`${prependBasePath(basePath, splatPath)} ${route.html} 200`];
+    }
+    const path = `/${segments.map(buildNetlifyPatternSegment).join('/')}`;
+    return [`${prependBasePath(basePath, path)} ${route.html} 200`];
+}
+export function createVercelBasePathAssetRoutes(basePath) {
+    const normalizedBasePath = normalizeBasePath(basePath);
+    if (normalizedBasePath === '/') {
+        return [];
+    }
+    const escaped = escapeRegex(normalizedBasePath);
+    return [
+        {
+            src: `^${escaped}/assets/(.+)$`,
+            dest: '/assets/$1'
+        },
+        {
+            src: `^${escaped}/_zenith/image/local/(.+)$`,
+            dest: '/_zenith/image/local/$1'
+        }
+    ];
+}
+export function createVercelRouteSource(routePath, basePath = '/') {
+    const segments = splitRouteSegments(routePath);
+    if (segments.length === 0) {
+        const rootPath = prependBasePath(basePath, '/');
+        return rootPath === '/' ? '^/?$' : `^${escapeRegex(rootPath)}/?$`;
+    }
+    let pattern = `^${escapeRegex(normalizeBasePath(basePath) === '/' ? '' : normalizeBasePath(basePath))}`;
+    for (const segment of segments) {
+        if (segment.startsWith(':')) {
+            pattern += '/([^/]+)';
+            continue;
+        }
+        if (segment.startsWith('*') && segment.endsWith('?')) {
+            pattern += '(?:/(.*))?';
+            continue;
+        }
+        if (segment.startsWith('*')) {
+            pattern += '/(.+)';
+            continue;
+        }
+        pattern += `/${escapeRegex(segment)}`;
+    }
+    pattern += '/?$';
+    return pattern;
+}

package/dist/base-path-html.d.ts

@@ -0,0 +1,2 @@
+export function rewriteSoftNavigationHrefBasePath(html: any, basePath: any): string;
+export function rewriteSoftNavigationHrefBasePathInHtmlFiles(rootDir: any, basePath: any): Promise<void>;

package/dist/base-path-html.js

@@ -0,0 +1,42 @@
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { prependBasePath } from './base-path.js';
+const SOFT_LINK_RE = /<a\b([^>]*\bdata-zen-link(?:=(["']).*?\2)?[^>]*)\bhref=(["'])(\/(?!\/)[^"']*)\3/gi;
+export function rewriteSoftNavigationHrefBasePath(html, basePath) {
+    return String(html || '').replace(SOFT_LINK_RE, (match, beforeHref, _attrQuote, hrefQuote, hrefValue) => {
+        const nextHref = prependBasePath(basePath, hrefValue);
+        if (nextHref === hrefValue) {
+            return match;
+        }
+        return `<a${beforeHref}href=${hrefQuote}${nextHref}${hrefQuote}`;
+    });
+}
+export async function rewriteSoftNavigationHrefBasePathInHtmlFiles(rootDir, basePath) {
+    async function walk(dir) {
+        let entries = [];
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            return;
+        }
+        entries.sort((left, right) => left.localeCompare(right));
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const info = await stat(fullPath);
+            if (info.isDirectory()) {
+                await walk(fullPath);
+                continue;
+            }
+            if (!entry.endsWith('.html')) {
+                continue;
+            }
+            const html = await readFile(fullPath, 'utf8');
+            const next = rewriteSoftNavigationHrefBasePath(html, basePath);
+            if (next !== html) {
+                await writeFile(fullPath, next, 'utf8');
+            }
+        }
+    }
+    await walk(rootDir);
+}

package/dist/base-path.d.ts

@@ -0,0 +1,8 @@
+export function normalizeBasePath(value: any): string;
+export function normalizePublicPath(pathname: any): string;
+export function prependBasePath(basePath: any, pathname?: string): string;
+export function stripBasePath(pathname: any, basePath: any): string | null;
+export function isWithinBasePath(pathname: any, basePath: any): boolean;
+export function appLocalRedirectLocation(location: any, basePath: any): string;
+export function routeCheckPath(basePath: any): string;
+export function imageEndpointPath(basePath: any): string;

package/dist/base-path.js

@@ -0,0 +1,74 @@
+const ROOT_BASE_PATH = '/';
+function normalizeLeadingSlash(value) {
+    const raw = String(value || '').trim();
+    if (!raw) {
+        return ROOT_BASE_PATH;
+    }
+    const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
+    return withLeadingSlash.replace(/\/{2,}/g, '/');
+}
+export function normalizeBasePath(value) {
+    const raw = String(value ?? ROOT_BASE_PATH).trim();
+    if (!raw || raw === ROOT_BASE_PATH) {
+        return ROOT_BASE_PATH;
+    }
+    if (raw.includes('?') || raw.includes('#')) {
+        throw new Error('[Zenith:Config] Key "basePath" must not include query or hash fragments');
+    }
+    if (!raw.startsWith('/')) {
+        throw new Error('[Zenith:Config] Key "basePath" must start with "/"');
+    }
+    const normalized = normalizeLeadingSlash(raw).replace(/\/+$/g, '');
+    return normalized || ROOT_BASE_PATH;
+}
+export function normalizePublicPath(pathname) {
+    const normalized = normalizeLeadingSlash(pathname);
+    if (normalized.length > 1) {
+        return normalized.replace(/\/+$/g, '');
+    }
+    return normalized;
+}
+export function prependBasePath(basePath, pathname = ROOT_BASE_PATH) {
+    const normalizedBasePath = normalizeBasePath(basePath);
+    const normalizedPath = normalizePublicPath(pathname);
+    if (normalizedBasePath === ROOT_BASE_PATH) {
+        return normalizedPath;
+    }
+    if (normalizedPath === ROOT_BASE_PATH) {
+        return normalizedBasePath;
+    }
+    if (normalizedPath === normalizedBasePath || normalizedPath.startsWith(`${normalizedBasePath}/`)) {
+        return normalizedPath;
+    }
+    return `${normalizedBasePath}${normalizedPath}`;
+}
+export function stripBasePath(pathname, basePath) {
+    const normalizedBasePath = normalizeBasePath(basePath);
+    const normalizedPath = normalizePublicPath(pathname);
+    if (normalizedBasePath === ROOT_BASE_PATH) {
+        return normalizedPath;
+    }
+    if (normalizedPath === normalizedBasePath) {
+        return ROOT_BASE_PATH;
+    }
+    if (normalizedPath.startsWith(`${normalizedBasePath}/`)) {
+        return normalizedPath.slice(normalizedBasePath.length) || ROOT_BASE_PATH;
+    }
+    return null;
+}
+export function isWithinBasePath(pathname, basePath) {
+    return stripBasePath(pathname, basePath) !== null;
+}
+export function appLocalRedirectLocation(location, basePath) {
+    const value = typeof location === 'string' ? location.trim() : '';
+    if (!value || !value.startsWith('/') || value.startsWith('//')) {
+        return value;
+    }
+    return prependBasePath(basePath, value);
+}
+export function routeCheckPath(basePath) {
+    return prependBasePath(basePath, '/__zenith/route-check');
+}
+export function imageEndpointPath(basePath) {
+    return prependBasePath(basePath, '/_zenith/image');
+}

package/dist/build/compiler-runtime.d.ts

@@ -42,7 +42,7 @@ export function createTimedCompilerRunner(startupProfile: ReturnType<typeof impo
  * @param {object | null} [logger]
  * @param {boolean} [showInfo]
  * @param {string|object} [bundlerBin]
- * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string }} [bundlerOptions]
+ * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string, basePath?: string }} [bundlerOptions]
  * @returns {Promise<void>}
  */
 export function runBundler(envelope: object | object[], outDir: string, projectRoot: string, logger?: object | null, showInfo?: boolean, bundlerBin?: string | object, bundlerOptions?: {
@@ -51,6 +51,7 @@ export function runBundler(envelope: object | object[], outDir: string, projectR
     changedRoutes?: string[];
     fastPath?: boolean;
     globalGraphHash?: string;
+    basePath?: string;
 }): Promise<void>;
 /**
  * @param {string} rootDir

package/dist/build/compiler-runtime.js

@@ -171,7 +171,7 @@ export function createTimedCompilerRunner(startupProfile, compilerTotals) {
  * @param {object | null} [logger]
  * @param {boolean} [showInfo]
  * @param {string|object} [bundlerBin]
- * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string }} [bundlerOptions]
+ * @param {{ devStableAssets?: boolean, rebuildStrategy?: 'full'|'bundle-only'|'page-only', changedRoutes?: string[], fastPath?: boolean, globalGraphHash?: string, basePath?: string }} [bundlerOptions]
  * @returns {Promise<void>}
  */
 export function runBundler(envelope, outDir, projectRoot, logger = null, showInfo = true, bundlerBin = resolveBundlerBin(projectRoot), bundlerOptions = {}) {
@@ -189,6 +189,9 @@ export function runBundler(envelope, outDir, projectRoot, logger = null, showInf
             '--out-dir',
             outDir
         ];
+        if (typeof bundlerOptions.basePath === 'string' && bundlerOptions.basePath.length > 0) {
+            bundlerArgs.push('--base-path', bundlerOptions.basePath);
+        }
         if (bundlerOptions.devStableAssets === true) {
             bundlerArgs.push('--dev-stable-assets');
         }

package/dist/build/page-loop.d.ts

@@ -6,7 +6,7 @@
  *   registry: Map<string, string>
  *   compilerOpts: object
  *   compilerBin: string|object
- *   softNavigationEnabled: boolean
+ *   routerEnabled: boolean
  *   startupProfile: ReturnType<import('../startup-profile.js').createStartupProfiler>
  *   compilerTotals: Record<string, number>
  *   emitCompilerWarning: (line: string) => void
@@ -23,7 +23,7 @@ export function buildPageEnvelopes(input: {
     registry: Map<string, string>;
     compilerOpts: object;
     compilerBin: string | object;
-    softNavigationEnabled: boolean;
+    routerEnabled: boolean;
     startupProfile: ReturnType<typeof import("../startup-profile.js").createStartupProfiler>;
     compilerTotals: Record<string, number>;
     emitCompilerWarning: (line: string) => void;

package/dist/build/page-loop.js

@@ -22,7 +22,7 @@ import { extractServerScript } from './server-script.js';
  *   registry: Map<string, string>
  *   compilerOpts: object
  *   compilerBin: string|object
- *   softNavigationEnabled: boolean
+ *   routerEnabled: boolean
  *   startupProfile: ReturnType<import('../startup-profile.js').createStartupProfiler>
  *   compilerTotals: Record<string, number>
  *   emitCompilerWarning: (line: string) => void
@@ -30,7 +30,7 @@ import { extractServerScript } from './server-script.js';
  * @returns {Promise<{ envelopes: object[], expressionRewriteMetrics: Record<string, number> }>}
  */
 export async function buildPageEnvelopes(input) {
-    const { manifest, pagesDir, srcDir, registry, compilerOpts, compilerBin, softNavigationEnabled, startupProfile, compilerTotals, emitCompilerWarning } = input;
+    const { manifest, pagesDir, srcDir, registry, compilerOpts, compilerBin, routerEnabled, startupProfile, compilerTotals, emitCompilerWarning } = input;
     const cacheState = input.pageLoopCaches || createPageLoopCaches();
     const executionState = createPageLoopExecutionState();
     const { componentIrCache, componentDocumentModeCache, componentExpressionRewriteCache, templateExpressionCache, hoistedCodeTransformCache } = cacheState;
@@ -182,7 +182,7 @@ export async function buildPageEnvelopes(input) {
             route: entry.path,
             file: sourceFile,
             ir: pageIr,
-            router: softNavigationEnabled
+            router: routerEnabled
         });
         recordPageProfile({
             pageProfiles,

package/dist/build-output-manifest.d.ts

@@ -0,0 +1,28 @@
+export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath }: {
+    coreOutputDir: any;
+    staticDir: any;
+    target: any;
+    routeManifest: any;
+    basePath?: string | undefined;
+}): Promise<{
+    schema_version: number;
+    zenith_version: any;
+    target: any;
+    base_path: string;
+    content_hash: any;
+    routes: {
+        path: any;
+        file: any;
+        path_kind: any;
+        render_mode: any;
+        requires_hydration: boolean;
+        params: any[];
+        html: any;
+        assets: any[];
+    }[];
+    assets: {
+        js: any[];
+        css: any[];
+        vendor: any;
+    };
+}>;

package/dist/build-output-manifest.js

@@ -0,0 +1,100 @@
+import { readFileSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const CLI_VERSION = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
+async function readJson(filePath, fallback) {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+function extractAssetRefs(html) {
+    const refs = new Set();
+    for (const match of html.matchAll(/<script\b[^>]*\bsrc="([^"]+)"/gi)) {
+        refs.add(String(match[1] || ''));
+    }
+    for (const match of html.matchAll(/<link\b[^>]*\brel="stylesheet"[^>]*\bhref="([^"]+)"/gi)) {
+        refs.add(String(match[1] || ''));
+    }
+    return [...refs]
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0)
+        .sort();
+}
+async function readRouteHtml(staticDir, htmlPath) {
+    try {
+        return await readFile(join(staticDir, htmlPath.replace(/^\//, '')), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+export async function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath = '/' }) {
+    const bundlerManifest = await readJson(join(staticDir, 'manifest.json'), {});
+    const routerManifest = await readJson(join(staticDir, 'assets', 'router-manifest.json'), { routes: [] });
+    const routeByPath = new Map((Array.isArray(routerManifest.routes) ? routerManifest.routes : []).map((entry) => [entry.path, entry]));
+    const routes = [];
+    const routeAssetJs = new Set();
+    const routeAssetCss = new Set();
+    for (const entry of routeManifest) {
+        const routeMeta = routeByPath.get(entry.path);
+        const htmlPath = typeof routeMeta?.output === 'string' ? routeMeta.output : '/index.html';
+        const html = await readRouteHtml(staticDir, htmlPath);
+        const assets = extractAssetRefs(html);
+        for (const asset of assets) {
+            if (asset.endsWith('.css')) {
+                routeAssetCss.add(asset);
+                continue;
+            }
+            if (asset.endsWith('.js')) {
+                routeAssetJs.add(asset);
+            }
+        }
+        routes.push({
+            path: entry.path,
+            file: entry.file,
+            path_kind: entry.path_kind,
+            render_mode: entry.render_mode,
+            requires_hydration: /<script\b[^>]*type="module"/i.test(html),
+            params: [...entry.params],
+            html: htmlPath,
+            assets
+        });
+    }
+    const jsAssets = new Set([
+        bundlerManifest.entry,
+        bundlerManifest.core,
+        bundlerManifest.router,
+        ...Object.values(bundlerManifest.chunks || {}),
+        ...routeAssetJs
+    ].filter((value) => typeof value === 'string' && value.endsWith('.js')));
+    const cssAssets = new Set([
+        bundlerManifest.css,
+        ...routeAssetCss
+    ].filter((value) => typeof value === 'string' && value.endsWith('.css')));
+    const buildManifest = {
+        schema_version: 1,
+        zenith_version: CLI_VERSION,
+        target,
+        base_path: basePath,
+        content_hash: typeof bundlerManifest.hash === 'string' ? bundlerManifest.hash : '',
+        routes,
+        assets: {
+            js: [...jsAssets].sort(),
+            css: [...cssAssets].sort(),
+            vendor: typeof bundlerManifest.vendor === 'string' ? bundlerManifest.vendor : null
+        }
+    };
+    await writeFile(join(coreOutputDir, 'manifest.json'), `${JSON.stringify(buildManifest, null, 2)}\n`, 'utf8');
+    return buildManifest;
+}