@ecopages/core 0.2.0-alpha.25 → 0.2.0-alpha.27

package/src/adapters/shared/explicit-static-route-matcher.ts

@@ -1,7 +1,8 @@
 import { appLogger } from '../../global/app-logger.ts';
 import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
 import type { StaticRoute } from '../../types/public-types.ts';
-import type { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
+import type { ExplicitViewRendererResolver } from '../../route-renderer/route-renderer.ts';
+import { prepareExplicitStaticRender } from './explicit-static-render-preparation.ts';
 
 export const EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS = {
 	missingIntegration: (routePath: string) =>
@@ -9,15 +10,9 @@ export const EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS = {
 	noRendererForIntegration: (integrationName: string) => `No renderer found for integration: ${integrationName}`,
 } as const;
 
-function getViewIntegrationName(view: {
-	config?: { integration?: string; __eco?: { integration?: string } };
-}): string | undefined {
-	return view.config?.integration ?? view.config?.__eco?.integration;
-}
-
 export interface ExplicitStaticRouteMatcherOptions {
 	appConfig: EcoPagesAppConfig;
-	routeRendererFactory: RouteRendererFactory;
+	routeRendererFactory: ExplicitViewRendererResolver;
 	staticRoutes: StaticRoute[];
 }
 
@@ -26,9 +21,12 @@ export interface ExplicitRouteMatch {
 	params: Record<string, string>;
 }
 
+/**
+ * Matches and renders explicit static routes declared through `app.static()`.
+ */
 export class ExplicitStaticRouteMatcher {
 	private readonly appConfig: EcoPagesAppConfig;
-	private readonly routeRendererFactory: RouteRendererFactory;
+	private readonly routeRendererFactory: ExplicitViewRendererResolver;
 	private readonly staticRoutes: StaticRoute[];
 
 	constructor({ appConfig, routeRendererFactory, staticRoutes }: ExplicitStaticRouteMatcherOptions) {
@@ -107,28 +105,21 @@ export class ExplicitStaticRouteMatcher {
 		try {
 			const mod = await route.loader();
 			const view = mod.default;
-
-			const integrationName = getViewIntegrationName(view);
-			if (!integrationName) {
-				throw new Error(EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS.missingIntegration(route.path));
-			}
-
-			const renderer = this.routeRendererFactory.getRendererByIntegration(integrationName);
-			if (!renderer) {
-				throw new Error(EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS.noRendererForIntegration(integrationName));
-			}
-
-			const props = view.staticProps
-				? (
-						await view.staticProps({
-							pathname: { params },
-							appConfig: this.appConfig,
-							runtimeOrigin: this.appConfig.baseUrl,
-						})
-					).props
-				: {};
-
-			return renderer.renderToResponse(view, props, {});
+			const {
+				renderer,
+				props,
+				view: renderableView,
+			} = await prepareExplicitStaticRender({
+				routePath: route.path,
+				view,
+				params,
+				appConfig: this.appConfig,
+				runtimeOrigin: this.appConfig.baseUrl,
+				routeRendererFactory: this.routeRendererFactory,
+				errors: EXPLICIT_STATIC_ROUTE_MATCHER_ERRORS,
+			});
+
+			return renderer.renderToResponse(renderableView, props, {});
 		} catch (error) {
 			appLogger.error(
 				`Error rendering explicit static route ${route.path}:`,

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import type { Middleware } from '../../types/public-types.ts';
+import type { FileRouteMiddleware } from '../../types/public-types.ts';
 import { LocalsAccessError } from '../../errors/locals-access-error.ts';
 import {
 	FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS,
@@ -30,21 +30,16 @@ describe('FileRouteMiddlewarePipeline', () => {
 		);
 	});
 
-	it('should create middleware context with render methods disabled', async () => {
+	it('should create middleware context without handler render methods', 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('render' in context).toBe(false);
+		expect('renderPartial' in context).toBe(false);
 
 		expect(context.require('user', () => new Response('missing', { status: 500 }))).toBe('andee');
 		expect(await context.html('<p>ok</p>').text()).toContain('<p>ok</p>');
@@ -60,7 +55,7 @@ describe('FileRouteMiddlewarePipeline', () => {
 		});
 		const events: string[] = [];
 
-		const middleware: Middleware[] = [
+		const middleware: FileRouteMiddleware[] = [
 			async (ctx, next) => {
 				events.push('first:before');
 				ctx.locals.first = true;

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

@@ -1,12 +1,10 @@
 import { createRequire } from '../../utils/locals-utils.ts';
-import type { Middleware, ApiHandlerContext, RequestLocals } from '../../types/public-types.ts';
+import type { FileRouteMiddleware, FileRouteMiddlewareContext, RequestLocals } from '../../types/public-types.ts';
 import type { PageCacheService } from '../../services/cache/page-cache-service.ts';
 import { ApiResponseBuilder } from './api-response.ts';
 import { LocalsAccessError } from '../../errors/locals-access-error.ts';
 
 export const FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS = {
-	CTX_RENDER_UNAVAILABLE: '[ecopages] ctx.render is not available in file-route middleware',
-	CTX_RENDER_PARTIAL_UNAVAILABLE: '[ecopages] ctx.renderPartial is not available in file-route middleware',
 	middlewareRequiresDynamic: (filePath: string) =>
 		`[ecopages] Page middleware requires cache: 'dynamic'. Page: ${filePath}`,
 } as const;
@@ -36,7 +34,7 @@ export class FileRouteMiddlewarePipeline {
 	 * @throws LocalsAccessError When middleware is configured for a non-dynamic page.
 	 */
 	assertValidConfiguration(input: {
-		middleware: Middleware[];
+		middleware: FileRouteMiddleware[];
 		pageCacheStrategy: 'static' | 'dynamic' | { revalidate: number; tags?: string[] };
 		filePath: string;
 	}): void {
@@ -50,9 +48,8 @@ export class FileRouteMiddlewarePipeline {
 	/**
 	 * Creates the request-scoped middleware context used by page middleware.
 	 *
-	 * The context intentionally disables `render()` and `renderPartial()` inside
-	 * file-route middleware because rendering is owned by the page route pipeline,
-	 * not by middleware stages.
+	 * The context intentionally omits `render()` and `renderPartial()` because
+	 * rendering is owned by the page route pipeline, not by middleware stages.
 	 *
 	 * @param input Request details and the mutable locals store.
 	 * @returns Middleware execution context.
@@ -61,8 +58,8 @@ export class FileRouteMiddlewarePipeline {
 		request: Request;
 		params: Record<string, string>;
 		locals: RequestLocals;
-	}): ApiHandlerContext {
-		const context: ApiHandlerContext = {
+	}): FileRouteMiddlewareContext {
+		const context: FileRouteMiddlewareContext = {
 			request: input.request,
 			params: input.params,
 			response: new ApiResponseBuilder(),
@@ -72,12 +69,6 @@ export class FileRouteMiddlewarePipeline {
 			},
 			locals: input.locals,
 			require: createRequire(() => context.locals as unknown as Record<string, unknown>),
-			render: async () => {
-				throw new Error(FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.CTX_RENDER_UNAVAILABLE);
-			},
-			renderPartial: async () => {
-				throw new Error(FILE_ROUTE_MIDDLEWARE_PIPELINE_ERRORS.CTX_RENDER_PARTIAL_UNAVAILABLE);
-			},
 			json: (data, options) => {
 				const builder = new ApiResponseBuilder();
 				if (options?.status) builder.status(options.status);
@@ -105,8 +96,8 @@ export class FileRouteMiddlewarePipeline {
 	 * @returns Response from middleware or final render stage.
 	 */
 	async run(input: {
-		middleware: Middleware[];
-		context: ApiHandlerContext;
+		middleware: FileRouteMiddleware[];
+		context: FileRouteMiddlewareContext;
 		renderResponse: () => Promise<Response>;
 	}): Promise<Response> {
 		if (input.middleware.length === 0) {

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

@@ -1,4 +1,5 @@
 import { beforeAll, describe, expect, it, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
 import {
 	FIXTURE_APP_PROJECT_DIR,
 	FIXTURE_EXISTING_CSS_FILE_IN_DIST,
@@ -7,7 +8,6 @@ import {
 import { appLogger } from '../../global/app-logger.ts';
 import { ConfigBuilder } from '../../config/config-builder.ts';
 import { STATUS_MESSAGE } from '../../config/constants.ts';
-import { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
 import { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
 
 let appConfig: Awaited<ReturnType<ConfigBuilder['build']>>;
@@ -23,11 +23,6 @@ describe('FileSystemServerResponseFactory', () => {
 		}
 
 		responseFactory = new FileSystemServerResponseFactory({
-			appConfig,
-			routeRendererFactory: new RouteRendererFactory({
-				appConfig,
-				runtimeOrigin: appConfig.baseUrl,
-			}),
 			options: {
 				watchMode: false,
 			},
@@ -54,11 +49,6 @@ describe('FileSystemServerResponseFactory', () => {
 	describe('shouldEnableGzip', () => {
 		it('should return false in watch mode', () => {
 			const responseFactoryWatch = new FileSystemServerResponseFactory({
-				appConfig,
-				routeRendererFactory: new RouteRendererFactory({
-					appConfig,
-					runtimeOrigin: appConfig.baseUrl,
-				}),
 				options: {
 					watchMode: true,
 				},
@@ -102,34 +92,9 @@ describe('FileSystemServerResponseFactory', () => {
 		});
 	});
 
-	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();
+	describe('createHtmlNotFoundResponse', () => {
+		it('should create an html 404 response from a rendered body', async () => {
+			const response = await responseFactory.createHtmlNotFoundResponse('<h1>404 - Page Not Found</h1>');
 			const body = await response.text();
 			expect(body).toContain('<h1>404 - Page Not Found</h1>');
 			expect(response.headers.get('Content-Type')).toBe('text/html');
@@ -139,18 +104,24 @@ describe('FileSystemServerResponseFactory', () => {
 
 	describe('createFileResponse', () => {
 		it('should create a response with the file content and content type', async () => {
+			const readFileAsBufferSpy = vi
+				.spyOn(fileSystem, 'readFileAsBuffer')
+				.mockReturnValue(Buffer.from('<svg></svg>'));
+
 			const response = await responseFactory.createFileResponse(
 				FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
 				'image/svg+xml',
 			);
+			readFileAsBufferSpy.mockRestore();
+			if (!response) {
+				throw new Error('Expected static file response');
+			}
 			expect(response.headers.get('Content-Type')).toBe('image/svg+xml');
 		});
 
-		it('should return custom 404 page if the file does not exist', async () => {
+		it('should return null 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);
+			expect(response).toBeNull();
 		});
 
 		it('should log debug for ENOENT errors', async () => {
@@ -168,18 +139,36 @@ describe('FileSystemServerResponseFactory', () => {
 
 		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 existsSpy = vi
+				.spyOn(fileSystem, 'exists')
+				.mockImplementation((filePath) => filePath === `${cssFilePath}.gz`);
+			const readFileAsBufferSpy = vi
+				.spyOn(fileSystem, 'readFileAsBuffer')
+				.mockReturnValue(Buffer.from('body{color:red}'));
 			const response = await responseFactory.createFileResponse(cssFilePath, 'text/css');
+			existsSpy.mockRestore();
+			readFileAsBufferSpy.mockRestore();
 
+			if (!response) {
+				throw new Error('Expected gzip file response');
+			}
 			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 readFileAsBufferSpy = vi
+				.spyOn(fileSystem, 'readFileAsBuffer')
+				.mockReturnValue(Buffer.from('<svg></svg>'));
 			const response = await responseFactory.createFileResponse(
 				FIXTURE_EXISTING_SVG_FILE_IN_DIST_PATH,
 				'image/svg+xml',
 			);
+			readFileAsBufferSpy.mockRestore();
 
+			if (!response) {
+				throw new Error('Expected non-gzip file response');
+			}
 			expect(response.headers.get('Content-Type')).toBe('image/svg+xml');
 			expect(response.headers.get('Content-Encoding')).toBeNull();
 		});

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

@@ -1,26 +1,16 @@
 import { STATUS_MESSAGE } from '../../config/constants.ts';
 import { appLogger } from '../../global/app-logger.ts';
-import type { EcoPagesAppConfig, FileSystemServerOptions } from '../../types/internal-types.ts';
+import type { FileSystemServerOptions } from '../../types/internal-types.ts';
 import type { RouteRendererBody } from '../../types/public-types.ts';
-import type { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
 import { fileSystem } from '@ecopages/file-system';
 
+/**
+ * Builds HTTP responses for static files and shared file-system fallbacks.
+ */
 export class FileSystemServerResponseFactory {
-	private appConfig: EcoPagesAppConfig;
-	private routeRendererFactory: RouteRendererFactory;
 	private options: FileSystemServerOptions;
 
-	constructor({
-		appConfig,
-		routeRendererFactory,
-		options,
-	}: {
-		appConfig: EcoPagesAppConfig;
-		routeRendererFactory: RouteRendererFactory;
-		options: FileSystemServerOptions;
-	}) {
-		this.appConfig = appConfig;
-		this.routeRendererFactory = routeRendererFactory;
+	constructor({ options }: { options: FileSystemServerOptions }) {
 		this.options = options;
 	}
 
@@ -51,26 +41,11 @@ export class FileSystemServerResponseFactory {
 		});
 	}
 
-	async createCustomNotFoundResponse() {
-		const error404TemplatePath = this.appConfig.absolutePaths.error404TemplatePath;
-
-		try {
-			fileSystem.verifyFileExists(error404TemplatePath);
-		} catch {
-			appLogger.debug(
-				'Custom 404 template not found, falling back to default 404 response',
-				error404TemplatePath,
-			);
-			return this.createDefaultNotFoundResponse();
-		}
-
-		const routeRenderer = this.routeRendererFactory.createRenderer(error404TemplatePath);
-
-		const result = await routeRenderer.createRoute({
-			file: error404TemplatePath,
-		});
-
-		return await this.createResponseWithBody(result.body, {
+	/**
+	 * Wraps already-rendered HTML in a 404 response envelope.
+	 */
+	async createHtmlNotFoundResponse(body: RouteRendererBody) {
+		return await this.createResponseWithBody(body, {
 			status: 404,
 			statusText: STATUS_MESSAGE[404],
 			headers: {
@@ -79,7 +54,10 @@ export class FileSystemServerResponseFactory {
 		});
 	}
 
-	async createFileResponse(filePath: string, contentType: string) {
+	/**
+	 * Reads a static file response, returning `null` when the file is missing.
+	 */
+	async createFileResponse(filePath: string, contentType: string): Promise<Response | null> {
 		try {
 			let file: Buffer;
 			const contentEncodingHeader: HeadersInit = {};
@@ -112,7 +90,7 @@ export class FileSystemServerResponseFactory {
 			} else {
 				appLogger.error('Error reading file', filePath, err);
 			}
-			return this.createCustomNotFoundResponse();
+			return null;
 		}
 	}
 }

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

@@ -1,11 +1,11 @@
 import { describe, expect, it, vi } from 'vitest';
+import { fileSystem } from '@ecopages/file-system';
 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 '../../types/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 { RouteRegistry } from '../../router/server/route-registry.ts';
 import { MemoryCacheStore } from '../../services/cache/memory-cache-store.ts';
 import { PageCacheService } from '../../services/cache/page-cache-service.ts';
 import { FileSystemServerResponseFactory } from './fs-server-response-factory.ts';
@@ -18,21 +18,18 @@ for (const integration of appConfig.integrations) {
 	integration.setRuntimeOrigin(appConfig.baseUrl);
 }
 
-const scanner = new FSRouterScanner({
-	dir: path.join(appConfig.rootDir, appConfig.srcDir, appConfig.pagesDir),
+const router = new RouteRegistry({
+	pagesDir: path.join(appConfig.rootDir, appConfig.srcDir, appConfig.pagesDir),
 	appConfig,
 	origin: appConfig.baseUrl,
 	templatesExt: appConfig.templatesExt,
-	options: {
-		buildMode: false,
+	buildMode: false,
+	pageModuleAdapter: {
+		loadPageModule: vi.fn(async () => ({})),
 	},
 });
 
-const router = new FSRouter({
-	origin: appConfig.baseUrl,
-	assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
-	scanner,
-});
+await router.init();
 
 const routeRendererFactory = new RouteRendererFactory({
 	appConfig,
@@ -40,8 +37,6 @@ const routeRendererFactory = new RouteRendererFactory({
 });
 
 const fileSystemResponseFactory = new FileSystemServerResponseFactory({
-	appConfig,
-	routeRendererFactory,
 	options: {
 		watchMode: false,
 	},
@@ -51,6 +46,7 @@ describe('FileSystemResponseMatcher', () => {
 	describe('without cache service', () => {
 		const matcherWithoutCache = new FileSystemResponseMatcher({
 			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
 			router,
 			routeRendererFactory,
 			fileSystemResponseFactory,
@@ -65,9 +61,12 @@ describe('FileSystemResponseMatcher', () => {
 
 		it('should handle match with disabled cache headers', async () => {
 			const match: MatchResult = {
-				kind: 'exact',
-				pathname: APP_TEST_ROUTES.index,
-				filePath: INDEX_TEMPLATE_FILE,
+				requestedPathname: APP_TEST_ROUTES.index,
+				templateRoute: {
+					kind: 'exact',
+					pathname: APP_TEST_ROUTES.index,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: {},
 			};
@@ -90,6 +89,7 @@ describe('FileSystemResponseMatcher', () => {
 
 		const matcherWithCache = new FileSystemResponseMatcher({
 			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
 			router,
 			routeRendererFactory,
 			fileSystemResponseFactory,
@@ -103,9 +103,12 @@ describe('FileSystemResponseMatcher', () => {
 
 		it('should return X-Cache header on first request (MISS)', async () => {
 			const match: MatchResult = {
-				kind: 'exact',
-				pathname: '/cache-test-miss',
-				filePath: INDEX_TEMPLATE_FILE,
+				requestedPathname: '/cache-test-miss',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/cache-test-miss',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: {},
 			};
@@ -117,9 +120,12 @@ describe('FileSystemResponseMatcher', () => {
 		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,
+				requestedPathname: uniquePath,
+				templateRoute: {
+					kind: 'exact',
+					pathname: uniquePath,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: {},
 			};
@@ -133,16 +139,22 @@ describe('FileSystemResponseMatcher', () => {
 
 		it('should cache different paths separately', async () => {
 			const match1: MatchResult = {
-				kind: 'exact',
-				pathname: '/path-a',
-				filePath: INDEX_TEMPLATE_FILE,
+				requestedPathname: '/path-a',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/path-a',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: {},
 			};
 			const match2: MatchResult = {
-				kind: 'exact',
-				pathname: '/path-b',
-				filePath: INDEX_TEMPLATE_FILE,
+				requestedPathname: '/path-b',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/path-b',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: {},
 			};
@@ -157,16 +169,22 @@ describe('FileSystemResponseMatcher', () => {
 		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,
+				requestedPathname: basePath,
+				templateRoute: {
+					kind: 'exact',
+					pathname: basePath,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: { q: 'test' },
 			};
 			const matchWithDifferentQuery: MatchResult = {
-				kind: 'exact',
-				pathname: basePath,
-				filePath: INDEX_TEMPLATE_FILE,
+				requestedPathname: basePath,
+				templateRoute: {
+					kind: 'exact',
+					pathname: basePath,
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: { q: 'other' },
 			};
@@ -189,6 +207,7 @@ describe('FileSystemResponseMatcher', () => {
 
 		const dynamicMatcher = new FileSystemResponseMatcher({
 			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
 			router,
 			routeRendererFactory,
 			fileSystemResponseFactory,
@@ -198,9 +217,12 @@ describe('FileSystemResponseMatcher', () => {
 
 		it('should bypass cache entirely for dynamic strategy', async () => {
 			const match: MatchResult = {
-				kind: 'exact',
-				pathname: '/dynamic-page',
-				filePath: INDEX_TEMPLATE_FILE,
+				requestedPathname: '/dynamic-page',
+				templateRoute: {
+					kind: 'exact',
+					pathname: '/dynamic-page',
+					filePath: INDEX_TEMPLATE_FILE,
+				},
 				params: {},
 				query: {},
 			};
@@ -217,6 +239,7 @@ describe('FileSystemResponseMatcher', () => {
 	describe('handleNoMatch content type behavior', () => {
 		const matcher = new FileSystemResponseMatcher({
 			appConfig,
+			assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
 			router,
 			routeRendererFactory,
 			fileSystemResponseFactory,
@@ -247,7 +270,9 @@ describe('FileSystemResponseMatcher', () => {
 		});
 
 		it('should serve text/plain files from disk', async () => {
+			const readFileAsBuffer = vi.spyOn(fileSystem, 'readFileAsBuffer').mockReturnValue(Buffer.from('robots'));
 			const response = await matcher.handleNoMatch('/robots.txt');
+			readFileAsBuffer.mockRestore();
 			expect(response.headers.get('Content-Type')).toBe('text/plain');
 		});
 
@@ -262,6 +287,7 @@ describe('FileSystemResponseMatcher', () => {
 		it('should inspect page modules through the owning route renderer', async () => {
 			const matcher = new FileSystemResponseMatcher({
 				appConfig,
+				assetPrefix: path.join(appConfig.rootDir, appConfig.distDir),
 				router,
 				routeRendererFactory,
 				fileSystemResponseFactory,
@@ -269,14 +295,14 @@ describe('FileSystemResponseMatcher', () => {
 
 			const loadPageModule = vi.fn(async () => ({}));
 			(matcher as any).routeRendererFactory = {
-				createRenderer: vi.fn(() => ({
+				getPageRenderer: vi.fn(() => ({
 					loadPageModule,
 				})),
 			};
 
 			await (matcher as any).importPageModule(INDEX_TEMPLATE_FILE);
 
-			expect((matcher as any).routeRendererFactory.createRenderer).toHaveBeenCalledWith(INDEX_TEMPLATE_FILE);
+			expect((matcher as any).routeRendererFactory.getPageRenderer).toHaveBeenCalledWith(INDEX_TEMPLATE_FILE);
 			expect(loadPageModule).toHaveBeenCalledWith(INDEX_TEMPLATE_FILE, {
 				cacheScope: 'request-metadata',
 			});