@zenithbuild/cli 0.7.11 → 0.7.12

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-server/request-handler.js

@@ -11,8 +11,18 @@ import { handleImageRequest } from '../images/service.js';
 import { resolveRequestRoute } from '../server/resolve-request-route.js';
 import { respondWithDevBuildError } from './build-error-response.js';
 import { handleRouteCheckRequest } from './route-check.js';
+function respondWithMiddlewareSourceError(res, error) {
+    logServerException('dev server route execution failed', error);
+    res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end(clientFacingRouteMessage(500));
+}
+function hasRouteScopedServerData(route) {
+    return route?.has_scoped_server_data === true &&
+        Array.isArray(route?.scoped_server_data) &&
+        route.scoped_server_data.length > 0;
+}
 export function createDevRequestHandler(options) {
-    const { outDir, projectRoot, imageConfig, configuredBasePath, routeCheckEnabled, isStaticExportTarget, logger, verboseLogging, buildSession, state, serverOrigin, loadRoutesForRequests, readFileForRequest, trace404, looksLikeJsonRequest, classifyNotFound, infer404Cause, buildNotFoundPayload, renderNotFoundHtml, appendSetCookieHeaders, MIME_TYPES, EVENT_STREAM_MIME, LEGACY_DEV_STREAM_PATH, IMAGE_RUNTIME_TAG_RE } = options;
+    const { outDir, projectRoot, imageConfig, configuredBasePath, routeCheckEnabled, isStaticExportTarget, logger, verboseLogging, buildSession, state, serverOrigin, loadRoutesForRequests, loadGlobalMiddlewareForRequests, readFileForRequest, trace404, looksLikeJsonRequest, classifyNotFound, infer404Cause, buildNotFoundPayload, renderNotFoundHtml, appendSetCookieHeaders, MIME_TYPES, EVENT_STREAM_MIME, LEGACY_DEV_STREAM_PATH, IMAGE_RUNTIME_TAG_RE } = options;
     return async function handleDevRequest(req, res) {
         const url = new URL(req.url, serverOrigin());
         const pathname = url.pathname;
@@ -205,6 +215,16 @@ export function createDevRequestHandler(options) {
             canonicalUrl.pathname = canonicalPath;
             const resolvedResource = resolveRequestRoute(canonicalUrl, routes.resourceRoutes || []);
             if (resolvedResource.matched && resolvedResource.route) {
+                let globalMiddleware = null;
+                try {
+                    globalMiddleware = loadGlobalMiddlewareForRequests
+                        ? await loadGlobalMiddlewareForRequests()
+                        : null;
+                }
+                catch (error) {
+                    respondWithMiddlewareSourceError(res, error);
+                    return;
+                }
                 const requestMethod = req.method || 'GET';
                 const requestBodyBuffer = requestMethod === 'GET' || requestMethod === 'HEAD'
                     ? null
@@ -220,7 +240,9 @@ export function createDevRequestHandler(options) {
                     routePattern: resolvedResource.route.path,
                     routeFile: resolvedResource.route.server_script_path || '',
                     routeId: resolvedResource.route.route_id || '',
-                    routeKind: 'resource'
+                    routeKind: 'resource',
+                    globalMiddlewareSource: globalMiddleware?.source || '',
+                    globalMiddlewareSourcePath: globalMiddleware?.sourcePath || ''
                 });
                 const descriptor = buildResourceResponseDescriptor(execution?.result, configuredBasePath, Array.isArray(execution?.setCookies) ? execution.setCookies : []);
                 res.writeHead(descriptor.status, appendSetCookieHeaders(descriptor.headers, descriptor.setCookies));
@@ -265,7 +287,19 @@ export function createDevRequestHandler(options) {
             }
             let ssrPayload = null;
             let routeExecution = null;
-            if (resolved.matched && resolved.route?.server_script && resolved.route.prerender !== true) {
+            if (resolved.matched &&
+                resolved.route?.prerender !== true &&
+                (resolved.route?.server_script || hasRouteScopedServerData(resolved.route))) {
+                let globalMiddleware = null;
+                try {
+                    globalMiddleware = loadGlobalMiddlewareForRequests
+                        ? await loadGlobalMiddlewareForRequests()
+                        : null;
+                }
+                catch (error) {
+                    respondWithMiddlewareSourceError(res, error);
+                    return;
+                }
                 try {
                     const requestMethod = req.method || 'GET';
                     const requestBodyBuffer = requestMethod === 'GET' || requestMethod === 'HEAD'
@@ -281,7 +315,15 @@ export function createDevRequestHandler(options) {
                         requestBodyBuffer,
                         routePattern: resolved.route.path,
                         routeFile: resolved.route.server_script_path || '',
-                        routeId: resolved.route.route_id || ''
+                        routeId: resolved.route.route_id || '',
+                        globalMiddlewareSource: globalMiddleware?.source || '',
+                        globalMiddlewareSourcePath: globalMiddleware?.sourcePath || '',
+                        scopedServerData: Array.isArray(resolved.route.scoped_server_data)
+                            ? resolved.route.scoped_server_data
+                            : [],
+                        scopedServerModuleSources: Array.isArray(resolved.route.scoped_server_modules)
+                            ? resolved.route.scoped_server_modules
+                            : []
                     });
                 }
                 catch (error) {

package/dist/dev-server.js

@@ -11,11 +11,15 @@
 // V0: Uses Node.js http module + fs.watch. No external deps.
 // ---------------------------------------------------------------------------
 import { createServer } from 'node:http';
+import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { basename, dirname, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { normalizeBasePath } from './base-path.js';
 import { resolveBuildAdapter } from './adapters/resolve-adapter.js';
 import { createDevBuildSession } from './dev-build-session.js';
+import { generateManifest } from './manifest.js';
+import { buildComponentRegistry } from './resolve-components.js';
 import { createStartupProfiler } from './startup-profile.js';
 import { createSilentLogger } from './ui/logger.js';
 import { createTrustedOriginResolver, publicHost } from './request-origin.js';
@@ -26,6 +30,8 @@ import { buildNotFoundPayload, classifyNotFound, infer404Cause, looksLikeJsonReq
 import { createDevRequestHandler } from './dev-server/request-handler.js';
 import { createDevWatcher } from './dev-server/watcher.js';
 import { listenWithPortFallback } from './dev-server/port-fallback.js';
+import { loadDevGlobalMiddlewareSource } from './global-middleware-runtime-source.js';
+const SCOPED_SERVER_DATA_LOWERING_HELPER_UNAVAILABLE = '[Zenith:ScopedServerData] Server-output lowering helper is unavailable. Run the CLI build step before packaging scoped server data modules.';
 const MIME_TYPES = {
     '.html': 'text/html',
     '.js': 'application/javascript',
@@ -42,6 +48,24 @@ const MIME_TYPES = {
 const IMAGE_RUNTIME_TAG_RE = new RegExp('<' + 'script\\b[^>]*\\bid=(["\'])zenith-image-runtime\\1[^>]*>[\\s\\S]*?<\\/' + 'script>', 'i');
 const EVENT_STREAM_MIME = ['text', 'event-stream'].join('/');
 const LEGACY_DEV_STREAM_PATH = ['/__zenith', '_hmr'].join('');
+let scopedServerDataLoweringPromise = null;
+function resolveScopedServerDataLoweringPath() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    return [
+        join(moduleDir, 'scoped-server-data', 'lowering.js'),
+        join(moduleDir, '..', 'dist', 'scoped-server-data', 'lowering.js')
+    ].find((candidate) => existsSync(candidate)) || null;
+}
+async function getScopedServerDataLowering() {
+    const helperPath = resolveScopedServerDataLoweringPath();
+    if (!helperPath) {
+        throw new Error(SCOPED_SERVER_DATA_LOWERING_HELPER_UNAVAILABLE);
+    }
+    if (!scopedServerDataLoweringPromise) {
+        scopedServerDataLoweringPromise = import(pathToFileURL(helperPath).href);
+    }
+    return scopedServerDataLoweringPromise;
+}
 function appendSetCookieHeaders(headers, setCookies = []) {
     if (Array.isArray(setCookies) && setCookies.length > 0) {
         headers['Set-Cookie'] = setCookies.slice();
@@ -65,6 +89,7 @@ export async function createDevServer(options) {
     const resolvedTarget = resolveBuildAdapter(config).target;
     const routeCheckEnabled = supportsTargetRouteCheck(resolvedTarget);
     const isStaticExportTarget = resolvedTarget === 'static-export';
+    const compilerOpts = { typescriptDefault: config.typescriptDefault === true, experimentalEmbeddedMarkup: config.embeddedMarkupExpressions === true, strictDomLints: config.strictDomLints === true };
     const resolvedPagesDir = resolve(pagesDir);
     const resolvedOutDir = resolve(outDir);
     const resolvedOutDirTmp = resolve(dirname(resolvedOutDir), `${basename(resolvedOutDir)}.tmp`);
@@ -178,8 +203,9 @@ export async function createDevServer(options) {
             const routeState = await loadRouteSurfaceState(outDir, configuredBasePath);
             if ((Array.isArray(routeState.pageRoutes) && routeState.pageRoutes.length > 0) ||
                 (Array.isArray(routeState.resourceRoutes) && routeState.resourceRoutes.length > 0)) {
-                state.currentRouteState = routeState;
-                return routeState;
+                const mergedRouteState = await _mergeDevScopedServerData(routeState);
+                state.currentRouteState = mergedRouteState;
+                return mergedRouteState;
             }
         }
         catch (error) {
@@ -190,6 +216,67 @@ export async function createDevServer(options) {
         }
         return state.currentRouteState;
     }
+    async function _mergeDevScopedServerData(routeState) {
+        const scopedByPath = await _loadDevScopedServerDataByPath();
+        if (scopedByPath.size === 0) {
+            return routeState;
+        }
+        return {
+            ...routeState,
+            pageRoutes: (Array.isArray(routeState.pageRoutes) ? routeState.pageRoutes : []).map((route) => {
+                const scoped = scopedByPath.get(route.path);
+                return scoped ? { ...route, ...scoped } : route;
+            })
+        };
+    }
+    async function _loadDevScopedServerDataByPath() {
+        const srcDir = resolve(resolvedPagesDir, '..');
+        const registry = buildComponentRegistry(srcDir);
+        const manifest = await generateManifest(resolvedPagesDir, '.zen', {
+            srcDir,
+            registry,
+            compilerOpts
+        });
+        const pageEntries = manifest.filter((entry) => entry?.route_kind !== 'resource' &&
+            entry?.has_scoped_server_data === true &&
+            Array.isArray(entry?.scoped_server_data) &&
+            entry.scoped_server_data.length > 0);
+        const scopedByPath = new Map();
+        if (pageEntries.length === 0) {
+            return scopedByPath;
+        }
+        const lowering = await getScopedServerDataLowering();
+        for (const entry of pageEntries) {
+            const pageFile = resolve(resolvedPagesDir, entry.file);
+            const pageSource = await readFile(pageFile, 'utf8');
+            const lowered = lowering.lowerRouteScopedServerData({
+                pageSource,
+                pageFile,
+                registry,
+                srcDir,
+                projectRoot,
+                compilerOpts,
+                scopedServerData: entry.scoped_server_data
+            });
+            scopedByPath.set(entry.path, {
+                has_scoped_server_data: true,
+                scoped_server_data: lowered.scopedServerData,
+                scoped_server_modules: lowered.modules.map((module) => ({
+                    module: module.module,
+                    source: module.source,
+                    sourcePath: module.sourcePath
+                }))
+            });
+        }
+        return scopedByPath;
+    }
+    async function _loadGlobalMiddlewareForRequests() {
+        return loadDevGlobalMiddlewareSource({
+            projectRoot,
+            pagesDir: resolvedPagesDir,
+            target: resolvedTarget
+        });
+    }
     function _broadcastEvent(type, payload = {}) {
         const eventBuildId = Number.isInteger(payload.buildId) ? payload.buildId : state.buildId;
         const data = JSON.stringify({
@@ -221,7 +308,7 @@ export async function createDevServer(options) {
             logger.build('Initial build (id=0)', { onceKey: 'dev-initial-build' });
             const initialBuild = await buildSession.build();
             const cssReady = await _syncCssStateFromBuild(initialBuild, state.buildId);
-            state.currentRouteState = await loadRouteSurfaceState(outDir, configuredBasePath);
+            state.currentRouteState = await _mergeDevScopedServerData(await loadRouteSurfaceState(outDir, configuredBasePath));
             state.buildStatus = 'ok';
             state.buildError = null;
             state.lastBuildMs = Date.now();
@@ -286,6 +373,7 @@ export async function createDevServer(options) {
         state,
         serverOrigin: _serverOrigin,
         loadRoutesForRequests: _loadRoutesForRequests,
+        loadGlobalMiddlewareForRequests: _loadGlobalMiddlewareForRequests,
         readFileForRequest: _readFileForRequest,
         trace404: _trace404,
         looksLikeJsonRequest,

package/dist/global-middleware-runtime-source.d.ts

@@ -0,0 +1,15 @@
+export function loadDevGlobalMiddlewareSource({ projectRoot, pagesDir, target }: {
+    projectRoot: any;
+    pagesDir: any;
+    target: any;
+}): Promise<{
+    source: string;
+    sourcePath: string;
+} | null>;
+export function loadPreviewGlobalMiddlewareSource({ projectRoot, distDir }: {
+    projectRoot: any;
+    distDir: any;
+}): Promise<{
+    source: string;
+    sourcePath: string;
+} | null>;

package/dist/global-middleware-runtime-source.js

@@ -0,0 +1,62 @@
+import { readFile } from 'node:fs/promises';
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
+import { resolveGlobalMiddleware, validateGlobalMiddlewareSource } from './global-middleware.js';
+const INVALID_PREVIEW_SOURCE_FILE = '[Zenith:Middleware] Invalid global middleware source_file in manifest.';
+function isWithinPath(root, candidate) {
+    const relativePath = relative(resolve(root), resolve(candidate));
+    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
+}
+function assertPreviewSourceFile(projectRoot, sourceFile) {
+    if (typeof sourceFile !== 'string' || sourceFile.length === 0 || !sourceFile.endsWith('.ts')) {
+        throw new Error(INVALID_PREVIEW_SOURCE_FILE);
+    }
+    const sourcePath = resolve(projectRoot, sourceFile);
+    if (!isWithinPath(projectRoot, sourcePath)) {
+        throw new Error(INVALID_PREVIEW_SOURCE_FILE);
+    }
+    return sourcePath;
+}
+function createReadError(sourceFile) {
+    return new Error(`[Zenith:Middleware] Cannot read global middleware source file "${sourceFile}".`);
+}
+async function readMiddlewareSource(sourcePath, sourceFile) {
+    try {
+        return await readFile(sourcePath, 'utf8');
+    }
+    catch {
+        throw createReadError(sourceFile);
+    }
+}
+export async function loadDevGlobalMiddlewareSource({ projectRoot, pagesDir, target }) {
+    const globalMiddleware = await resolveGlobalMiddleware({ projectRoot, pagesDir, target });
+    if (!globalMiddleware) {
+        return null;
+    }
+    const source = await readMiddlewareSource(globalMiddleware.sourcePath, globalMiddleware.sourceFile);
+    validateGlobalMiddlewareSource(source, globalMiddleware.sourceFile, projectRoot);
+    return {
+        source,
+        sourcePath: globalMiddleware.sourcePath
+    };
+}
+export async function loadPreviewGlobalMiddlewareSource({ projectRoot, distDir }) {
+    let manifest = null;
+    const manifestDir = basename(resolve(distDir)) === 'static' ? dirname(distDir) : distDir;
+    try {
+        manifest = JSON.parse(await readFile(join(manifestDir, 'manifest.json'), 'utf8'));
+    }
+    catch {
+        manifest = null;
+    }
+    const sourceFile = manifest?.global_middleware?.source_file;
+    if (!sourceFile) {
+        return null;
+    }
+    const sourcePath = assertPreviewSourceFile(projectRoot, sourceFile);
+    const source = await readMiddlewareSource(sourcePath, sourceFile);
+    validateGlobalMiddlewareSource(source, sourceFile, projectRoot);
+    return {
+        source,
+        sourcePath
+    };
+}

package/dist/global-middleware.d.ts

@@ -0,0 +1,13 @@
+export function validateGlobalMiddlewareSource(source: any, sourceFile: any, projectRoot?: string): void;
+export function normalizeGlobalMiddlewareMetadata(globalMiddleware: any): {
+    source_file: any;
+} | null;
+export function assertGlobalMiddlewareTargetSupported(target: any, globalMiddleware: any): void;
+export function resolveGlobalMiddleware({ projectRoot, pagesDir, target }?: {}): Promise<{
+    sourcePath: string;
+    sourceFile: string;
+    root: string;
+    metadata: {
+        source_file: any;
+    };
+} | null>;