@zenithbuild/cli 0.7.10 → 0.7.12

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

@@ -1,15 +1,11 @@
-export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath }: {
+export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath, globalMiddleware }: {
     coreOutputDir: any;
     staticDir: any;
     target: any;
     routeManifest: any;
     basePath?: string | undefined;
+    globalMiddleware?: null | undefined;
 }): Promise<{
-    schema_version: number;
-    zenith_version: any;
-    target: any;
-    base_path: string;
-    content_hash: any;
     routes: {
         html: any;
         assets: any[];
@@ -26,4 +22,12 @@ export function writeBuildOutputManifest({ coreOutputDir, staticDir, target, rou
         css: any[];
         vendor: any;
     };
+    global_middleware?: {
+        source_file: any;
+    } | undefined;
+    schema_version: number;
+    zenith_version: any;
+    target: any;
+    base_path: string;
+    content_hash: any;
 }>;

package/dist/build-output-manifest.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { normalizeGlobalMiddlewareMetadata } from './global-middleware.js';
 const CLI_VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
@@ -39,7 +40,7 @@ async function readRouteHtml(staticDir, htmlPath) {
         return '';
     }
 }
-export async function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath = '/' }) {
+export async function writeBuildOutputManifest({ coreOutputDir, staticDir, target, routeManifest, basePath = '/', globalMiddleware = null }) {
     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]));
@@ -85,12 +86,14 @@ export async function writeBuildOutputManifest({ coreOutputDir, staticDir, targe
         bundlerManifest.css,
         ...routeAssetCss
     ].filter((value) => typeof value === 'string' && value.endsWith('.css')));
+    const globalMiddlewareMetadata = normalizeGlobalMiddlewareMetadata(globalMiddleware);
     const buildManifest = {
         schema_version: 1,
         zenith_version: CLI_VERSION,
         target,
         base_path: basePath,
         content_hash: typeof bundlerManifest.hash === 'string' ? bundlerManifest.hash : '',
+        ...(globalMiddlewareMetadata ? { global_middleware: globalMiddlewareMetadata } : {}),
         routes,
         assets: {
             js: [...jsAssets].sort(),

package/dist/build.js

@@ -16,6 +16,7 @@ import { createImageRuntimePayload, injectImageRuntimePayloadIntoHtmlFiles } fro
 import { supportsTargetRouteCheck } from './route-check-support.js';
 import { createStartupProfiler } from './startup-profile.js';
 import { writeServerOutput } from './server-output.js';
+import { resolveGlobalMiddleware } from './global-middleware.js';
 import { resolveBundlerBin } from './toolchain-paths.js';
 import { createBundlerToolchain, createCompilerToolchain, ensureToolchainCompatibility, getActiveToolchainCandidate } from './toolchain-runner.js';
 import { maybeWarnAboutZenithVersionMismatch } from './version-check.js';
@@ -75,6 +76,7 @@ export async function build(options) {
         }));
     }
     const registry = startupProfile.measureSync('build_component_registry', () => buildComponentRegistry(srcDir));
+    const globalMiddleware = await startupProfile.measureAsync('resolve_global_middleware', () => resolveGlobalMiddleware({ projectRoot, pagesDir, target }));
     const manifest = await startupProfile.measureAsync('generate_manifest', () => generateManifest(pagesDir, '.zen', { compilerOpts }));
     const pageManifest = manifest.filter((entry) => entry?.route_kind !== 'resource');
     if (mode !== 'legacy') {
@@ -136,14 +138,21 @@ export async function build(options) {
         staticDir: staticOutputDir,
         target,
         routeManifest: pageManifest,
-        basePath
+        basePath,
+        globalMiddleware: globalMiddleware?.metadata || null
     }));
     await startupProfile.measureAsync('write_server_output', () => writeServerOutput({
         coreOutputDir,
         staticDir: staticOutputDir,
         projectRoot,
         config,
-        basePath
+        basePath,
+        globalMiddleware: globalMiddleware?.metadata || null,
+        pageManifest,
+        pagesDir,
+        srcDir,
+        registry,
+        compilerOpts
     }));
     await startupProfile.measureAsync('adapt_output', () => adapter.adapt({ coreOutput: coreOutputDir, outDir, manifest: buildManifest, config }));
     const assets = await startupProfile.measureAsync('collect_assets', () => collectAssets(outDir));

package/dist/component-instance-ir.js

@@ -388,6 +388,7 @@ export function applyOccurrenceRewritePlans(pageIr, occurrencePlans, resolveBind
                     binding.state_index = resolved.state_index;
                     binding.component_instance = resolved.component_instance;
                     binding.component_binding = resolved.component_binding;
+                    binding.scoped_data_key = resolved.scoped_data_key;
                 }
             }
             exprCursor = found + 1;

package/dist/component-occurrences.d.ts

@@ -4,3 +4,12 @@ export function collectExpandedComponentOccurrences(source: any, registry: any,
     ownerPath: string;
     componentPath: string;
 }[];
+/**
+ * Unique layout/component `.zen` paths reachable from a page dependency graph.
+ *
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string} sourceFile
+ * @returns {string[]}
+ */
+export function collectReachableOwnerPaths(source: string, registry: Map<string, string>, sourceFile: string): string[];

package/dist/component-occurrences.js

@@ -10,6 +10,24 @@ export function collectExpandedComponentOccurrences(source, registry, sourceFile
     }, [], occurrences);
     return occurrences;
 }
+/**
+ * Unique layout/component `.zen` paths reachable from a page dependency graph.
+ *
+ * @param {string} source
+ * @param {Map<string, string>} registry
+ * @param {string} sourceFile
+ * @returns {string[]}
+ */
+export function collectReachableOwnerPaths(source, registry, sourceFile) {
+    const occurrences = collectExpandedComponentOccurrences(source, registry, sourceFile);
+    const paths = new Set();
+    for (const occurrence of occurrences) {
+        if (occurrence.componentPath) {
+            paths.add(occurrence.componentPath);
+        }
+    }
+    return [...paths];
+}
 function walkSource(source, registry, context, chain, occurrences) {
     let cursor = 0;
     while (cursor < source.length) {

package/dist/config-plugins.d.ts

@@ -0,0 +1,12 @@
+export function normalizePlugins(value: any): ({
+    name: any;
+    config: any;
+} | {
+    name: any;
+    config?: undefined;
+})[];
+export function assertPluginConfigPatch(value: any): void;
+export function cloneConfigValue(value: any, seen?: Map<any, any>): any;
+export function deepFreeze(value: any, seen?: Set<any>): any;
+export function pluginHookError(pluginName: any, hookName: any, error: any): Error;
+export const PLUGIN_CONFIG_PATCH_KEYS: Set<string>;

package/dist/config-plugins.js

@@ -0,0 +1,100 @@
+const PLUGIN_OBJECT_KEYS = new Set(['name', 'config']);
+const freezeObject = Object.freeze;
+export const PLUGIN_CONFIG_PATCH_KEYS = new Set([
+    'router',
+    'embeddedMarkupExpressions',
+    'typescriptDefault',
+    'strictDomLints',
+    'images',
+    'basePath',
+    'outDir'
+]);
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function describePlugin(index, plugin) {
+    if (plugin && typeof plugin === 'object' && typeof plugin.name === 'string' && plugin.name.trim()) {
+        return `"${plugin.name.trim()}"`;
+    }
+    return `at index ${index}`;
+}
+export function normalizePlugins(value) {
+    if (!Array.isArray(value)) {
+        throw new Error('[Zenith:Config] Key "plugins" must be an array');
+    }
+    const seen = new Set();
+    return value.map((plugin, index) => {
+        if (!isPlainObject(plugin)) {
+            throw new Error(`[Zenith:Config] Plugin at index ${index} must be a plain object`);
+        }
+        for (const key of Object.keys(plugin)) {
+            if (!PLUGIN_OBJECT_KEYS.has(key)) {
+                throw new Error(`[Zenith:Config] Plugin ${describePlugin(index, plugin)} uses unsupported key "${key}"`);
+            }
+        }
+        if (typeof plugin.name !== 'string' || plugin.name.trim().length === 0) {
+            throw new Error(`[Zenith:Config] Plugin at index ${index} must have a non-empty name`);
+        }
+        const name = plugin.name.trim();
+        if (seen.has(name)) {
+            throw new Error(`[Zenith:Config] Duplicate plugin name: "${name}"`);
+        }
+        seen.add(name);
+        if ('config' in plugin && typeof plugin.config !== 'function') {
+            throw new Error(`[Zenith:Config] Plugin "${name}" key "config" must be a function`);
+        }
+        return 'config' in plugin ? { name, config: plugin.config } : { name };
+    });
+}
+export function assertPluginConfigPatch(value) {
+    if (!isPlainObject(value)) {
+        throw new Error('config hook must return a plain object patch');
+    }
+    for (const key of Object.keys(value)) {
+        if (!PLUGIN_CONFIG_PATCH_KEYS.has(key)) {
+            throw new Error(`${key} is not patchable`);
+        }
+    }
+}
+export function cloneConfigValue(value, seen = new Map()) {
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    if (seen.has(value)) {
+        return seen.get(value);
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        seen.set(value, out);
+        for (const item of value) {
+            out.push(cloneConfigValue(item, seen));
+        }
+        return out;
+    }
+    const out = {};
+    seen.set(value, out);
+    for (const [key, child] of Object.entries(value)) {
+        out[key] = cloneConfigValue(child, seen);
+    }
+    return out;
+}
+export function deepFreeze(value, seen = new Set()) {
+    if (!value || (typeof value !== 'object' && typeof value !== 'function') || seen.has(value)) {
+        return value;
+    }
+    seen.add(value);
+    for (const key of Object.keys(value)) {
+        deepFreeze(value[key], seen);
+    }
+    return freezeObject(value);
+}
+export function pluginHookError(pluginName, hookName, error) {
+    const message = error && typeof error.message === 'string'
+        ? error.message
+        : String(error);
+    return new Error(`[Zenith plugin ${pluginName}] ${hookName} failed: ${message}`);
+}

package/dist/config.d.ts

@@ -27,4 +27,5 @@ export namespace DEFAULT_CONFIG {
         minimumCacheTTL: number;
         dangerouslyAllowLocalNetwork: boolean;
     };
+    let plugins: never[];
 }

package/dist/config.js

@@ -5,6 +5,7 @@ import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { KNOWN_TARGETS } from './adapters/adapter-types.js';
 import { normalizeBasePath } from './base-path.js';
+import { assertPluginConfigPatch, cloneConfigValue, deepFreeze, normalizePlugins, pluginHookError } from './config-plugins.js';
 import { normalizeImageConfig } from './images/shared.js';
 const PACKAGE_REQUIRE = createRequire(import.meta.url);
 const CONFIG_FILES = ['zenith.config.ts', 'zenith.config.js'];
@@ -19,7 +20,8 @@ export const DEFAULT_CONFIG = {
     target: 'static',
     adapter: null,
     strictDomLints: false,
-    images: normalizeImageConfig()
+    images: normalizeImageConfig(),
+    plugins: []
 };
 const TOP_LEVEL_SCHEMA = {
     router: 'boolean',
@@ -31,7 +33,8 @@ const TOP_LEVEL_SCHEMA = {
     target: 'string',
     adapter: 'object',
     strictDomLints: 'boolean',
-    images: 'object'
+    images: 'object',
+    plugins: 'array'
 };
 function attachConfigMeta(config, explicitKeys) {
     Object.defineProperty(config, CONFIG_META, {
@@ -160,7 +163,7 @@ export function resolveConfigOutDir(projectRoot, config) {
 }
 export function validateConfig(config) {
     if (config === null || config === undefined) {
-        return attachConfigMeta({ ...DEFAULT_CONFIG, images: normalizeImageConfig() }, []);
+        return attachConfigMeta({ ...DEFAULT_CONFIG, images: normalizeImageConfig(), plugins: [] }, []);
     }
     if (typeof config !== 'object' || Array.isArray(config)) {
         throw new Error('[Zenith:Config] Config must be a plain object');
@@ -175,7 +178,8 @@ export function validateConfig(config) {
     }
     const result = {
         ...DEFAULT_CONFIG,
-        images: normalizeImageConfig(DEFAULT_CONFIG.images)
+        images: normalizeImageConfig(DEFAULT_CONFIG.images),
+        plugins: []
     };
     for (const [key, expectedType] of Object.entries(TOP_LEVEL_SCHEMA)) {
         if (!(key in config)) {
@@ -190,6 +194,10 @@ export function validateConfig(config) {
             result.adapter = validateAdapterValue(value);
             continue;
         }
+        if (key === 'plugins') {
+            result.plugins = normalizePlugins(value);
+            continue;
+        }
         if (typeof value !== expectedType) {
             throw new Error(`[Zenith:Config] Key "${key}" must be ${expectedType}, got ${typeof value}`);
         }
@@ -207,6 +215,48 @@ export function validateConfig(config) {
     }
     return attachConfigMeta(result, Object.keys(config));
 }
+function normalizeConfigPatch(patch) {
+    assertPluginConfigPatch(patch);
+    const keys = Object.keys(patch);
+    const normalized = validateConfig(patch);
+    const out = {};
+    for (const key of keys) {
+        out[key] = cloneConfigValue(normalized[key]);
+    }
+    return out;
+}
+async function runPluginConfigHooks(config, projectRoot) {
+    let current = config;
+    for (const plugin of current.plugins) {
+        if (typeof plugin.config !== 'function') {
+            continue;
+        }
+        let patch;
+        try {
+            const snapshot = deepFreeze(cloneConfigValue(current));
+            patch = await plugin.config(snapshot, { projectRoot });
+        }
+        catch (error) {
+            throw pluginHookError(plugin.name, 'config', error);
+        }
+        if (patch === undefined || patch === null) {
+            continue;
+        }
+        let normalizedPatch;
+        try {
+            normalizedPatch = normalizeConfigPatch(patch);
+        }
+        catch (error) {
+            throw pluginHookError(plugin.name, 'config', error);
+        }
+        const explicitKeys = new Set(current?.[CONFIG_META]?.explicitKeys || []);
+        for (const key of Object.keys(normalizedPatch)) {
+            explicitKeys.add(key);
+        }
+        current = attachConfigMeta({ ...current, ...normalizedPatch, plugins: current.plugins }, explicitKeys);
+    }
+    return current;
+}
 export async function loadConfig(projectRoot) {
     const resolvedProjectRoot = resolve(projectRoot);
     const configPath = resolveConfigFile(resolvedProjectRoot);
@@ -216,5 +266,6 @@ export async function loadConfig(projectRoot) {
     const mod = configPath.endsWith('.ts')
         ? await importTypescriptConfig(configPath, resolvedProjectRoot)
         : await importJavascriptConfig(configPath, resolvedProjectRoot);
-    return markLoaded(validateConfig(mod.default || mod));
+    const config = validateConfig(mod.default || mod);
+    return markLoaded(await runPluginConfigHooks(config, resolvedProjectRoot));
 }

package/dist/dev-build-session/helpers.js

@@ -143,18 +143,38 @@ function collectTemplateClassSignature(envelope) {
     return [...classes].sort();
 }
 export function buildPageOnlyFastPathSignature(envelope) {
+    const ir = envelope.ir || {};
     return stableJson({
         route: envelope.route,
         router: envelope.router === true,
+        interactivityShape: {
+            requiresJs: envelope.requires_js === true,
+            signals: Array.isArray(ir.signals) ? ir.signals.length : 0,
+            refs: Array.isArray(ir.ref_bindings) ? ir.ref_bindings.length : 0,
+            events: Array.isArray(ir.event_bindings)
+                ? ir.event_bindings.map((entry) => [entry.index, entry.event]).sort()
+                : [],
+            markers: Array.isArray(ir.marker_bindings)
+                ? ir.marker_bindings.map((entry) => [entry.index, entry.kind]).sort()
+                : [],
+            componentInstances: Array.isArray(ir.component_instances) ? ir.component_instances.length : 0,
+            hoistedCode: Array.isArray(ir.hoisted?.code)
+                ? ir.hoisted.code.filter((entry) => String(entry || '').trim().length > 0).length
+                : 0,
+            hoistedState: Array.isArray(ir.hoisted?.state) ? ir.hoisted.state.length : 0,
+            hoistedSignals: Array.isArray(ir.hoisted?.signals) ? ir.hoisted.signals.length : 0
+        },
         assetContract: collectEnvelopeAssetContract(envelope),
         templateClassSignature: collectTemplateClassSignature(envelope),
-        styleBlocks: envelope.ir.style_blocks || [],
-        serverScript: envelope.ir.server_script || null,
-        prerender: envelope.ir.prerender === true,
-        hasGuard: envelope.ir.has_guard === true,
-        hasLoad: envelope.ir.has_load === true,
-        guardModuleRef: envelope.ir.guard_module_ref || null,
-        loadModuleRef: envelope.ir.load_module_ref || null
+        styleBlocks: ir.style_blocks || [],
+        serverScript: ir.server_script || null,
+        prerender: ir.prerender === true,
+        hasGuard: ir.has_guard === true,
+        hasLoad: ir.has_load === true,
+        hasAction: ir.has_action === true,
+        guardModuleRef: ir.guard_module_ref || null,
+        loadModuleRef: ir.load_module_ref || null,
+        actionModuleRef: ir.action_module_ref || null
     });
 }
 export function buildGlobalGraphHash(envelopes) {

package/dist/dev-build-session/session.js

@@ -5,10 +5,12 @@ import { collectAssets, runBundler } from '../build/compiler-runtime.js';
 import { buildPageEnvelopes } from '../build/page-loop.js';
 import { createPageLoopCaches } from '../build/page-loop-state.js';
 import { deriveProjectRootFromPagesDir, ensureZenithTypeDeclarations } from '../build/type-declarations.js';
+import { rewriteSoftNavigationHrefBasePathInHtmlFiles } from '../base-path-html.js';
 import { injectImageMaterializationIntoRouterManifest } from '../images/router-manifest.js';
 import { buildImageArtifacts } from '../images/service.js';
 import { materializeImageMarkupInHtmlFiles } from '../images/materialize.js';
 import { createImageRuntimePayload, injectImageRuntimePayloadIntoHtmlFiles } from '../images/payload.js';
+import { writeResourceRouteManifest } from '../resource-manifest.js';
 import { createStartupProfiler } from '../startup-profile.js';
 import { resolveBuildAdapter } from '../adapters/resolve-adapter.js';
 import { supportsTargetRouteCheck } from '../route-check-support.js';
@@ -34,6 +36,9 @@ export function createDevBuildSession(options) {
     };
     ensureToolchainCompatibility(bundlerBin);
     const state = createDevBuildState(config, basePath);
+    function pageManifestEntries() {
+        return state.manifest.filter((entry) => entry?.route_kind !== 'resource');
+    }
     async function syncImageState(startupProfile) {
         const { manifest } = await startupProfile.measureAsync('build_image_artifacts', () => buildImageArtifacts({
             projectRoot,
@@ -50,12 +55,13 @@ export function createDevBuildSession(options) {
     }
     async function runBundlerWithCachedEnvelopes(startupProfile, activeLogger, showBundlerInfo, bundlerOptions = {}) {
         const orderedEnvelopes = bundlerOptions.envelopesOverride
-            || orderEnvelopes(state.manifest, resolvedPagesDir, state.envelopeByFile);
+            || orderEnvelopes(pageManifestEntries(), resolvedPagesDir, state.envelopeByFile);
         if (!orderedEnvelopes || orderedEnvelopes.length === 0) {
             throw new Error('Dev rebuild cache is incomplete; full rebuild required.');
         }
         await startupProfile.measureAsync('run_bundler', () => runBundler(orderedEnvelopes, outDir, projectRoot, activeLogger, showBundlerInfo, bundlerBin, {
             routeCheck: routeCheckEnabled,
+            basePath,
             devStableAssets: true,
             rebuildStrategy: bundlerOptions.rebuildStrategy || 'full',
             changedRoutes: bundlerOptions.changedRoutes || [],
@@ -63,6 +69,7 @@ export function createDevBuildSession(options) {
             globalGraphHash: bundlerOptions.globalGraphHash || ''
         }), { envelopes: orderedEnvelopes.length });
         await startupProfile.measureAsync('inject_image_materialization_manifest', () => injectImageMaterializationIntoRouterManifest(outDir, orderedEnvelopes), { envelopes: orderedEnvelopes.length });
+        await startupProfile.measureAsync('rewrite_soft_navigation_base_path', () => rewriteSoftNavigationHrefBasePathInHtmlFiles(outDir, basePath));
         const assets = await startupProfile.measureAsync('collect_assets', () => collectAssets(outDir));
         return { assets, envelopeCount: orderedEnvelopes.length };
     }
@@ -78,14 +85,15 @@ export function createDevBuildSession(options) {
         });
         state.registry = startupProfile.measureSync('build_component_registry', () => buildComponentRegistry(srcDir));
         state.manifest = await startupProfile.measureAsync('generate_manifest', () => generateManifest(resolvedPagesDir));
+        const pageManifest = pageManifestEntries();
         await startupProfile.measureAsync('ensure_zenith_type_declarations', () => ensureZenithTypeDeclarations({
-            manifest: state.manifest,
+            manifest: pageManifest,
             pagesDir: resolvedPagesDir
         }));
         state.pageLoopCaches = createPageLoopCaches();
         const emitCompilerWarning = buildCompilerWarningEmitter(activeLogger);
         const { envelopes, expressionRewriteMetrics } = await buildPageEnvelopes({
-            manifest: state.manifest,
+            manifest: pageManifest,
             pagesDir: resolvedPagesDir,
             srcDir,
             registry: state.registry,
@@ -98,20 +106,21 @@ export function createDevBuildSession(options) {
             pageLoopCaches: state.pageLoopCaches
         });
         state.envelopeByFile = new Map(envelopes.map((entry) => [entry.file, entry]));
-        state.manifestEntryByPath = toManifestEntryMap(state.manifest, resolvedPagesDir);
+        state.manifestEntryByPath = toManifestEntryMap(pageManifest, resolvedPagesDir);
         state.pageOnlyFastPathSignatureByFile = new Map(envelopes.map((entry) => [entry.file, buildPageOnlyFastPathSignature(entry)]));
         state.globalGraphHash = buildGlobalGraphHash(envelopes);
         const { assets } = await runBundlerWithCachedEnvelopes(startupProfile, activeLogger, showBundlerInfo);
+        await startupProfile.measureAsync('write_resource_manifest', () => writeResourceRouteManifest(outDir, state.manifest, basePath));
         await syncImageState(startupProfile);
         startupProfile.emit('build_complete', {
-            pages: state.manifest.length,
+            pages: pageManifest.length,
             assets: assets.length,
             compilerTotals,
             expressionRewriteMetrics,
             strategy: 'full'
         });
         state.hasSuccessfulBuild = true;
-        return { pages: state.manifest.length, assets, strategy: 'full' };
+        return { pages: pageManifest.length, assets, strategy: 'full' };
     }
     async function runBundleOnlyBuild(activeLogger, showBundlerInfo) {
         const startupProfile = createStartupProfiler('cli-build');
@@ -120,7 +129,7 @@ export function createDevBuildSession(options) {
         const { assets } = await runBundlerWithCachedEnvelopes(startupProfile, activeLogger, showBundlerInfo, { rebuildStrategy: 'bundle-only' });
         await syncImageState(startupProfile);
         startupProfile.emit('build_complete', {
-            pages: state.manifest.length,
+            pages: pageManifestEntries().length,
             assets: assets.length,
             compilerTotals,
             expressionRewriteMetrics,
@@ -155,7 +164,7 @@ export function createDevBuildSession(options) {
             state.envelopeByFile.set(envelope.file, envelope);
             state.pageOnlyFastPathSignatureByFile.set(envelope.file, buildPageOnlyFastPathSignature(envelope));
         }
-        const orderedEnvelopes = orderEnvelopes(state.manifest, resolvedPagesDir, state.envelopeByFile);
+        const orderedEnvelopes = orderEnvelopes(pageManifestEntries(), resolvedPagesDir, state.envelopeByFile);
         if (!orderedEnvelopes || orderedEnvelopes.length === 0) {
             throw new Error('Dev rebuild cache is incomplete; full rebuild required.');
         }
@@ -169,14 +178,14 @@ export function createDevBuildSession(options) {
         });
         await syncImageState(startupProfile);
         startupProfile.emit('build_complete', {
-            pages: state.manifest.length,
+            pages: pageManifestEntries().length,
             assets: assets.length,
             compilerTotals,
             expressionRewriteMetrics,
             strategy: 'page-only',
             rebuiltPages: entries.length
         });
-        return { pages: state.manifest.length, assets, strategy: 'page-only', rebuiltPages: entries.length };
+        return { pages: pageManifestEntries().length, assets, strategy: 'page-only', rebuiltPages: entries.length };
     }
     return {
         async build(buildOptions = {}) {

package/dist/dev-server/build-error-response.d.ts

@@ -0,0 +1,21 @@
+export function buildDevErrorPayload({ pathname, state }: {
+    pathname: any;
+    state: any;
+}): {
+    kind: string;
+    requestedPath: any;
+    buildId: any;
+    pendingBuildId: any;
+    buildStatus: any;
+    error: {
+        message: string;
+    };
+    hint: string;
+};
+export function respondWithDevBuildError({ req, res, pathname, state, looksLikeJsonRequest }: {
+    req: any;
+    res: any;
+    pathname: any;
+    state: any;
+    looksLikeJsonRequest: any;
+}): void;

package/dist/dev-server/build-error-response.js

@@ -0,0 +1,48 @@
+function truncateMessage(message, limit = 1000) {
+    const value = String(message || 'Dev build failed.');
+    return value.length > limit ? `${value.slice(0, limit - 3)}...` : value;
+}
+function escapeHtml(value) {
+    return String(value)
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+export function buildDevErrorPayload({ pathname, state }) {
+    const message = truncateMessage(state.buildError?.message || 'Dev build failed.');
+    return {
+        kind: 'zenith_dev_build_failed',
+        requestedPath: pathname,
+        buildId: state.buildId,
+        pendingBuildId: state.pendingBuildId,
+        buildStatus: state.buildStatus,
+        error: { message },
+        hint: 'Fix the build error and save again.'
+    };
+}
+export function respondWithDevBuildError({ req, res, pathname, state, looksLikeJsonRequest }) {
+    const payload = buildDevErrorPayload({ pathname, state });
+    if (looksLikeJsonRequest(req, pathname)) {
+        res.writeHead(503, {
+            'Content-Type': 'application/json',
+            'Cache-Control': 'no-store',
+            'X-Zenith-Dev-Error': 'build-failed'
+        });
+        res.end(JSON.stringify(payload));
+        return;
+    }
+    res.writeHead(503, {
+        'Content-Type': 'text/html; charset=utf-8',
+        'Cache-Control': 'no-store',
+        'X-Zenith-Dev-Error': 'build-failed'
+    });
+    res.end([
+        '<!DOCTYPE html>',
+        '<html><head><meta charset="utf-8"><title>Zenith Dev Build Failed</title></head>',
+        '<body style="font-family: ui-monospace, SFMono-Regular, Menlo, monospace; padding: 20px; background: #101216; color: #e6edf3;">',
+        '<h1 style="margin-top:0;">Zenith Dev Build Failed</h1>',
+        `<pre style="white-space: pre-wrap; line-height: 1.5;">Requested: ${escapeHtml(pathname)}\nStatus: build failed\nError: ${escapeHtml(payload.error.message)}\nHint: ${escapeHtml(payload.hint)}</pre>`,
+        '</body></html>'
+    ].join(''));
+}

package/dist/dev-server/port-fallback.d.ts

@@ -0,0 +1,15 @@
+export function isPortConflict(error: any): any;
+export function listenWithPortFallback({ server, port, host, maxAttempts }: {
+    server: any;
+    port: any;
+    host: any;
+    maxAttempts?: number | undefined;
+}): Promise<{
+    port: any;
+    requestedPort: any;
+    portFallback: {
+        requestedPort: any;
+        occupiedPorts: any[];
+        finalPort: any;
+    } | null;
+}>;