@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/adapters/shared/file-route-middleware-pipeline.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import type { Middleware } from '../../public-types.ts';
+import { LocalsAccessError } from '../../errors/locals-access-error.ts';
+import {
+	FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS,
+	FileRouteMiddlewarePipeline,
+} from './file-route-middleware-pipeline.ts';
+
+declare module '../../public-types.ts' {
+	interface RequestLocals {
+		user?: string;
+		first?: boolean;
+	}
+}
+
+describe('FileRouteMiddlewarePipeline', () => {
+	it('should reject middleware on non-dynamic pages', () => {
+		const service = new FileRouteMiddlewarePipeline(null);
+
+		expect(() =>
+			service.assertValidConfiguration({
+				middleware: [async (_ctx, next) => next()],
+				pageCacheStrategy: 'static',
+				filePath: '/app/pages/index.tsx',
+			}),
+		).toThrowError(
+			new LocalsAccessError(
+				FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.middlewareRequiresDynamic('/app/pages/index.tsx'),
+			),
+		);
+	});
+
+	it('should create middleware context with render methods disabled', async () => {
+		const service = new FileRouteMiddlewarePipeline(null);
+		const DummyView = (() => '<div>dummy</div>') as never;
+		const context = service.createContext({
+			request: new Request('http://localhost:3000/hello'),
+			params: { slug: 'hello' },
+			locals: { user: 'andee' },
+		});
+
+		await expect(context.render(DummyView, {})).rejects.toThrow(
+			FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.CTX_RENDER_UNAVAILABLE,
+		);
+		await expect(context.renderPartial(DummyView, {})).rejects.toThrow(
+			FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.CTX_RENDER_PARTIAL_UNAVAILABLE,
+		);
+
+		expect(context.require('user', () => new Response('missing', { status: 500 }))).toBe('andee');
+		expect(await context.html('<p>ok</p>').text()).toContain('<p>ok</p>');
+		expect(await context.json({ ok: true }).text()).toContain('{"ok":true}');
+	});
+
+	it('should execute middleware in order and eventually render the response', async () => {
+		const service = new FileRouteMiddlewarePipeline(null);
+		const context = service.createContext({
+			request: new Request('http://localhost:3000/hello'),
+			params: {},
+			locals: {},
+		});
+		const events: string[] = [];
+
+		const middleware: Middleware[] = [
+			async (ctx, next) => {
+				events.push('first:before');
+				ctx.locals.first = true;
+				const response = await next();
+				events.push('first:after');
+				return response;
+			},
+			async (ctx, next) => {
+				events.push('second');
+				expect(ctx.locals.first).toBe(true);
+				return next();
+			},
+		];
+
+		const response = await service.run({
+			middleware,
+			context,
+			renderResponse: async () => {
+				events.push('render');
+				return new Response('done');
+			},
+		});
+
+		expect(await response.text()).toBe('done');
+		expect(events).toEqual(['first:before', 'second', 'render', 'first:after']);
+	});
+});

package/src/adapters/shared/file-route-middleware-pipeline.ts

@@ -1,6 +1,6 @@
 import { createRequire } from '../../utils/locals-utils.ts';
 import type { Middleware, ApiHandlerContext, RequestLocals } from '../../public-types.ts';
-import type { PageCacheService } from '../../services/cache/page-cache-service.ts';
+import type { PageCacheService } from '../../services/cache/page-cache-service.js';
 import { ApiResponseBuilder } from './api-response.js';
 import { LocalsAccessError } from '../../errors/locals-access-error.ts';
 
@@ -20,7 +20,11 @@ export const FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS = {
  * request-time dynamic rendering.
  */
 export class FileRouteMiddlewarePipeline {
-	constructor(private cacheService: PageCacheService | null) {}
+	private cacheService: PageCacheService | null;
+
+	constructor(cacheService: PageCacheService | null) {
+		this.cacheService = cacheService;
+	}
 
 	/**
 	 * Enforces the current middleware contract for file-routed pages.

package/src/adapters/shared/fs-server-response-factory.test.ts

@@ -0,0 +1,187 @@
+import { beforeAll, describe, expect, it, vi } from 'vitest';
+import {
+	FIXTURE_APP_PROJECT_DIR,
+	FIXTURE_EXISTING_CSS_FILE_IN_DIST,
+	FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
+} from '../../../__fixtures__/constants.js';
+import { appLogger } from '../../global/app-logger.ts';
+import { ConfigBuilder } from '../../config/config-builder.ts';
+import { STATUS_MESSAGE } from '../../constants.ts';
+import { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
+import { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
+
+let appConfig: Awaited<ReturnType<ConfigBuilder['build']>>;
+let responseFactory: FileSystemServerResponseFactory;
+
+describe('FileSystemServerResponseFactory', () => {
+	beforeAll(async () => {
+		appConfig = await new ConfigBuilder().setRootDir(FIXTURE_APP_PROJECT_DIR).build();
+
+		for (const integration of appConfig.integrations) {
+			integration.setConfig(appConfig);
+			integration.setRuntimeOrigin(appConfig.baseUrl);
+		}
+
+		responseFactory = new FileSystemServerResponseFactory({
+			appConfig,
+			routeRendererFactory: new RouteRendererFactory({
+				appConfig,
+				runtimeOrigin: appConfig.baseUrl,
+			}),
+			options: {
+				watchMode: false,
+			},
+		});
+	});
+
+	describe('isHtml', () => {
+		it('should return true for text/html content type', () => {
+			const result = responseFactory.isHtml('text/html');
+			expect(result).toBe(true);
+		});
+
+		it('should return false for text/plain content type', () => {
+			const result = responseFactory.isHtml('text/plain');
+			expect(result).toBe(false);
+		});
+
+		it('should return false for other content types', () => {
+			const result = responseFactory.isHtml('application/json');
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('shouldEnableGzip', () => {
+		it('should return false in watch mode', () => {
+			const responseFactoryWatch = new FileSystemServerResponseFactory({
+				appConfig,
+				routeRendererFactory: new RouteRendererFactory({
+					appConfig,
+					runtimeOrigin: appConfig.baseUrl,
+				}),
+				options: {
+					watchMode: true,
+				},
+			});
+
+			const result = responseFactoryWatch.shouldEnableGzip('text/javascript');
+			expect(result).toBe(false);
+		});
+
+		it('should return true for text/javascript content type', () => {
+			const result = responseFactory.shouldEnableGzip('text/javascript');
+			expect(result).toBe(true);
+		});
+
+		it('should return true for text/css content type', () => {
+			const result = responseFactory.shouldEnableGzip('text/css');
+			expect(result).toBe(true);
+		});
+
+		it('should return false for other content types', () => {
+			const result = responseFactory.shouldEnableGzip('application/json');
+			expect(result).toBe(false);
+		});
+	});
+
+	describe('createResponseWithBody', () => {
+		it('should create a response with the given route renderer body', async () => {
+			const routeRendererBody = '<html><body>Test</body></html>';
+			const response = await responseFactory.createResponseWithBody(routeRendererBody);
+			const body = await response.text();
+			expect(body).toBe(routeRendererBody);
+			expect(response.headers.get('Content-Type')).toBe('text/html');
+		});
+	});
+
+	describe('createDefaultNotFoundResponse', () => {
+		it('should create a response with status 404 and body "file not found"', async () => {
+			const response = await responseFactory.createDefaultNotFoundResponse();
+			expect(response.status).toBe(404);
+			expect(await response.text()).toBe(STATUS_MESSAGE[404]);
+		});
+	});
+
+	describe('createCustomNotFoundResponse', () => {
+		it('should create a response with status 404 if error404 template file does not exist', async () => {
+			const customAppConfig = {
+				...appConfig,
+				absolutePaths: {
+					...appConfig.absolutePaths,
+					error404TemplatePath: 'non-existent-file',
+				},
+			};
+
+			const responseFactoryNo404Template = new FileSystemServerResponseFactory({
+				appConfig: customAppConfig,
+				routeRendererFactory: new RouteRendererFactory({
+					appConfig: customAppConfig,
+					runtimeOrigin: customAppConfig.baseUrl,
+				}),
+				options: {
+					watchMode: false,
+				},
+			});
+
+			const response = await responseFactoryNo404Template.createCustomNotFoundResponse();
+			expect(response.status).toBe(404);
+			expect(await response.text()).toBe(STATUS_MESSAGE[404]);
+		});
+
+		it('should create a response with the route renderer body if error404 template file exists', async () => {
+			const response = await responseFactory.createCustomNotFoundResponse();
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+			expect(response.headers.get('Content-Type')).toBe('text/html');
+			expect(response.status).toBe(404);
+		});
+	});
+
+	describe('createFileResponse', () => {
+		it('should create a response with the file content and content type', async () => {
+			const response = await responseFactory.createFileResponse(
+				FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
+				'image/svg+xml',
+			);
+			expect(response.headers.get('Content-Type')).toBe('image/svg+xml');
+		});
+
+		it('should return custom 404 page if the file does not exist', async () => {
+			const response = await responseFactory.createFileResponse('/path/to/nonexistent.txt', 'text/plain');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+			expect(response.status).toBe(404);
+		});
+
+		it('should log debug for ENOENT errors', async () => {
+			const debugSpy = vi.spyOn(appLogger, 'debug');
+			const errorSpy = vi.spyOn(appLogger, 'error');
+
+			await responseFactory.createFileResponse('/path/to/nonexistent-debug.txt', 'text/plain');
+
+			expect(debugSpy).toHaveBeenCalled();
+			expect(errorSpy).not.toHaveBeenCalled();
+
+			debugSpy.mockRestore();
+			errorSpy.mockRestore();
+		});
+
+		it('should serve gzip file with Content-Encoding header when gzip is enabled', async () => {
+			const cssFilePath = `${appConfig.absolutePaths.distDir}/${FIXTURE_EXISTING_CSS_FILE_IN_DIST}`;
+			const response = await responseFactory.createFileResponse(cssFilePath, 'text/css');
+
+			expect(response.headers.get('Content-Type')).toBe('text/css');
+			expect(response.headers.get('Content-Encoding')).toBe('gzip');
+		});
+
+		it('should not set Content-Encoding header for non-gzip content types', async () => {
+			const response = await responseFactory.createFileResponse(
+				FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
+				'image/svg+xml',
+			);
+
+			expect(response.headers.get('Content-Type')).toBe('image/svg+xml');
+			expect(response.headers.get('Content-Encoding')).toBeNull();
+		});
+	});
+});

package/src/adapters/shared/fs-server-response-matcher.test.ts

@@ -0,0 +1,286 @@
+import { describe, expect, it, vi } from 'vitest';
+import path from 'node:path';
+import { APP_TEST_ROUTES, FIXTURE_APP_PROJECT_DIR, INDEX_TEMPLATE_FILE } from '../../../__fixtures__/constants.ts';
+import { ConfigBuilder } from '../../config/config-builder.ts';
+import type { MatchResult } from '../../internal-types.ts';
+import { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
+import { FSRouter } from '../../router/server/fs-router.ts';
+import { FSRouterScanner } from '../../router/server/fs-router-scanner.ts';
+import { MemoryCacheStore } from '../../services/cache/memory-cache-store.ts';
+import { PageCacheService } from '../../services/cache/page-cache-service.ts';
+import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
+import { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
+import { FileSystemResponseMatcher } from './fs-server-response-matcher.ts';
+
+const appConfig = await new ConfigBuilder().setRootDir(FIXTURE_APP_PROJECT_DIR).build();
+
+for (const integration of appConfig.integrations) {
+	integration.setConfig(appConfig);
+	integration.setRuntimeOrigin(appConfig.baseUrl);
+}
+
+const scanner = new FSRouterScanner({
+	dir: path.join(appConfig.rootDir, appConfig.srcDir, appConfig.pagesDir),
+	appConfig,
+	origin: appConfig.baseUrl,
+	templatesExt: appConfig.templatesExt,
+	options: {
+		buildMode: false,
+	},
+});
+
+const router = new FSRouter({
+	origin: appConfig.baseUrl,
+	assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
+	scanner,
+});
+
+const routeRendererFactory = new RouteRendererFactory({
+	appConfig,
+	runtimeOrigin: appConfig.baseUrl,
+});
+
+const fileSystemResponseFactory = new FileSystemServerResponseFactory({
+	appConfig,
+	routeRendererFactory,
+	options: {
+		watchMode: false,
+	},
+});
+
+describe('FileSystemResponseMatcher', () => {
+	describe('without cache service', () => {
+		const matcherWithoutCache = new FileSystemResponseMatcher({
+			appConfig,
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+		});
+
+		it('should return custom 404 page for unmatched request URL', async () => {
+			const requestUrl = APP_TEST_ROUTES.nonExistentFile;
+			const response = await matcherWithoutCache.handleNoMatch(requestUrl);
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should handle match with disabled cache headers', async () => {
+			const match: MatchResult = {
+				kind: 'exact',
+				pathname: APP_TEST_ROUTES.index,
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: {},
+			};
+			const response = await matcherWithoutCache.handleMatch(match);
+			expect(response.headers.get('Content-Type')).toBe('text/html');
+			expect(response.headers.get('X-Cache')).toBe('DISABLED');
+			expect(response.headers.get('Cache-Control')).toBe('no-store, must-revalidate');
+		});
+
+		it('should return null for getCacheService when not configured', () => {
+			expect(matcherWithoutCache.getCacheService()).toBeNull();
+		});
+	});
+
+	describe('with cache service', () => {
+		const cacheService = new PageCacheService({
+			store: new MemoryCacheStore(),
+			enabled: true,
+		});
+
+		const matcherWithCache = new FileSystemResponseMatcher({
+			appConfig,
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+			cacheService,
+			defaultCacheStrategy: 'static',
+		});
+
+		it('should return cache service via getCacheService', () => {
+			expect(matcherWithCache.getCacheService()).toBe(cacheService);
+		});
+
+		it('should return X-Cache header on first request (MISS)', async () => {
+			const match: MatchResult = {
+				kind: 'exact',
+				pathname: '/cache-test-miss',
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: {},
+			};
+			const response = await matcherWithCache.handleMatch(match);
+			expect(response.headers.get('X-Cache')).toBe('MISS');
+			expect(response.headers.get('Cache-Control')).toBe('public, max-age=31536000, immutable');
+		});
+
+		it('should return X-Cache HIT on second request to same path', async () => {
+			const uniquePath = `/cache-test-hit-${Date.now()}`;
+			const match: MatchResult = {
+				kind: 'exact',
+				pathname: uniquePath,
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: {},
+			};
+
+			const response1 = await matcherWithCache.handleMatch(match);
+			const response2 = await matcherWithCache.handleMatch(match);
+
+			expect(response1.headers.get('X-Cache')).toBe('MISS');
+			expect(response2.headers.get('X-Cache')).toBe('HIT');
+		});
+
+		it('should cache different paths separately', async () => {
+			const match1: MatchResult = {
+				kind: 'exact',
+				pathname: '/path-a',
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: {},
+			};
+			const match2: MatchResult = {
+				kind: 'exact',
+				pathname: '/path-b',
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: {},
+			};
+
+			const response1 = await matcherWithCache.handleMatch(match1);
+			const response2 = await matcherWithCache.handleMatch(match2);
+
+			expect(response1.headers.get('X-Cache')).toBe('MISS');
+			expect(response2.headers.get('X-Cache')).toBe('MISS');
+		});
+
+		it('should include query params in cache key', async () => {
+			const basePath = `/search-${Date.now()}`;
+			const matchWithQuery: MatchResult = {
+				kind: 'exact',
+				pathname: basePath,
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: { q: 'test' },
+			};
+			const matchWithDifferentQuery: MatchResult = {
+				kind: 'exact',
+				pathname: basePath,
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: { q: 'other' },
+			};
+
+			const firstCall = await matcherWithCache.handleMatch(matchWithQuery);
+			const response1 = await matcherWithCache.handleMatch(matchWithQuery);
+			const response2 = await matcherWithCache.handleMatch(matchWithDifferentQuery);
+
+			expect(firstCall.headers.get('X-Cache')).toBe('MISS');
+			expect(response1.headers.get('X-Cache')).toBe('HIT');
+			expect(response2.headers.get('X-Cache')).toBe('MISS');
+		});
+	});
+
+	describe('with dynamic cache strategy', () => {
+		const cacheService = new PageCacheService({
+			store: new MemoryCacheStore(),
+			enabled: true,
+		});
+
+		const dynamicMatcher = new FileSystemResponseMatcher({
+			appConfig,
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+			cacheService,
+			defaultCacheStrategy: 'dynamic',
+		});
+
+		it('should bypass cache entirely for dynamic strategy', async () => {
+			const match: MatchResult = {
+				kind: 'exact',
+				pathname: '/dynamic-page',
+				filePath: INDEX_TEMPLATE_FILE,
+				params: {},
+				query: {},
+			};
+
+			const response1 = await dynamicMatcher.handleMatch(match);
+			const response2 = await dynamicMatcher.handleMatch(match);
+
+			expect(response1.headers.get('X-Cache')).toBe('DISABLED');
+			expect(response2.headers.get('X-Cache')).toBe('DISABLED');
+			expect(response1.headers.get('Cache-Control')).toBe('no-store, must-revalidate');
+		});
+	});
+
+	describe('handleNoMatch content type behavior', () => {
+		const matcher = new FileSystemResponseMatcher({
+			appConfig,
+			router,
+			routeRendererFactory,
+			fileSystemResponseFactory,
+		});
+
+		it('should return custom 404 page for known extension like .html', async () => {
+			const response = await matcher.handleNoMatch('/non-existent-page.html');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should return custom 404 page for page requests without extension', async () => {
+			const response = await matcher.handleNoMatch('/non-existent-page');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should return custom 404 page for unknown extensions', async () => {
+			const response = await matcher.handleNoMatch('/page.xyz');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should return custom 404 page for trailing dot', async () => {
+			const response = await matcher.handleNoMatch('/page.');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+
+		it('should serve text/plain files from disk', async () => {
+			const response = await matcher.handleNoMatch('/robots.txt');
+			expect(response.headers.get('Content-Type')).toBe('text/plain');
+		});
+
+		it('should return custom 404 page for non-existent static files', async () => {
+			const response = await matcher.handleNoMatch('/non-existent.txt');
+			const body = await response.text();
+			expect(body).toContain('<h1>404 - Page Not Found</h1>');
+		});
+	});
+
+	describe('internal transpile output', () => {
+		it('should write page metadata modules to the execution directory', async () => {
+			const matcher = new FileSystemResponseMatcher({
+				appConfig,
+				router,
+				routeRendererFactory,
+				fileSystemResponseFactory,
+			});
+
+			const importModule = vi.fn(async () => ({}));
+			(matcher as any).serverModuleTranspiler = {
+				importModule,
+			};
+
+			await (matcher as any).importPageModule(INDEX_TEMPLATE_FILE);
+
+			expect(importModule).toHaveBeenCalledWith(
+				expect.objectContaining({
+					filePath: INDEX_TEMPLATE_FILE,
+					outdir: path.join(resolveInternalExecutionDir(appConfig), '.server-modules-meta'),
+				}),
+			);
+		});
+	});
+});

package/src/adapters/shared/fs-server-response-matcher.ts

@@ -1,12 +1,14 @@
 import path from 'node:path';
 import { appLogger } from '../../global/app-logger.ts';
-import type { MatchResult } from '../../internal-types.ts';
+import type { EcoPagesAppConfig, MatchResult } from '../../internal-types.ts';
 import type { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
-import type { FSRouter } from '../../router/fs-router.ts';
+import type { FSRouter } from '../../router/server/fs-router.ts';
 import type { PageCacheService } from '../../services/cache/page-cache-service.ts';
 import type { CacheStrategy, RenderResult } from '../../services/cache/cache.types.ts';
-import { PageModuleImportService } from '../../services/page-module-import.service.ts';
-import { PageRequestCacheCoordinator } from '../../services/page-request-cache-coordinator.service.ts';
+import { PageRequestCacheCoordinator } from '../../services/cache/page-request-cache-coordinator.service.ts';
+import { getAppServerModuleTranspiler } from '../../services/module-loading/app-server-module-transpiler.service.ts';
+import type { ServerModuleTranspiler } from '../../services/module-loading/server-module-transpiler.service.ts';
+import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
 import { ServerUtils } from '../../utils/server-utils.module.ts';
 import type { Middleware, RequestLocals } from '../../public-types.ts';
 import { FileRouteMiddlewarePipeline } from './file-route-middleware-pipeline.ts';
@@ -21,6 +23,7 @@ export const FILE_SYSTEM_RESPONSE_MATCHER_ERRORS = {
 } as const;
 
 export interface FileSystemResponseMatcherOptions {
+	appConfig: EcoPagesAppConfig;
 	router: FSRouter;
 	routeRendererFactory: RouteRendererFactory;
 	fileSystemResponseFactory: FileSystemServerResponseFactory;
@@ -39,24 +42,27 @@ export interface FileSystemResponseMatcherOptions {
  * error translation.
  */
 export class FileSystemResponseMatcher {
+	private appConfig: EcoPagesAppConfig;
 	private router: FSRouter;
 	private routeRendererFactory: RouteRendererFactory;
 	private fileSystemResponseFactory: FileSystemServerResponseFactory;
-	private pageModuleImportService: PageModuleImportService;
+	private serverModuleTranspiler: ServerModuleTranspiler;
 	private pageRequestCacheCoordinator: PageRequestCacheCoordinator;
 	private fileRouteMiddlewarePipeline: FileRouteMiddlewarePipeline;
 
 	constructor({
+		appConfig,
 		router,
 		routeRendererFactory,
 		fileSystemResponseFactory,
 		cacheService = null,
 		defaultCacheStrategy = 'static',
 	}: FileSystemResponseMatcherOptions) {
+		this.appConfig = appConfig;
 		this.router = router;
 		this.routeRendererFactory = routeRendererFactory;
 		this.fileSystemResponseFactory = fileSystemResponseFactory;
-		this.pageModuleImportService = new PageModuleImportService();
+		this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
 		this.pageRequestCacheCoordinator = new PageRequestCacheCoordinator(cacheService, defaultCacheStrategy);
 		this.fileRouteMiddlewarePipeline = new FileRouteMiddlewarePipeline(cacheService);
 	}
@@ -174,16 +180,17 @@ export class FileSystemResponseMatcher {
 	 *
 	 * The matcher needs access to page-level metadata such as `cache` and
 	 * `middleware` before full rendering starts, so it uses the shared module
-	 * import service directly rather than going through route rendering.
+	 * import service directly rather than going through route rendering. The
+	 * app config is injected explicitly so build ownership stays at the adapter
+	 * boundary instead of leaking through nested router collaborators.
 	 *
 	 * @param filePath Absolute page module path.
 	 * @returns Imported page module.
 	 */
 	private async importPageModule(filePath: string): Promise<unknown> {
-		return this.pageModuleImportService.importModule({
+		return this.serverModuleTranspiler.importModule({
 			filePath,
-			rootDir: path.dirname(this.router.assetPrefix),
-			outdir: path.join(this.router.assetPrefix, '.server-modules-meta'),
+			outdir: path.join(resolveInternalExecutionDir(this.appConfig), '.server-modules-meta'),
 			transpileErrorMessage: FILE_SYSTEM_RESPONSE_MATCHER_ERRORS.transpilePageModuleFailed,
 			noOutputMessage: FILE_SYSTEM_RESPONSE_MATCHER_ERRORS.noTranspiledOutputForPageModule,
 		});