@zenithbuild/cli 0.7.10 → 0.7.12

package/dist/server-output.js

@@ -1,11 +1,13 @@
 import { existsSync } from 'node:fs';
 import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { basename, dirname, extname, join, relative, resolve } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { loadResourceRouteManifest } from './resource-manifest.js';
-const PACKAGE_REQUIRE = createRequire(import.meta.url);
-const RELATIVE_SPECIFIER_RE = /((?:import|export)\s+(?:[^'"]*?\s+from\s+)?|import\s*\()\s*(['"])([^'"]+)\2/g;
+import { assignServerRouteNames } from './server-route-names.js';
+import { normalizeGlobalMiddlewareMetadata } from './global-middleware.js';
+import { writeServerModulePackage } from './server-module-output.js';
+const GLOBAL_MIDDLEWARE_MODULE = 'global-middleware/entry.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 SERVER_RUNTIME_FILES = [
     {
         from: new URL('./server-runtime/route-render.js', import.meta.url),
@@ -20,6 +22,10 @@ const SERVER_RUNTIME_FILES = [
         to: 'server-contract',
         recursive: true
     },
+    {
+        from: new URL('./scoped-server-data/runtime.js', import.meta.url),
+        to: 'scoped-server-data/runtime.js'
+    },
     {
         from: new URL('./server-middleware.js', import.meta.url),
         to: 'server-middleware.js'
@@ -44,6 +50,10 @@ const SERVER_RUNTIME_FILES = [
         from: new URL('./images/shared.js', import.meta.url),
         to: 'images/shared.js'
     },
+    {
+        from: new URL('./images/remote-fetch.js', import.meta.url),
+        to: 'images/remote-fetch.js'
+    },
     {
         from: new URL('./images/runtime.js', import.meta.url),
         to: 'images/runtime.js'
@@ -65,197 +75,33 @@ const SERVER_RUNTIME_FILES = [
         to: 'download-result.js'
     }
 ];
-const SPECIAL_SERVER_SPECIFIERS = new Map([
-    ['zenith:server-contract', 'server-contract.js'],
-    ['zenith:route-auth', 'auth/route-auth.js']
-]);
-function normalizeRouteName(routePath) {
-    if (routePath === '/') {
-        return 'index';
-    }
-    return routePath
-        .replace(/^\//, '')
-        .replace(/\/+/g, '_')
-        .replace(/:/g, 'param_')
-        .replace(/\*/g, 'splat_')
-        .replace(/\?/g, 'opt')
-        .replace(/[^a-zA-Z0-9_]/g, '_')
-        .replace(/_+/g, '_')
-        .replace(/^_+|_+$/g, '');
-}
-function resolveTypeScriptApi(projectRoot) {
-    try {
-        const projectRequire = createRequire(join(projectRoot, '__zenith_server_output_loader__.js'));
-        return projectRequire('typescript');
-    }
-    catch {
-        try {
-            return PACKAGE_REQUIRE('typescript');
-        }
-        catch {
-            throw new Error('[Zenith:Build] Server-capable targets require the `typescript` package to transpile route modules.');
-        }
-    }
-}
-function withJsExtension(specifier) {
-    if (specifier.endsWith('.json')) {
-        return specifier;
-    }
-    return specifier.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
-}
-function replaceSpecifier(source, original, nextValue) {
-    return source.replace(new RegExp(`(['"])${escapeRegex(original)}\\1`, 'g'), (_, quote) => `${quote}${nextValue}${quote}`);
-}
-function escapeRegex(value) {
-    return String(value).replace(/[|\\{}()[\]^$+*?.-]/g, '\\$&');
-}
-function isRelativeSpecifier(specifier) {
-    return (specifier.startsWith('./') ||
-        specifier.startsWith('../') ||
-        specifier.startsWith('/') ||
-        specifier.startsWith('file:'));
-}
-function resolveModuleCandidates(basePath) {
-    if (extname(basePath)) {
-        return [basePath];
-    }
+let scopedServerDataLoweringPromise = null;
+function resolveScopedServerDataLoweringPath() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
     return [
-        basePath,
-        `${basePath}.ts`,
-        `${basePath}.tsx`,
-        `${basePath}.mts`,
-        `${basePath}.cts`,
-        `${basePath}.js`,
-        `${basePath}.mjs`,
-        `${basePath}.cjs`,
-        `${basePath}.json`,
-        join(basePath, 'index.ts'),
-        join(basePath, 'index.tsx'),
-        join(basePath, 'index.mts'),
-        join(basePath, 'index.cts'),
-        join(basePath, 'index.js'),
-        join(basePath, 'index.mjs'),
-        join(basePath, 'index.cjs'),
-        join(basePath, 'index.json')
-    ];
+        join(moduleDir, 'scoped-server-data', 'lowering.js'),
+        join(moduleDir, '..', 'dist', 'scoped-server-data', 'lowering.js')
+    ].find((candidate) => existsSync(candidate)) || null;
 }
-function resolveImportedModule(specifier, sourceFile) {
-    if (!isRelativeSpecifier(specifier)) {
-        return null;
-    }
-    const baseDir = dirname(sourceFile);
-    const basePath = specifier.startsWith('file:')
-        ? new URL(specifier)
-        : resolve(baseDir, specifier);
-    const filePath = basePath instanceof URL ? fileURLToPath(basePath) : basePath;
-    const candidates = resolveModuleCandidates(filePath);
-    const found = candidates.find((candidate) => existsSync(candidate));
-    if (!found) {
-        throw new Error(`[Zenith:Build] Cannot resolve server import "${specifier}" from "${sourceFile}"`);
+async function getScopedServerDataLowering() {
+    const helperPath = resolveScopedServerDataLoweringPath();
+    if (!helperPath) {
+        throw new Error(SCOPED_SERVER_DATA_LOWERING_HELPER_UNAVAILABLE);
     }
-    return found;
-}
-function gatherSpecifiers(source) {
-    const results = [];
-    for (const match of source.matchAll(RELATIVE_SPECIFIER_RE)) {
-        const specifier = String(match[3] || '');
-        results.push(specifier);
+    if (!scopedServerDataLoweringPromise) {
+        scopedServerDataLoweringPromise = import(pathToFileURL(helperPath).href);
     }
-    return results;
-}
-function transpileSource(ts, source, filePath) {
-    return ts.transpileModule(source, {
-        compilerOptions: {
-            module: ts.ModuleKind.ESNext,
-            target: ts.ScriptTarget.ES2022,
-            moduleResolution: ts.ModuleResolutionKind.NodeNext,
-            esModuleInterop: true,
-            allowSyntheticDefaultImports: true
-        },
-        fileName: filePath
-    }).outputText;
-}
-function outputPathForSource(projectRoot, modulesRoot, sourcePath) {
-    const relativePath = relative(projectRoot, sourcePath).replaceAll('\\', '/');
-    const nextRelative = extname(relativePath) === '.json'
-        ? relativePath
-        : relativePath.replace(/\.(tsx|ts|mts|cts|jsx|js|mjs|cjs)$/i, '.js');
-    return join(modulesRoot, nextRelative);
-}
-async function compileImportedModule({ projectRoot, modulesRoot, serverDir, sourcePath, ts, seen }) {
-    if (seen.has(sourcePath)) {
-        return outputPathForSource(projectRoot, modulesRoot, sourcePath);
-    }
-    seen.add(sourcePath);
-    const outPath = outputPathForSource(projectRoot, modulesRoot, sourcePath);
-    await mkdir(dirname(outPath), { recursive: true });
-    if (extname(sourcePath) === '.json') {
-        await cp(sourcePath, outPath, { force: true });
-        return outPath;
-    }
-    const source = await readFile(sourcePath, 'utf8');
-    let output = transpileSource(ts, source, sourcePath);
-    for (const specifier of gatherSpecifiers(output)) {
-        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
-        if (specialSpecifierPath) {
-            const nextSpecifier = relative(dirname(outPath), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
-            output = replaceSpecifier(output, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
-            continue;
-        }
-        if (!isRelativeSpecifier(specifier)) {
-            continue;
-        }
-        const resolvedPath = resolveImportedModule(specifier, sourcePath);
-        if (!resolvedPath) {
-            continue;
-        }
-        const compiledDependencyPath = await compileImportedModule({
-            projectRoot,
-            modulesRoot,
-            serverDir,
-            sourcePath: resolvedPath,
-            ts,
-            seen
-        });
-        const nextSpecifier = relative(dirname(outPath), compiledDependencyPath).replaceAll('\\', '/');
-        output = replaceSpecifier(output, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
-    }
-    await writeFile(outPath, output, 'utf8');
-    return outPath;
+    return scopedServerDataLoweringPromise;
 }
 async function writeRouteModulePackage({ projectRoot, serverDir, routeDir, route }) {
-    const ts = resolveTypeScriptApi(projectRoot);
-    const modulesRoot = join(routeDir, 'modules');
-    const seen = new Set();
-    let entryOutput = transpileSource(ts, route.server_script || '', route.server_script_path || 'route-entry.ts');
-    for (const specifier of gatherSpecifiers(entryOutput)) {
-        const specialSpecifierPath = SPECIAL_SERVER_SPECIFIERS.get(specifier);
-        if (specialSpecifierPath) {
-            const nextSpecifier = relative(join(routeDir, 'route'), join(serverDir, specialSpecifierPath)).replaceAll('\\', '/');
-            entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
-            continue;
-        }
-        if (!isRelativeSpecifier(specifier)) {
-            continue;
-        }
-        const resolvedPath = resolveImportedModule(specifier, route.server_script_path || projectRoot);
-        if (!resolvedPath) {
-            continue;
-        }
-        const compiledDependencyPath = await compileImportedModule({
-            projectRoot,
-            modulesRoot,
-            serverDir,
-            sourcePath: resolvedPath,
-            ts,
-            seen
-        });
-        const nextSpecifier = relative(join(routeDir, 'route'), compiledDependencyPath).replaceAll('\\', '/');
-        entryOutput = replaceSpecifier(entryOutput, specifier, nextSpecifier.startsWith('.') ? nextSpecifier : `./${nextSpecifier}`);
-    }
-    const routeModulePath = join(routeDir, 'route', 'entry.js');
-    await mkdir(dirname(routeModulePath), { recursive: true });
-    await writeFile(routeModulePath, entryOutput, 'utf8');
+    await writeServerModulePackage({
+        projectRoot,
+        serverDir,
+        entrySource: route.server_script || '',
+        entrySourcePath: route.server_script_path || 'route-entry.ts',
+        entryOutputPath: join(routeDir, 'route', 'entry.js'),
+        modulesRoot: join(routeDir, 'modules')
+    });
 }
 async function copyRuntimeFiles(serverDir) {
     for (const file of SERVER_RUNTIME_FILES) {
@@ -275,7 +121,81 @@ async function copyOptionalFile(sourcePath, targetPath) {
     await cp(sourcePath, targetPath, { force: true });
     return true;
 }
-export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot, config, basePath = '/' }) {
+async function writeGlobalMiddlewarePackage({ projectRoot, serverDir, globalMiddleware }) {
+    const metadata = normalizeGlobalMiddlewareMetadata(globalMiddleware);
+    if (!metadata) {
+        return null;
+    }
+    const sourcePath = resolve(projectRoot, metadata.source_file);
+    if (!existsSync(sourcePath)) {
+        throw new Error(`[Zenith:Middleware] Cannot emit global middleware because source file "${metadata.source_file}" was not found.`);
+    }
+    await writeServerModulePackage({
+        projectRoot,
+        serverDir,
+        entrySource: await readFile(sourcePath, 'utf8'),
+        entrySourcePath: sourcePath,
+        entryOutputPath: join(serverDir, GLOBAL_MIDDLEWARE_MODULE),
+        modulesRoot: join(serverDir, 'global-middleware', 'modules'),
+        validateMiddlewareImports: true
+    });
+    return {
+        ...metadata,
+        module: GLOBAL_MIDDLEWARE_MODULE
+    };
+}
+function mergePageRouteMetadata(route, manifestEntry) {
+    if (!manifestEntry) {
+        return route;
+    }
+    return {
+        ...route,
+        file: manifestEntry.file || route.file || null,
+        has_scoped_server_data: manifestEntry.has_scoped_server_data === true || route.has_scoped_server_data === true,
+        scoped_server_data: Array.isArray(manifestEntry.scoped_server_data)
+            ? manifestEntry.scoped_server_data
+            : (Array.isArray(route.scoped_server_data) ? route.scoped_server_data : [])
+    };
+}
+async function writeScopedServerDataModules({ projectRoot, serverDir, route, pagesDir, srcDir, registry, compilerOpts }) {
+    if (route.route_kind === 'resource' || route.has_scoped_server_data !== true) {
+        return [];
+    }
+    if (!pagesDir || !srcDir || !registry) {
+        throw new Error(`[Zenith:ScopedServerData] Cannot package scoped server data for route "${route.path}" without build context.`);
+    }
+    if (typeof route.file !== 'string' || route.file.length === 0) {
+        throw new Error(`[Zenith:ScopedServerData] Cannot package scoped server data for route "${route.path}" without a source file.`);
+    }
+    const pageFile = resolve(pagesDir, route.file);
+    const pageSource = await readFile(pageFile, 'utf8');
+    const lowering = await getScopedServerDataLowering();
+    const lowered = lowering.lowerRouteScopedServerData({
+        pageSource,
+        pageFile,
+        registry,
+        srcDir,
+        projectRoot,
+        compilerOpts,
+        scopedServerData: Array.isArray(route.scoped_server_data) ? route.scoped_server_data : []
+    });
+    if (!Array.isArray(lowered.scopedServerData) || lowered.scopedServerData.length === 0) {
+        throw new Error(`[Zenith:ScopedServerData] Cannot package scoped server data for route "${route.path}" because no owners were lowered.`);
+    }
+    for (const module of lowered.modules) {
+        const entryOutputPath = lowering.resolveScopedServerModuleOutputPath(serverDir, module.module);
+        await writeServerModulePackage({
+            projectRoot,
+            serverDir,
+            entrySource: module.source,
+            entrySourcePath: module.sourcePath,
+            entryOutputPath,
+            modulesRoot: join(serverDir, 'scoped', '_modules')
+        });
+    }
+    return lowered.scopedServerData;
+}
+export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot, config, basePath = '/', globalMiddleware = null, pageManifest = [], pagesDir = null, srcDir = null, registry = null, compilerOpts = {} }) {
     const serverDir = join(coreOutputDir, 'server');
     await rm(serverDir, { recursive: true, force: true });
     let routerManifest = { routes: [] };
@@ -286,20 +206,31 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
         routerManifest = { routes: [] };
     }
     const resourceManifest = await loadResourceRouteManifest(staticDir, basePath);
-    const pageRoutes = Array.isArray(routerManifest.routes) ? routerManifest.routes : [];
+    const pageManifestByPath = new Map((Array.isArray(pageManifest) ? pageManifest : [])
+        .filter((entry) => entry?.route_kind !== 'resource')
+        .map((entry) => [entry.path, entry]));
+    const pageRoutes = (Array.isArray(routerManifest.routes) ? routerManifest.routes : [])
+        .map((route) => mergePageRouteMetadata(route, pageManifestByPath.get(route.path)));
     const serverRoutes = pageRoutes
-        .filter((route) => route.server_script && route.prerender !== true)
+        .filter((route) => route.prerender !== true && (route.server_script || route.has_scoped_server_data === true))
         .map((route) => ({ ...route, route_kind: 'page' }))
         .concat((Array.isArray(resourceManifest.routes) ? resourceManifest.routes : []).map((route) => ({
         ...route,
         route_kind: 'resource'
     })));
+    if (serverRoutes.some((route) => route.route_kind !== 'resource' && route.has_scoped_server_data === true)) {
+        await getScopedServerDataLowering();
+    }
     await mkdir(serverDir, { recursive: true });
     await copyRuntimeFiles(serverDir);
+    const serverGlobalMiddlewareMetadata = await writeGlobalMiddlewarePackage({
+        projectRoot,
+        serverDir,
+        globalMiddleware
+    });
     const imageManifestSource = join(staticDir, '_zenith', 'image', 'manifest.json');
     const emittedRoutes = [];
-    for (const route of serverRoutes) {
-        const name = normalizeRouteName(route.path);
+    for (const { route, name } of assignServerRouteNames(serverRoutes)) {
         const routeDir = join(serverDir, 'routes', name);
         await mkdir(routeDir, { recursive: true });
         if (route.route_kind !== 'resource') {
@@ -324,6 +255,15 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             routeDir,
             route
         });
+        const scopedServerData = await writeScopedServerDataModules({
+            projectRoot,
+            serverDir,
+            route,
+            pagesDir,
+            srcDir,
+            registry,
+            compilerOpts
+        });
         const meta = {
             name,
             path: route.path,
@@ -346,13 +286,22 @@ export async function writeServerOutput({ coreOutputDir, staticDir, projectRoot,
             image_manifest_file: route.route_kind === 'resource' ? null : imageManifestFile,
             image_config: config?.images || {}
         };
+        if (scopedServerData.length > 0) {
+            meta.has_scoped_server_data = true;
+            meta.scoped_server_data = scopedServerData;
+        }
         if (route.route_kind !== 'resource' && Array.isArray(route.image_materialization) && route.image_materialization.length > 0) {
             meta.image_materialization = route.image_materialization;
         }
         await writeFile(join(routeDir, 'route.json'), `${JSON.stringify(meta, null, 2)}\n`, 'utf8');
         emittedRoutes.push(meta);
     }
-    await writeFile(join(serverDir, 'manifest.json'), `${JSON.stringify({ base_path: basePath, routes: emittedRoutes }, null, 2)}\n`, 'utf8');
+    const serverManifest = {
+        base_path: basePath,
+        ...(serverGlobalMiddlewareMetadata ? { global_middleware: serverGlobalMiddlewareMetadata } : {}),
+        routes: emittedRoutes
+    };
+    await writeFile(join(serverDir, 'manifest.json'), `${JSON.stringify(serverManifest, null, 2)}\n`, 'utf8');
     return {
         serverDir,
         routes: emittedRoutes

package/dist/server-route-names.d.ts

@@ -0,0 +1,2 @@
+export function normalizeRouteName(routePath: any): any;
+export function assignServerRouteNames(routes: any): any;

package/dist/server-route-names.js

@@ -0,0 +1,38 @@
+import { createHash } from 'node:crypto';
+export function normalizeRouteName(routePath) {
+    if (routePath === '/') {
+        return 'index';
+    }
+    return routePath
+        .replace(/^\//, '')
+        .replace(/\/+/g, '_')
+        .replace(/:/g, 'param_')
+        .replace(/\*/g, 'splat_')
+        .replace(/\?/g, 'opt')
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'route';
+}
+function routeNameHash(route) {
+    return createHash('sha256')
+        .update(`${route.route_kind || 'page'}:${route.path || ''}`)
+        .digest('hex')
+        .slice(0, 8);
+}
+export function assignServerRouteNames(routes) {
+    const used = new Set();
+    return routes.map((route) => {
+        const baseName = normalizeRouteName(route.path);
+        let name = baseName;
+        if (used.has(name)) {
+            name = `${baseName}_${routeNameHash(route)}`;
+        }
+        let suffix = 2;
+        while (used.has(name)) {
+            name = `${baseName}_${routeNameHash(route)}_${suffix}`;
+            suffix += 1;
+        }
+        used.add(name);
+        return { route, name };
+    });
+}

package/dist/server-runtime/matched-route-pipeline.d.ts

@@ -0,0 +1 @@
+export { executeMatchedRoutePipeline, runGlobalMiddlewareChain } from "../server-contract/resolve.js";

package/dist/server-runtime/matched-route-pipeline.js

@@ -0,0 +1 @@
+export { executeMatchedRoutePipeline, runGlobalMiddlewareChain } from '../server-contract/resolve.js';

package/dist/server-runtime/node-server.js

@@ -11,6 +11,7 @@ import { executeRouteRequest, renderResourceRouteRequest, renderRouteRequest } f
 import { resolveRequestRoute } from './resolve-request-route.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const PUBLIC_ORIGIN_ENV = 'ZENITH_PUBLIC_ORIGIN';
 const MIME_TYPES = {
     '.html': 'text/html; charset=utf-8',
     '.js': 'application/javascript; charset=utf-8',
@@ -60,6 +61,22 @@ function resolveWithinRoot(rootDir, requestPath) {
     }
     return null;
 }
+function resolveManifestMiddlewareModulePath(serverDir, serverManifest) {
+    const modulePath = serverManifest?.global_middleware?.module;
+    if (typeof modulePath !== 'string' || modulePath.trim().length === 0) {
+        return null;
+    }
+    const normalized = normalize(modulePath).replace(/\\/g, '/');
+    if (normalized === '..' || normalized.startsWith('../') || normalized.startsWith('/')) {
+        throw new Error('[Zenith:Middleware] Invalid global middleware module path in server manifest.');
+    }
+    const root = resolve(serverDir);
+    const candidate = resolve(root, normalized);
+    if (candidate !== root && candidate.startsWith(`${root}${sep}`)) {
+        return candidate;
+    }
+    throw new Error('[Zenith:Middleware] Invalid global middleware module path in server manifest.');
+}
 function toStaticFilePath(staticDir, pathname) {
     let resolvedPath = pathname;
     if (resolvedPath === '/') {
@@ -192,6 +209,7 @@ async function loadRuntimeContext(options = {}) {
         });
         const serverManifest = await readJson(join(serverDir, 'manifest.json'), { routes: [] });
         const allServerRoutes = Array.isArray(serverManifest.routes) ? serverManifest.routes : [];
+        const globalMiddlewareModulePath = resolveManifestMiddlewareModulePath(serverDir, serverManifest);
         return {
             distDir,
             serverDir,
@@ -201,6 +219,7 @@ async function loadRuntimeContext(options = {}) {
             serverRoutes: allServerRoutes,
             pageServerRoutes: allServerRoutes.filter((route) => route?.route_kind !== 'resource'),
             resourceServerRoutes: allServerRoutes.filter((route) => route?.route_kind === 'resource'),
+            globalMiddlewareModulePath,
             images: config.images || {},
             basePath: normalizeBasePath(config.base_path || '/')
         };
@@ -322,7 +341,8 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
             request,
             route: resourceResolved.route,
             params: resourceResolved.params,
-            routeModulePath: join(routeDir, 'route', 'entry.js')
+            routeModulePath: join(routeDir, 'route', 'entry.js'),
+            globalMiddlewareModulePath: context.globalMiddlewareModulePath
         });
         await sendFetchResponse(res, response, req.method);
         return;
@@ -336,6 +356,7 @@ async function handleNodeRequest(req, res, context, serverOrigin) {
             route: serverResolved.route,
             params: serverResolved.params,
             routeModulePath: join(routeDir, 'route', 'entry.js'),
+            globalMiddlewareModulePath: context.globalMiddlewareModulePath,
             shellHtmlPath: join(routeDir, 'route', 'page.html'),
             imageManifestPath: serverResolved.route.image_manifest_file
                 ? join(routeDir, 'route', serverResolved.route.image_manifest_file)
@@ -375,8 +396,9 @@ function createNodeRequestHandler(context, resolveServerOrigin) {
 }
 export async function createRequestHandler(options = {}) {
     const context = await loadRuntimeContext(options);
+    const publicOrigin = options.publicOrigin ?? process.env[PUBLIC_ORIGIN_ENV];
     const resolveServerOrigin = createTrustedOriginResolver({
-        publicOrigin: options.publicOrigin,
+        publicOrigin,
         host: options.host || '127.0.0.1',
         port: Number.isInteger(options.port) ? options.port : undefined,
         label: 'createRequestHandler()'
@@ -388,8 +410,9 @@ export async function createNodeServer(options = {}) {
     const { port = 3000, host = '127.0.0.1' } = options;
     const context = await loadRuntimeContext(options);
     let actualPort = Number.isInteger(port) && port > 0 ? port : 0;
+    const publicOrigin = options.publicOrigin ?? process.env[PUBLIC_ORIGIN_ENV];
     const resolveServerOrigin = createTrustedOriginResolver({
-        publicOrigin: options.publicOrigin,
+        publicOrigin,
         host,
         getPort: () => actualPort,
         label: 'createNodeServer()'

package/dist/server-runtime/route-render.d.ts

@@ -6,9 +6,10 @@ export function extractInternalParams(requestUrl: any, route: any): {};
  *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null },
  *   params: Record<string, string>,
  *   routeModulePath: string,
+ *   globalMiddlewareModulePath?: string | null,
  *   guardOnly?: boolean
  * }} options
- * @returns {Promise<{ publicUrl: URL, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
+ * @returns {Promise<{ publicUrl: URL, ctx: object, result: { kind: string, [key: string]: unknown }, trace: { guard: string, action: string, load: string }, status?: number, setCookies?: string[] }>}
  */
 export function executeRouteRequest(options: {
     request: Request;
@@ -21,9 +22,11 @@ export function executeRouteRequest(options: {
     };
     params: Record<string, string>;
     routeModulePath: string;
+    globalMiddlewareModulePath?: string | null;
     guardOnly?: boolean;
 }): Promise<{
     publicUrl: URL;
+    ctx: object;
     result: {
         kind: string;
         [key: string]: unknown;
@@ -42,9 +45,11 @@ export function executeRouteRequest(options: {
  *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null },
  *   params: Record<string, string>,
  *   routeModulePath: string,
+ *   globalMiddlewareModulePath?: string | null,
  *   shellHtmlPath: string,
  *   imageManifestPath?: string | null,
- *   imageConfig?: Record<string, unknown>
+ *   imageConfig?: Record<string, unknown>,
+ *   scopedModuleBaseDir?: string | null
  * }} options
  * @returns {Promise<Response>}
  */
@@ -59,16 +64,19 @@ export function renderRouteRequest(options: {
     };
     params: Record<string, string>;
     routeModulePath: string;
+    globalMiddlewareModulePath?: string | null;
     shellHtmlPath: string;
     imageManifestPath?: string | null;
     imageConfig?: Record<string, unknown>;
+    scopedModuleBaseDir?: string | null;
 }): Promise<Response>;
 /**
  * @param {{
  *   request: Request,
  *   route: { path: string, params?: string[], route_id?: string | null, server_script_path?: string | null, file?: string | null, route_kind?: string | null, base_path?: string | null },
  *   params: Record<string, string>,
- *   routeModulePath: string
+ *   routeModulePath: string,
+ *   globalMiddlewareModulePath?: string | null
  * }} options
  * @returns {Promise<Response>}
  */
@@ -85,4 +93,5 @@ export function renderResourceRouteRequest(options: {
     };
     params: Record<string, string>;
     routeModulePath: string;
+    globalMiddlewareModulePath?: string | null;
 }): Promise<Response>;