@zenithbuild/cli 0.7.11 → 0.7.12

package/dist/global-middleware.js

@@ -0,0 +1,252 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, join, relative, resolve } from 'node:path';
+const PACKAGE_REQUIRE = createRequire(import.meta.url);
+const STATIC_MIDDLEWARE_TARGETS = new Set([
+    'static',
+    'static-export',
+    'vercel-static',
+    'netlify-static'
+]);
+function toPosixRelative(from, to) {
+    const relativePath = relative(from, to).replaceAll('\\', '/');
+    return relativePath || '.';
+}
+function middlewareError(sourceFile, message) {
+    return new Error(`[Zenith:Middleware] Invalid global middleware in ${sourceFile}: ${message}`);
+}
+function resolveTypeScriptApi(projectRoot) {
+    try {
+        const projectRequire = createRequire(join(projectRoot, '__zenith_middleware_parser__.js'));
+        return projectRequire('typescript');
+    }
+    catch {
+        try {
+            return PACKAGE_REQUIRE('typescript');
+        }
+        catch {
+            throw new Error('[Zenith:Middleware] Global middleware validation requires the `typescript` package to be installed.');
+        }
+    }
+}
+function hasModifier(ts, node, kind) {
+    return Boolean(node?.modifiers?.some((modifier) => modifier.kind === kind));
+}
+function isAllowedTypeOnlyNamedExport(ts, node) {
+    if (ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) {
+        return hasModifier(ts, node, ts.SyntaxKind.ExportKeyword)
+            && !hasModifier(ts, node, ts.SyntaxKind.DefaultKeyword);
+    }
+    if (ts.isExportDeclaration(node)) {
+        if (node.isTypeOnly) {
+            return true;
+        }
+        const elements = node.exportClause && ts.isNamedExports(node.exportClause)
+            ? node.exportClause.elements
+            : [];
+        return elements.length > 0 && elements.every((specifier) => specifier.isTypeOnly === true);
+    }
+    return false;
+}
+function unwrapExpression(ts, expression) {
+    let current = expression;
+    while (current && ts.isParenthesizedExpression(current)) {
+        current = current.expression;
+    }
+    return current;
+}
+function isFunctionLikeDefault(ts, expression) {
+    const unwrapped = unwrapExpression(ts, expression);
+    return ts.isFunctionExpression(unwrapped) || ts.isArrowFunction(unwrapped)
+        ? unwrapped
+        : null;
+}
+function propertyAccessPath(ts, node) {
+    const parts = [];
+    let current = node;
+    while (current && ts.isPropertyAccessExpression(current)) {
+        parts.unshift(current.name.text);
+        current = current.expression;
+    }
+    if (current && ts.isIdentifier(current)) {
+        parts.unshift(current.text);
+    }
+    return parts;
+}
+function hasCommonJsExport(ts, node) {
+    let found = false;
+    function visit(current) {
+        if (found) {
+            return;
+        }
+        if (ts.isBinaryExpression(current)
+            && current.operatorToken.kind === ts.SyntaxKind.EqualsToken
+            && ts.isPropertyAccessExpression(current.left)) {
+            const parts = propertyAccessPath(ts, current.left);
+            if (parts[0] === 'module' && parts[1] === 'exports') {
+                found = true;
+                return;
+            }
+            if (parts[0] === 'exports') {
+                found = true;
+                return;
+            }
+        }
+        ts.forEachChild(current, visit);
+    }
+    ts.forEachChild(node, visit);
+    return found;
+}
+function assertTwoNonRestParams(fn, sourceFile) {
+    const params = Array.isArray(fn?.parameters) ? fn.parameters : [];
+    const hasRest = params.some((param) => param.dotDotDotToken);
+    if (params.length !== 2 || hasRest) {
+        throw middlewareError(sourceFile, 'default function must accept exactly two arguments: ctx and next.');
+    }
+}
+export function validateGlobalMiddlewareSource(source, sourceFile, projectRoot = process.cwd()) {
+    const ts = resolveTypeScriptApi(projectRoot);
+    const parsed = ts.createSourceFile(sourceFile, String(source || ''), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    if (parsed.parseDiagnostics.length > 0) {
+        throw middlewareError(sourceFile, 'unable to parse middleware module.');
+    }
+    if (hasCommonJsExport(ts, parsed)) {
+        throw middlewareError(sourceFile, 'CommonJS middleware exports are not supported. Use `export default function middleware(ctx, next) { ... }`.');
+    }
+    let defaultExportCount = 0;
+    let defaultFunction = null;
+    let defaultExportWasNonFunction = false;
+    let hasNamedRuntimeExport = false;
+    for (const statement of parsed.statements) {
+        if (ts.isExportDeclaration(statement)) {
+            if (!isAllowedTypeOnlyNamedExport(ts, statement)) {
+                hasNamedRuntimeExport = true;
+            }
+            continue;
+        }
+        if (ts.isExportAssignment(statement)) {
+            if (statement.isExportEquals) {
+                throw middlewareError(sourceFile, 'CommonJS middleware exports are not supported. Use `export default function middleware(ctx, next) { ... }`.');
+            }
+            defaultExportCount += 1;
+            const fn = isFunctionLikeDefault(ts, statement.expression);
+            if (fn) {
+                defaultFunction = fn;
+            }
+            else {
+                defaultExportWasNonFunction = true;
+            }
+            continue;
+        }
+        const hasExport = hasModifier(ts, statement, ts.SyntaxKind.ExportKeyword);
+        if (!hasExport) {
+            continue;
+        }
+        const hasDefault = hasModifier(ts, statement, ts.SyntaxKind.DefaultKeyword);
+        if (hasDefault) {
+            defaultExportCount += 1;
+            if (ts.isFunctionDeclaration(statement)) {
+                defaultFunction = statement;
+            }
+            else {
+                defaultExportWasNonFunction = true;
+            }
+            continue;
+        }
+        if (!isAllowedTypeOnlyNamedExport(ts, statement)) {
+            hasNamedRuntimeExport = true;
+        }
+    }
+    if (hasNamedRuntimeExport) {
+        throw middlewareError(sourceFile, 'named runtime exports are not supported. Export only `default function middleware(ctx, next)`.');
+    }
+    if (defaultExportCount !== 1) {
+        throw middlewareError(sourceFile, 'expected exactly one default export function.');
+    }
+    if (!defaultFunction || defaultExportWasNonFunction) {
+        throw middlewareError(sourceFile, 'default export must be a function. Use `export default function middleware(ctx, next) { ... }`.');
+    }
+    assertTwoNonRestParams(defaultFunction, sourceFile);
+}
+async function findNestedMiddlewareFiles(dir, projectRoot) {
+    const matches = [];
+    let entries;
+    try {
+        entries = await readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return matches;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (entry.name === 'middleware' && existsSync(join(fullPath, 'index.ts'))) {
+                matches.push(join(fullPath, 'index.ts'));
+            }
+            matches.push(...await findNestedMiddlewareFiles(fullPath, projectRoot));
+            continue;
+        }
+        if (entry.isFile() && entry.name === 'middleware.ts') {
+            matches.push(fullPath);
+        }
+    }
+    return matches.sort((left, right) => (toPosixRelative(projectRoot, left).localeCompare(toPosixRelative(projectRoot, right))));
+}
+function createMetadata(sourceFile) {
+    return { source_file: sourceFile };
+}
+export function normalizeGlobalMiddlewareMetadata(globalMiddleware) {
+    const sourceFile = typeof globalMiddleware?.source_file === 'string'
+        ? globalMiddleware.source_file
+        : typeof globalMiddleware?.sourceFile === 'string'
+            ? globalMiddleware.sourceFile
+            : null;
+    return sourceFile ? createMetadata(sourceFile) : null;
+}
+export function assertGlobalMiddlewareTargetSupported(target, globalMiddleware) {
+    if (!globalMiddleware || !STATIC_MIDDLEWARE_TARGETS.has(target)) {
+        return;
+    }
+    throw new Error(`[Zenith:Middleware] target "${target}" cannot use global middleware. ` +
+        'Global middleware requires a server-capable target ("node", "vercel", or "netlify"). ' +
+        `File: ${globalMiddleware.sourceFile}.`);
+}
+export async function resolveGlobalMiddleware({ projectRoot, pagesDir, target } = {}) {
+    const resolvedProjectRoot = resolve(projectRoot || process.cwd());
+    const resolvedPagesDir = resolve(resolvedProjectRoot, pagesDir || 'pages');
+    const middlewareRoot = dirname(resolvedPagesDir);
+    const rootCandidates = [
+        join(middlewareRoot, 'middleware.ts'),
+        join(middlewareRoot, 'middleware', 'index.ts')
+    ].filter((candidate) => existsSync(candidate));
+    if (rootCandidates.length > 1) {
+        throw new Error(`[Zenith:Middleware] Multiple global middleware files found in "${middlewareRoot}". ` +
+            'Keep exactly one of: middleware.ts, middleware/index.ts.');
+    }
+    const nestedMatches = await findNestedMiddlewareFiles(resolvedPagesDir, resolvedProjectRoot);
+    if (nestedMatches.length > 0) {
+        const relativePath = toPosixRelative(resolvedProjectRoot, nestedMatches[0]);
+        const middlewareRootRelative = toPosixRelative(resolvedProjectRoot, middlewareRoot);
+        const targetPath = middlewareRootRelative === '.'
+            ? 'middleware.ts'
+            : `${middlewareRootRelative}/middleware.ts`;
+        throw new Error('[Zenith:Middleware] Nested middleware files are not supported in V1. ' +
+            `Move "${relativePath}" to "${targetPath}" or remove it.`);
+    }
+    if (rootCandidates.length === 0) {
+        return null;
+    }
+    const sourcePath = rootCandidates[0];
+    const sourceFile = toPosixRelative(resolvedProjectRoot, sourcePath);
+    const globalMiddleware = {
+        sourcePath,
+        sourceFile,
+        root: middlewareRoot,
+        metadata: createMetadata(sourceFile)
+    };
+    assertGlobalMiddlewareTargetSupported(target, globalMiddleware);
+    validateGlobalMiddlewareSource(await readFile(sourcePath, 'utf8'), sourceFile, resolvedProjectRoot);
+    return globalMiddleware;
+}

package/dist/manifest.d.ts

@@ -1,3 +1,5 @@
+export function analyzeRouteScopedServerMetadata(options: import("./scoped-server-data/types.js").AnalyzeRouteScopedServerMetadataOptions): import("./scoped-server-data/types.js").AnalyzeRouteScopedServerMetadataResult;
+export function assertNoScopedServerBuildErrors(diagnostics: import("./scoped-server-data/types.js").ScopedServerDiagnostic[], contextFile: string): void;
 /**
  * @typedef {{
  *   path: string,
@@ -11,6 +13,8 @@
  *   has_guard?: boolean,
  *   has_load?: boolean,
  *   has_action?: boolean,
+ *   has_scoped_server_data?: boolean,
+ *   scoped_server_data?: import('./scoped-server-data/types.js').ManifestScopedServerDataEntry[],
  *   export_paths?: string[]
  * }} ManifestEntry
  */
@@ -19,11 +23,13 @@
  *
  * @param {string} pagesDir - Absolute path to /pages directory
  * @param {string} [extension='.zen'] - File extension to scan for
- * @param {{ compilerOpts?: object }} [options]
+ * @param {{ compilerOpts?: object, srcDir?: string, registry?: Map<string, string> }} [options]
  * @returns {Promise<ManifestEntry[]>}
  */
 export function generateManifest(pagesDir: string, extension?: string, options?: {
     compilerOpts?: object;
+    srcDir?: string;
+    registry?: Map<string, string>;
 }): Promise<ManifestEntry[]>;
 /**
  * Generate a JavaScript module string from manifest entries.
@@ -45,5 +51,7 @@ export type ManifestEntry = {
     has_guard?: boolean;
     has_load?: boolean;
     has_action?: boolean;
+    has_scoped_server_data?: boolean;
+    scoped_server_data?: import("./scoped-server-data/types.js").ManifestScopedServerDataEntry[];
     export_paths?: string[];
 };

package/dist/manifest.js

@@ -1,27 +1,41 @@
-// ---------------------------------------------------------------------------
-// manifest.js — Zenith CLI V0
-// ---------------------------------------------------------------------------
-// File-based manifest engine.
-//
-// Scans a /pages directory and produces a deterministic RouteManifest.
-//
-// Rules:
-//   - index.zen → parent directory path
-//   - [param].zen → :param dynamic segment
-//   - [...slug].zen → *slug catch-all segment (must be terminal, 1+ segments;
-//                     root '/*slug' may match '/' in router matcher)
-//   - [[...slug]].zen → *slug? optional catch-all segment (must be terminal, 0+ segments)
-//   - Deterministic precedence: static > :param > *catchall
-//   - Tie-breaker: lexicographic route path
-// ---------------------------------------------------------------------------
-import { readFileSync } from 'node:fs';
+// File-based manifest engine. Scans /pages and produces deterministic RouteManifest entries.
+// Rules: static > :param > *catchall, then lexicographic tie-breaker.
+import { readFileSync, existsSync } from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
 import { join, relative, sep, basename, extname, dirname, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 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';
 import { classifyPageRoute } from './route-classification.js';
+import { buildComponentRegistry } from './resolve-components.js';
+const SCOPED_SERVER_DATA_HELPER_UNAVAILABLE = '[Zenith:ScopedServerData] Manifest integration helper is unavailable. Run the CLI build step before using scoped server data manifest integration.';
+function resolveManifestIntegrationPath() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    return [
+        join(moduleDir, 'scoped-server-data', 'manifest-integration.js'),
+        join(moduleDir, '..', 'dist', 'scoped-server-data', 'manifest-integration.js')
+    ].find((candidate) => existsSync(candidate)) || null;
+}
+const manifestIntegrationPath = resolveManifestIntegrationPath();
+const manifestIntegration = manifestIntegrationPath
+    ? await import(pathToFileURL(manifestIntegrationPath).href)
+    : null;
+function getManifestIntegration() {
+    if (!manifestIntegration) {
+        throw new Error(SCOPED_SERVER_DATA_HELPER_UNAVAILABLE);
+    }
+    return manifestIntegration;
+}
+/** @type {typeof import('./scoped-server-data/manifest-integration.js').analyzeRouteScopedServerMetadata} */
+export function analyzeRouteScopedServerMetadata(options) {
+    return getManifestIntegration().analyzeRouteScopedServerMetadata(options);
+}
+/** @type {typeof import('./scoped-server-data/manifest-integration.js').assertNoScopedServerBuildErrors} */
+export function assertNoScopedServerBuildErrors(diagnostics, contextFile) {
+    return getManifestIntegration().assertNoScopedServerBuildErrors(diagnostics, contextFile);
+}
 /**
  * @typedef {{
  *   path: string,
@@ -35,6 +49,8 @@ import { classifyPageRoute } from './route-classification.js';
  *   has_guard?: boolean,
  *   has_load?: boolean,
  *   has_action?: boolean,
+ *   has_scoped_server_data?: boolean,
+ *   scoped_server_data?: import('./scoped-server-data/types.js').ManifestScopedServerDataEntry[],
  *   export_paths?: string[]
  * }} ManifestEntry
  */
@@ -43,11 +59,15 @@ import { classifyPageRoute } from './route-classification.js';
  *
  * @param {string} pagesDir - Absolute path to /pages directory
  * @param {string} [extension='.zen'] - File extension to scan for
- * @param {{ compilerOpts?: object }} [options]
+ * @param {{ compilerOpts?: object, srcDir?: string, registry?: Map<string, string> }} [options]
  * @returns {Promise<ManifestEntry[]>}
  */
 export async function generateManifest(pagesDir, extension = '.zen', options = {}) {
-    const entries = await _scanDir(pagesDir, pagesDir, extension, options.compilerOpts || {});
+    const resolvedPagesDir = resolve(pagesDir);
+    const srcDir = resolve(options.srcDir || resolve(resolvedPagesDir, '..'));
+    const registry = options.registry || buildComponentRegistry(srcDir);
+    const scanContext = { srcDir, registry, compilerOpts: options.compilerOpts || {} };
+    const entries = await _scanDir(resolvedPagesDir, resolvedPagesDir, extension, scanContext);
     const apiAliasState = _resolveSrcApiAliasState(pagesDir);
     if (apiAliasState) {
         const aliasEntries = await _scanResourceDir(apiAliasState.aliasDir, apiAliasState.srcDir);
@@ -69,7 +89,7 @@ export async function generateManifest(pagesDir, extension = '.zen', options = {
  * @param {string} ext - Extension to match
  * @returns {Promise<ManifestEntry[]>}
  */
-async function _scanDir(dir, root, ext, compilerOpts) {
+async function _scanDir(dir, root, ext, scanContext) {
     /** @type {ManifestEntry[]} */
     const entries = [];
     let items;
@@ -85,7 +105,7 @@ async function _scanDir(dir, root, ext, compilerOpts) {
         const fullPath = join(dir, item);
         const info = await stat(fullPath);
         if (info.isDirectory()) {
-            const nested = await _scanDir(fullPath, root, ext, compilerOpts);
+            const nested = await _scanDir(fullPath, root, ext, scanContext);
             entries.push(...nested);
         }
         else if (item.endsWith(ext)) {
@@ -94,7 +114,7 @@ async function _scanDir(dir, root, ext, compilerOpts) {
                 fullPath,
                 root,
                 routePath,
-                compilerOpts
+                scanContext
             }));
         }
         else if (isResourceRouteFile(item)) {
@@ -143,7 +163,8 @@ function _resolveSrcApiAliasState(pagesDir) {
         srcDir
     };
 }
-function buildPageManifestEntry({ fullPath, root, routePath, compilerOpts }) {
+function buildPageManifestEntry({ fullPath, root, routePath, scanContext }) {
+    const { srcDir, registry, compilerOpts } = scanContext;
     const rawSource = readFileSync(fullPath, 'utf8');
     const inlineServerScript = extractServerScript(rawSource, fullPath, compilerOpts).serverScript;
     const { guardPath, loadPath, actionPath } = resolveAdjacentServerModules(fullPath);
@@ -154,20 +175,39 @@ function buildPageManifestEntry({ fullPath, root, routePath, compilerOpts }) {
         adjacentLoadPath: loadPath,
         adjacentActionPath: actionPath
     });
+    const scopedMetadata = analyzeRouteScopedServerMetadata({
+        pageSource: rawSource,
+        pageFile: fullPath,
+        registry,
+        srcDir,
+        compilerOpts
+    });
+    const manifestFile = relative(root, fullPath);
+    assertNoScopedServerBuildErrors(scopedMetadata.diagnostics, manifestFile);
     const exportPaths = Array.isArray(composed.serverScript?.export_paths)
         ? validateStaticExportPaths(routePath, composed.serverScript.export_paths, fullPath)
         : [];
     const classification = classifyPageRoute({
-        file: relative(root, fullPath),
-        serverScript: composed.serverScript
+        file: manifestFile,
+        serverScript: composed.serverScript,
+        hasScopedServerData: scopedMetadata.hasScopedServerData
     });
     return {
         path: routePath,
-        file: relative(root, fullPath),
+        file: manifestFile,
         route_kind: 'page',
         path_kind: _isDynamic(routePath) ? 'dynamic' : 'static',
         render_mode: classification.renderMode,
         params: extractRouteParams(routePath),
+        has_guard: classification.hasGuard,
+        has_load: classification.hasLoad,
+        has_action: classification.hasAction,
+        ...(scopedMetadata.hasScopedServerData
+            ? {
+                has_scoped_server_data: true,
+                scoped_server_data: scopedMetadata.scopedServerData
+            }
+            : {}),
         ...(exportPaths.length > 0 ? { export_paths: exportPaths } : {})
     };
 }

package/dist/preview/request-handler.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { extname, join } from 'node:path';
+import { dirname, extname, join } from 'node:path';
 import { appLocalRedirectLocation, imageEndpointPath, routeCheckPath, stripBasePath } from '../base-path.js';
 import { materializeImageMarkup } from '../images/materialize.js';
 import { createImageRuntimePayload, injectImageRuntimePayload } from '../images/payload.js';
@@ -8,6 +8,7 @@ import { readRequestBodyBuffer } from '../request-body.js';
 import { buildResourceResponseDescriptor } from '../resource-response.js';
 import { clientFacingRouteMessage, logServerException, sanitizeRouteResult } from '../server-error.js';
 import { resolveRequestRoute } from '../server/resolve-request-route.js';
+import { loadPreviewGlobalMiddlewareSource } from '../global-middleware-runtime-source.js';
 import { loadRouteSurfaceState } from './manifest.js';
 import { injectSsrPayload } from './payload.js';
 import { fileExists, resolveWithinDist, toStaticFilePath } from './paths.js';
@@ -32,6 +33,47 @@ function appendSetCookieHeaders(headers, setCookies = []) {
     }
     return headers;
 }
+function respondWithMiddlewareSourceError(res, error) {
+    logServerException('preview 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;
+}
+async function loadPreviewScopedServerRoutes(serverModuleBaseDir) {
+    try {
+        const parsed = JSON.parse(await readFile(join(serverModuleBaseDir, 'manifest.json'), 'utf8'));
+        return Array.isArray(parsed?.routes) ? parsed.routes : [];
+    }
+    catch {
+        return [];
+    }
+}
+function mergePreviewScopedServerRoutes(routeState, serverRoutes) {
+    const scopedByPath = new Map((Array.isArray(serverRoutes) ? serverRoutes : [])
+        .filter((route) => hasRouteScopedServerData(route))
+        .map((route) => [route.path, route]));
+    if (scopedByPath.size === 0) {
+        return routeState;
+    }
+    return {
+        ...routeState,
+        pageRoutes: (Array.isArray(routeState.pageRoutes) ? routeState.pageRoutes : []).map((route) => {
+            const scoped = scopedByPath.get(route.path);
+            if (!scoped) {
+                return route;
+            }
+            return {
+                ...route,
+                has_scoped_server_data: true,
+                scoped_server_data: scoped.scoped_server_data
+            };
+        })
+    };
+}
 export function createPreviewRequestHandler(options) {
     const { distDir, projectRoot, config, logger, verboseLogging, configuredBasePath, routeCheckEnabled, isStaticExportTarget, serverOrigin } = options;
     async function loadImageManifest() {
@@ -44,9 +86,14 @@ export function createPreviewRequestHandler(options) {
             return {};
         }
     }
+    async function loadGlobalMiddlewareForRoute() {
+        return loadPreviewGlobalMiddlewareSource({ projectRoot, distDir });
+    }
     return async function previewRequestHandler(req, res) {
         const url = new URL(req.url, serverOrigin());
-        const { basePath, pageRoutes, resourceRoutes } = await loadRouteSurfaceState(distDir, configuredBasePath);
+        const serverModuleBaseDir = join(dirname(distDir), 'server');
+        const routeState = mergePreviewScopedServerRoutes(await loadRouteSurfaceState(distDir, configuredBasePath), await loadPreviewScopedServerRoutes(serverModuleBaseDir));
+        const { basePath, pageRoutes, resourceRoutes } = routeState;
         const canonicalPath = stripBasePath(url.pathname, basePath);
         try {
             if (url.pathname === routeCheckPath(basePath)) {
@@ -171,6 +218,14 @@ export function createPreviewRequestHandler(options) {
             canonicalUrl.pathname = canonicalPath;
             const resolvedResource = resolveRequestRoute(canonicalUrl, resourceRoutes);
             if (resolvedResource.matched && resolvedResource.route) {
+                let globalMiddleware = null;
+                try {
+                    globalMiddleware = await loadGlobalMiddlewareForRoute();
+                }
+                catch (error) {
+                    respondWithMiddlewareSourceError(res, error);
+                    return;
+                }
                 const requestMethod = req.method || 'GET';
                 const requestBodyBuffer = requestMethod === 'GET' || requestMethod === 'HEAD'
                     ? null
@@ -186,7 +241,9 @@ export function createPreviewRequestHandler(options) {
                     routePattern: resolvedResource.route.path,
                     routeFile: resolvedResource.route.server_script_path || '',
                     routeId: resolvedResource.route.route_id || routeIdFromSourcePath(resolvedResource.route.server_script_path || ''),
-                    routeKind: 'resource'
+                    routeKind: 'resource',
+                    globalMiddlewareSource: globalMiddleware?.source || '',
+                    globalMiddlewareSourcePath: globalMiddleware?.sourcePath || ''
                 });
                 const descriptor = buildResourceResponseDescriptor(execution?.result, basePath, Array.isArray(execution?.setCookies) ? execution.setCookies : []);
                 res.writeHead(descriptor.status, appendSetCookieHeaders(descriptor.headers, descriptor.setCookies));
@@ -216,7 +273,17 @@ export function createPreviewRequestHandler(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 = await loadGlobalMiddlewareForRoute();
+                }
+                catch (error) {
+                    respondWithMiddlewareSourceError(res, error);
+                    return;
+                }
                 try {
                     const requestMethod = req.method || 'GET';
                     const requestBodyBuffer = requestMethod === 'GET' || requestMethod === 'HEAD'
@@ -232,7 +299,13 @@ export function createPreviewRequestHandler(options) {
                         requestBodyBuffer,
                         routePattern: resolved.route.path,
                         routeFile: resolved.route.server_script_path || '',
-                        routeId: resolved.route.route_id || routeIdFromSourcePath(resolved.route.server_script_path || '')
+                        routeId: resolved.route.route_id || routeIdFromSourcePath(resolved.route.server_script_path || ''),
+                        globalMiddlewareSource: globalMiddleware?.source || '',
+                        globalMiddlewareSourcePath: globalMiddleware?.sourcePath || '',
+                        scopedServerData: Array.isArray(resolved.route.scoped_server_data)
+                            ? resolved.route.scoped_server_data
+                            : [],
+                        scopedServerModuleBaseDir: serverModuleBaseDir
                     });
                 }
                 catch (error) {

package/dist/preview/server-runner.d.ts

@@ -1,8 +1,8 @@
 /**
- * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, requestBodyBuffer?: Buffer | null, routePattern?: string, routeFile?: string, routeId?: string, routeKind?: 'page' | 'resource' }} input
+ * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, requestBodyBuffer?: Buffer | null, routePattern?: string, routeFile?: string, routeId?: string, routeKind?: 'page' | 'resource', globalMiddlewareSource?: string, globalMiddlewareSourcePath?: string, scopedServerData?: unknown[], scopedServerModuleBaseDir?: string, scopedServerModuleSources?: unknown[] }} input
  * @returns {Promise<{ result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
-export function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, requestBodyBuffer, routePattern, routeFile, routeId, routeKind, guardOnly }: {
+export function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, requestBodyBuffer, routePattern, routeFile, routeId, routeKind, guardOnly, globalMiddlewareSource, globalMiddlewareSourcePath, scopedServerData, scopedServerModuleBaseDir, scopedServerModuleSources }: {
     source: string;
     sourcePath: string;
     params: Record<string, string>;
@@ -14,6 +14,11 @@ export function executeServerRoute({ source, sourcePath, params, requestUrl, req
     routeFile?: string;
     routeId?: string;
     routeKind?: "page" | "resource";
+    globalMiddlewareSource?: string;
+    globalMiddlewareSourcePath?: string;
+    scopedServerData?: unknown[];
+    scopedServerModuleBaseDir?: string;
+    scopedServerModuleSources?: unknown[];
 }): Promise<{
     result: {
         kind: string;

package/dist/preview/server-runner.js

@@ -5,11 +5,12 @@ import { clientFacingRouteMessage, defaultRouteDenyMessage } from '../server-err
 import { SERVER_SCRIPT_RUNNER } from './server-script-runner-template.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 /**
- * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, requestBodyBuffer?: Buffer | null, routePattern?: string, routeFile?: string, routeId?: string, routeKind?: 'page' | 'resource' }} input
+ * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl?: string, requestMethod?: string, requestHeaders?: Record<string, string | string[] | undefined>, requestBodyBuffer?: Buffer | null, routePattern?: string, routeFile?: string, routeId?: string, routeKind?: 'page' | 'resource', globalMiddlewareSource?: string, globalMiddlewareSourcePath?: string, scopedServerData?: unknown[], scopedServerModuleBaseDir?: string, scopedServerModuleSources?: unknown[] }} input
  * @returns {Promise<{ result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
-export async function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, requestBodyBuffer, routePattern, routeFile, routeId, routeKind = 'page', guardOnly = false }) {
-    if (!source || !String(source).trim()) {
+export async function executeServerRoute({ source, sourcePath, params, requestUrl, requestMethod, requestHeaders, requestBodyBuffer, routePattern, routeFile, routeId, routeKind = 'page', guardOnly = false, globalMiddlewareSource = '', globalMiddlewareSourcePath = '', scopedServerData = [], scopedServerModuleBaseDir = '', scopedServerModuleSources = [] }) {
+    const hasScopedServerData = Array.isArray(scopedServerData) && scopedServerData.length > 0;
+    if ((!source || !String(source).trim()) && !hasScopedServerData) {
         return {
             result: { kind: 'data', data: {} },
             trace: { guard: 'none', action: 'none', load: 'none' }
@@ -27,7 +28,12 @@ export async function executeServerRoute({ source, sourcePath, params, requestUr
         routeFile: routeFile || sourcePath || '',
         routeId: routeId || routeIdFromSourcePath(sourcePath || ''),
         routeKind,
-        guardOnly
+        guardOnly,
+        globalMiddlewareSource,
+        globalMiddlewareSourcePath,
+        scopedServerData,
+        scopedServerModuleBaseDir,
+        scopedServerModuleSources
     });
     if (payload === null || payload === undefined) {
         return {
@@ -110,7 +116,7 @@ export async function executeServerScript(input) {
     return {};
 }
 /**
- * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl: string, requestMethod: string, requestHeaders: Record<string, string>, requestBodyBuffer?: Buffer | null, routePattern: string, routeFile: string, routeId: string, routeKind?: 'page' | 'resource' }} input
+ * @param {{ source: string, sourcePath: string, params: Record<string, string>, requestUrl: string, requestMethod: string, requestHeaders: Record<string, string>, requestBodyBuffer?: Buffer | null, routePattern: string, routeFile: string, routeId: string, routeKind?: 'page' | 'resource', globalMiddlewareSource?: string, globalMiddlewareSourcePath?: string, scopedServerData?: unknown[], scopedServerModuleBaseDir?: string, scopedServerModuleSources?: unknown[] }} input
  * @returns {Promise<unknown>}
  */
 function spawnNodeServerRunner(input) {
@@ -130,7 +136,14 @@ function spawnNodeServerRunner(input) {
                 ZENITH_SERVER_ROUTE_KIND: input.routeKind || 'page',
                 ZENITH_SERVER_GUARD_ONLY: input.guardOnly ? '1' : '',
                 ZENITH_SERVER_CONTRACT_PATH: join(__dirname, '..', 'server-contract.js'),
-                ZENITH_SERVER_ROUTE_AUTH_PATH: join(__dirname, '..', 'auth', 'route-auth.js')
+                ZENITH_SERVER_ROUTE_AUTH_PATH: join(__dirname, '..', 'auth', 'route-auth.js'),
+                ZENITH_SERVER_MATCHED_ROUTE_PIPELINE_PATH: join(__dirname, '..', 'server-runtime', 'matched-route-pipeline.js'),
+                ZENITH_GLOBAL_MIDDLEWARE_SOURCE: input.globalMiddlewareSource || '',
+                ZENITH_GLOBAL_MIDDLEWARE_SOURCE_PATH: input.globalMiddlewareSourcePath || '',
+                ZENITH_SCOPED_SERVER_DATA: JSON.stringify(Array.isArray(input.scopedServerData) ? input.scopedServerData : []),
+                ZENITH_SCOPED_SERVER_MODULE_BASE_DIR: input.scopedServerModuleBaseDir || '',
+                ZENITH_SCOPED_SERVER_MODULE_SOURCES: JSON.stringify(Array.isArray(input.scopedServerModuleSources) ? input.scopedServerModuleSources : []),
+                ZENITH_SCOPED_SERVER_RUNTIME_PATH: join(__dirname, '..', 'scoped-server-data', 'runtime.js')
             },
             stdio: ['pipe', 'pipe', 'pipe']
         });