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

package/src/adapters/shared/server-adapter.ts

@@ -2,8 +2,7 @@ import path from 'node:path';
 import { AbstractServerAdapter } from '../abstract/server-adapter.ts';
 import type { ServerAdapterOptions, ServerAdapterResult } from '../abstract/server-adapter.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 { SchemaValidationService } from '../../services/validation/schema-validation-service.ts';
@@ -19,6 +18,10 @@ import { HttpError } from '../../errors/http-error.ts';
 import { ApiResponseBuilder } from './api-response.ts';
 import { appLogger } from '../../global/app-logger.ts';
 import { fileSystem } from '@ecopages/file-system';
+import type { EcoPageFile } from '../../types/public-types.ts';
+import { getAppServerModuleTranspiler } from '../../services/module-loading/app-server-module-transpiler.service.ts';
+import { resolveInternalExecutionDir } from '../../utils/resolve-work-dir.ts';
+import type { RouteRegistryPageModuleAdapter } from '../../router/server/route-registry.ts';
 import type {
 	ApiHandler,
 	ApiHandlerContext,
@@ -28,11 +31,24 @@ import type {
 	StaticRoute,
 } from '../../types/public-types.ts';
 
+type SharedResponseHandlerDependencies = {
+	cacheService: PageCacheService | null;
+	fileSystemResponseMatcher: FileSystemResponseMatcher;
+	explicitStaticRouteMatcher?: ExplicitStaticRouteMatcher;
+};
+
+type SharedRequestContext = {
+	apiHandlers: ApiHandler[];
+	errorHandler?: ErrorHandler;
+	serverInstance?: any;
+	hmrManager?: any;
+};
+
 export abstract class SharedServerAdapter<
 	TOptions extends ServerAdapterOptions,
 	TResult extends ServerAdapterResult,
 > extends AbstractServerAdapter<TOptions, TResult> {
-	protected router!: FSRouter;
+	protected router!: RouteRegistry;
 	protected fileSystemResponseMatcher!: FileSystemResponseMatcher;
 	protected routeRendererFactory!: RouteRendererFactory;
 	protected routeHandler!: ServerRouteHandler;
@@ -76,33 +92,50 @@ export abstract class SharedServerAdapter<
 	}
 
 	/**
-	 * Scans the filesystem and dynamically constructs the universal router map.
+	 * Scans the filesystem and dynamically constructs the Route Registry.
 	 *
 	 * This process runs identically across both Bun and Node wrappers. It analyzes the configured pages
 	 * directory, building a map of all available UI routes and API endpoints.
-	 * The resulting `FSRouter` instance becomes the central nervous system for mapping WinterCG incoming
+	 * The resulting `RouteRegistry` instance becomes the central nervous system for mapping WinterCG incoming
 	 * Web Requests (`Request`) to their corresponding internal execution paths.
 	 */
 	protected async initSharedRouter(): Promise<void> {
-		const scanner = new FSRouterScanner({
-			dir: path.join(this.appConfig.rootDir, this.appConfig.srcDir, this.appConfig.pagesDir),
+		this.router = new RouteRegistry({
+			pagesDir: path.join(this.appConfig.rootDir, this.appConfig.srcDir, this.appConfig.pagesDir),
 			appConfig: this.appConfig,
 			origin: this.runtimeOrigin,
 			templatesExt: this.appConfig.templatesExt,
-			options: {
-				buildMode: !this.options?.watch,
-			},
-		});
-
-		this.router = new FSRouter({
-			origin: this.runtimeOrigin,
-			assetPrefix: path.join(this.appConfig.rootDir, this.appConfig.distDir),
-			scanner,
+			buildMode: !this.options?.watch,
+			pageModuleAdapter: this.createRouteRegistryPageModuleAdapter(),
 		});
 
 		await this.router.init();
 	}
 
+	private createRouteRegistryPageModuleAdapter(): RouteRegistryPageModuleAdapter {
+		const serverModuleTranspiler = getAppServerModuleTranspiler(this.appConfig);
+
+		return {
+			loadPageModule: async (filePath) => {
+				const module = (await serverModuleTranspiler.importModule({
+					filePath,
+					outdir: path.join(resolveInternalExecutionDir(this.appConfig), '.server-route-modules'),
+					externalPackages: false,
+					transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
+					noOutputMessage: (targetFilePath) =>
+						`No transpiled output generated for route module: ${targetFilePath}`,
+				})) as EcoPageFile;
+
+				const page = module.default;
+
+				return {
+					staticPaths: page?.staticPaths ?? module.getStaticPaths,
+					staticProps: page?.staticProps ?? module.getStaticProps,
+				};
+			},
+		};
+	}
+
 	/**
 	 * Sets up the unified rendering pipeline and response matching chain.
 	 *
@@ -124,51 +157,63 @@ export abstract class SharedServerAdapter<
 			runtimeOrigin: this.runtimeOrigin,
 		});
 
+		const { fileSystemResponseMatcher, explicitStaticRouteMatcher } =
+			this.createSharedResponseHandlerDependencies(staticRoutes);
+
+		this.fileSystemResponseMatcher = fileSystemResponseMatcher;
+		this.routeHandler = new ServerRouteHandler({
+			router: this.router,
+			fileSystemResponseMatcher: this.fileSystemResponseMatcher,
+			explicitStaticRouteMatcher,
+			watch: !!this.options?.watch,
+			hmrManager,
+		});
+	}
+
+	private createSharedResponseHandlerDependencies(staticRoutes: StaticRoute[]): SharedResponseHandlerDependencies {
 		const fileSystemResponseFactory = new FileSystemServerResponseFactory({
-			appConfig: this.appConfig,
-			routeRendererFactory: this.routeRendererFactory,
 			options: {
 				watchMode: !!this.options?.watch,
 			},
 		});
 
-		const cacheConfig = this.appConfig.cache;
-		const isCacheEnabled = cacheConfig?.enabled ?? !this.options?.watch;
-		let cacheService: PageCacheService | null = null;
-
-		if (isCacheEnabled) {
-			const store =
-				cacheConfig?.store === 'memory' || !cacheConfig?.store
-					? new MemoryCacheStore({ maxEntries: cacheConfig?.maxEntries })
-					: cacheConfig.store;
-			cacheService = new PageCacheService({ store, enabled: true });
-		}
-
-		this.fileSystemResponseMatcher = new FileSystemResponseMatcher({
+		const cacheService = this.createSharedPageCacheService();
+		const fileSystemResponseMatcher = new FileSystemResponseMatcher({
 			appConfig: this.appConfig,
+			assetPrefix: path.join(this.appConfig.rootDir, this.appConfig.distDir),
 			router: this.router,
 			routeRendererFactory: this.routeRendererFactory,
 			fileSystemResponseFactory,
 			cacheService,
-			defaultCacheStrategy: cacheConfig?.defaultStrategy ?? 'static',
+			defaultCacheStrategy: this.appConfig.cache?.defaultStrategy ?? 'static',
 		});
 
-		const explicitStaticRouteMatcher =
-			staticRoutes.length > 0
-				? new ExplicitStaticRouteMatcher({
-						appConfig: this.appConfig,
-						routeRendererFactory: this.routeRendererFactory,
-						staticRoutes,
-					})
-				: undefined;
+		return {
+			cacheService,
+			fileSystemResponseMatcher,
+			explicitStaticRouteMatcher:
+				staticRoutes.length > 0
+					? new ExplicitStaticRouteMatcher({
+							appConfig: this.appConfig,
+							routeRendererFactory: this.routeRendererFactory,
+							staticRoutes,
+						})
+					: undefined,
+		};
+	}
 
-		this.routeHandler = new ServerRouteHandler({
-			router: this.router,
-			fileSystemResponseMatcher: this.fileSystemResponseMatcher,
-			explicitStaticRouteMatcher,
-			watch: !!this.options?.watch,
-			hmrManager,
-		});
+	private createSharedPageCacheService(): PageCacheService | null {
+		const cacheConfig = this.appConfig.cache;
+		const isCacheEnabled = cacheConfig?.enabled ?? !this.options?.watch;
+		if (!isCacheEnabled) {
+			return null;
+		}
+
+		const store =
+			cacheConfig?.store === 'memory' || !cacheConfig?.store
+				? new MemoryCacheStore({ maxEntries: cacheConfig?.maxEntries })
+				: cacheConfig.store;
+		return new PageCacheService({ store, enabled: true });
 	}
 
 	protected getCacheService(): CacheInvalidator | null {
@@ -209,98 +254,20 @@ export abstract class SharedServerAdapter<
 		let context: ApiHandlerContext<Request, any> | undefined;
 
 		try {
-			const middleware = routeConfig.middleware || [];
-			const schema = routeConfig.schema;
-			const locals: Record<string, unknown> = {};
-
-			const normalizedParams = Object.fromEntries(
-				Object.entries(params).map(([key, value]) => [key, Array.isArray(value) ? value.join('/') : value]),
-			);
-
-			context = {
-				request,
-				params: normalizedParams,
-				response: new ApiResponseBuilder(),
-				server: serverInstance,
-				locals,
-				require: createRequire((): Record<string, unknown> => locals),
-				services: {
-					cache: this.getCacheService(),
-				},
-				...this.getRenderContext(),
-			};
-
-			if (schema) {
-				const url = new URL(request.url);
-				const queryParams = Object.fromEntries(url.searchParams);
-				const headers = Object.fromEntries(request.headers);
-
-				let body: unknown;
-				if (schema.body) {
-					try {
-						const contentType = request.headers.get('Content-Type') || '';
-						if (contentType.includes('application/json')) body = await request.clone().json();
-						else if (contentType.includes('text/plain')) body = await request.clone().text();
-					} catch {
-						return context.response.status(400).json({ error: 'Invalid request body' });
-					}
-				}
-
-				const validationResult = await this.schemaValidator.validateRequest(
-					{ body, query: queryParams, headers, params: normalizedParams },
-					schema,
-				);
-
-				if (!validationResult.success) {
-					return context.response.status(400).json({
-						error: 'Validation failed',
-						issues: validationResult.errors,
-					});
-				}
-
-				const validated = validationResult.data!;
-				if (validated.body !== undefined) context.body = validated.body;
-				if (validated.query !== undefined) context.query = validated.query;
-				if (validated.headers !== undefined) context.headers = validated.headers;
-				if (validated.params !== undefined) context.params = validated.params as Record<string, string>;
-			}
-
-			if (middleware.length === 0) {
-				return await routeConfig.handler(context);
+			context = this.createApiHandlerContext(request, params, serverInstance);
+			const schemaResponse = await this.applyApiRequestSchema(context, routeConfig.schema);
+			if (schemaResponse) {
+				return schemaResponse;
 			}
 
-			let index = 0;
-			const executeNext = async (): Promise<Response> => {
-				if (index < middleware.length) {
-					const currentMiddleware = middleware[index++];
-					return await currentMiddleware(context!, executeNext);
-				}
-				return await routeConfig.handler(context!);
-			};
-
-			return await executeNext();
+			return await this.runApiMiddlewareChain(context, routeConfig);
 		} catch (error) {
 			if (error instanceof Response) return error;
 
 			if (errorHandler) {
 				try {
 					if (!context) {
-						const locals: Record<string, unknown> = {};
-						context = {
-							request,
-							params: Object.fromEntries(
-								Object.entries(params).map(([key, value]) => [
-									key,
-									Array.isArray(value) ? value.join('/') : value,
-								]),
-							),
-							response: new ApiResponseBuilder(),
-							server: serverInstance,
-							locals,
-							require: createRequire((): Record<string, unknown> => locals),
-							services: { cache: this.getCacheService() },
-							...this.getRenderContext(),
-						};
+						context = this.createApiHandlerContext(request, params, serverInstance);
 					}
 					return await errorHandler(error, context);
 				} catch (handlerError) {
@@ -314,6 +281,98 @@ export abstract class SharedServerAdapter<
 		}
 	}
 
+	private createApiHandlerContext(
+		request: Request,
+		params: Record<string, string | string[]>,
+		serverInstance: any,
+	): ApiHandlerContext<Request, any> {
+		const locals: Record<string, unknown> = {};
+		const normalizedParams = this.normalizeApiParams(params);
+
+		return {
+			request,
+			params: normalizedParams,
+			response: new ApiResponseBuilder(),
+			server: serverInstance,
+			locals,
+			require: createRequire((): Record<string, unknown> => locals),
+			services: {
+				cache: this.getCacheService(),
+			},
+			...this.getRenderContext(),
+		};
+	}
+
+	private normalizeApiParams(params: Record<string, string | string[]>): Record<string, string> {
+		return Object.fromEntries(
+			Object.entries(params).map(([key, value]) => [key, Array.isArray(value) ? value.join('/') : value]),
+		);
+	}
+
+	private async applyApiRequestSchema(
+		context: ApiHandlerContext<Request, any>,
+		schema: ApiHandler['schema'],
+	): Promise<Response | undefined> {
+		if (!schema) {
+			return undefined;
+		}
+
+		const url = new URL(context.request.url);
+		const queryParams = Object.fromEntries(url.searchParams);
+		const headers = Object.fromEntries(context.request.headers);
+
+		let body: unknown;
+		if (schema.body) {
+			try {
+				const contentType = context.request.headers.get('Content-Type') || '';
+				if (contentType.includes('application/json')) body = await context.request.clone().json();
+				else if (contentType.includes('text/plain')) body = await context.request.clone().text();
+			} catch {
+				return context.response.status(400).json({ error: 'Invalid request body' });
+			}
+		}
+
+		const validationResult = await this.schemaValidator.validateRequest(
+			{ body, query: queryParams, headers, params: context.params },
+			schema,
+		);
+
+		if (!validationResult.success) {
+			return context.response.status(400).json({
+				error: 'Validation failed',
+				issues: validationResult.errors,
+			});
+		}
+
+		const validated = validationResult.data!;
+		if (validated.body !== undefined) context.body = validated.body;
+		if (validated.query !== undefined) context.query = validated.query;
+		if (validated.headers !== undefined) context.headers = validated.headers;
+		if (validated.params !== undefined) context.params = validated.params as Record<string, string>;
+		return undefined;
+	}
+
+	private async runApiMiddlewareChain(
+		context: ApiHandlerContext<Request, any>,
+		routeConfig: ApiHandler,
+	): Promise<Response> {
+		const middleware = routeConfig.middleware || [];
+		if (middleware.length === 0) {
+			return await routeConfig.handler(context);
+		}
+
+		let index = 0;
+		const executeNext = async (): Promise<Response> => {
+			if (index < middleware.length) {
+				const currentMiddleware = middleware[index++];
+				return await currentMiddleware(context, executeNext);
+			}
+			return await routeConfig.handler(context);
+		};
+
+		return await executeNext();
+	}
+
 	private normalizePath(pathname: string): string {
 		if (pathname.length > 1 && pathname.endsWith('/')) {
 			return pathname.slice(0, -1);
@@ -435,26 +494,7 @@ export abstract class SharedServerAdapter<
 		return null;
 	}
 
-	/**
-	 * Universally processes an incoming WinterCG Web standard Request.
-	 *
-	 * 1. Resolves static Hot Module Replacement runtime blobs if development.
-	 * 2. Checks if the incoming request matches any parsed API route schemas.
-	 *   - Routes through `executeApiHandler` which performs strict validation.
-	 * 3. Falls through to standard `ServerRouteHandler` for React/Lit filesystem pages.
-	 *
-	 * Both Bun and Node bindings fall back to this exact function once they have mapped their
-	 * native HTTP objects into Web Standard Requests.
-	 */
-	public async handleSharedRequest(
-		request: Request,
-		context: {
-			apiHandlers: ApiHandler[];
-			errorHandler?: ErrorHandler;
-			serverInstance?: any;
-			hmrManager?: any;
-		},
-	): Promise<Response> {
+	private tryHandleSharedHmrRequest(request: Request, context: SharedRequestContext): Response | null {
 		const url = new URL(request.url);
 
 		if (url.pathname === '/_hmr_runtime.js' && context.hmrManager) {
@@ -477,15 +517,44 @@ export abstract class SharedServerAdapter<
 			}
 		}
 
+		return null;
+	}
+
+	private async tryHandleSharedApiRequest(request: Request, context: SharedRequestContext): Promise<Response | null> {
 		const apiMatch = this.matchApiHandler(request, context.apiHandlers);
-		if (apiMatch) {
-			return this.executeApiHandler(
-				request,
-				apiMatch.params,
-				apiMatch.routeConfig,
-				context.serverInstance,
-				context.errorHandler,
-			);
+		if (!apiMatch) {
+			return null;
+		}
+
+		return await this.executeApiHandler(
+			request,
+			apiMatch.params,
+			apiMatch.routeConfig,
+			context.serverInstance,
+			context.errorHandler,
+		);
+	}
+
+	/**
+	 * Universally processes an incoming WinterCG Web standard Request.
+	 *
+	 * 1. Resolves static Hot Module Replacement runtime blobs if development.
+	 * 2. Checks if the incoming request matches any parsed API route schemas.
+	 *   - Routes through `executeApiHandler` which performs strict validation.
+	 * 3. Falls through to standard `ServerRouteHandler` for React/Lit filesystem pages.
+	 *
+	 * Both Bun and Node bindings fall back to this exact function once they have mapped their
+	 * native HTTP objects into Web Standard Requests.
+	 */
+	public async handleSharedRequest(request: Request, context: SharedRequestContext): Promise<Response> {
+		const hmrResponse = this.tryHandleSharedHmrRequest(request, context);
+		if (hmrResponse) {
+			return hmrResponse;
+		}
+
+		const apiResponse = await this.tryHandleSharedApiRequest(request, context);
+		if (apiResponse) {
+			return apiResponse;
 		}
 
 		return this.routeHandler.handleResponse(request);

package/src/adapters/shared/server-route-handler.test.ts

@@ -1,13 +1,14 @@
 import { describe, expect, it, vi } from 'vitest';
 import { ServerRouteHandler } from './server-route-handler';
-import type { FSRouter } from '../../router/server/fs-router.ts';
+import type { RouteRegistry } from '../../router/server/route-registry.ts';
 import type { FileSystemResponseMatcher } from './fs-server-response-matcher.ts';
 import type { IHmrManager } from '../../types/public-types.ts';
 
 function createMockDependencies() {
 	const Router = {
-		match: vi.fn(() => null),
-	} as unknown as FSRouter;
+		matchRequest: vi.fn(() => null),
+		origin: 'http://localhost:3000',
+	} as unknown as RouteRegistry;
 
 	const FileSystemResponseMatcher = {
 		handleMatch: vi.fn(() => Promise.resolve(new Response('Matched Content'))),
@@ -35,7 +36,7 @@ describe('ServerRouteHandler', () => {
 				fileSystemResponseMatcher: FileSystemResponseMatcher,
 			});
 
-			Router.match = vi.fn(
+			Router.matchRequest = vi.fn(
 				() =>
 					({
 						/* match */
@@ -71,7 +72,7 @@ describe('ServerRouteHandler', () => {
 				hmrManager: HmrManager,
 			});
 
-			Router.match = vi.fn(() => ({}) as any);
+			Router.matchRequest = vi.fn(() => ({}) as any);
 			FileSystemResponseMatcher.handleMatch = vi.fn(() =>
 				Promise.resolve(
 					new Response('<html><body></body></html>', { headers: { 'Content-Type': 'text/html' } }),

package/src/adapters/shared/server-route-handler.ts

@@ -1,5 +1,5 @@
 import type { IHmrManager } from '../../types/public-types.ts';
-import type { FSRouter } from '../../router/server/fs-router.ts';
+import type { RouteRegistry } from '../../router/server/route-registry.ts';
 import type { ExplicitStaticRouteMatcher } from './explicit-static-route-matcher.ts';
 import type { FileSystemResponseMatcher } from './fs-server-response-matcher.ts';
 import { appLogger } from '../../global/app-logger.ts';
@@ -11,7 +11,7 @@ import { injectHmrRuntimeIntoHtmlResponse, isHtmlResponse, shouldInjectHmrHtmlRe
  */
 export interface ServerRouteHandlerParams {
 	/** File system router for matching request URLs to route handlers. */
-	router: FSRouter;
+	router: RouteRegistry;
 	/** Matcher for handling file system route responses. */
 	fileSystemResponseMatcher: FileSystemResponseMatcher;
 	/** Optional matcher for explicit static routes like processed images or sitemaps. */
@@ -33,7 +33,7 @@ export interface ServerRouteHandlerParams {
  * In development mode, it also injects HMR scripts into HTML responses.
  */
 export class ServerRouteHandler {
-	private readonly router: FSRouter;
+	private readonly router: RouteRegistry;
 	private readonly fileSystemResponseMatcher: FileSystemResponseMatcher;
 	private readonly explicitStaticRouteMatcher?: ExplicitStaticRouteMatcher;
 	private readonly watch: boolean;
@@ -98,7 +98,7 @@ export class ServerRouteHandler {
 			return this.maybeInjectHmrScript(response);
 		}
 
-		const fsMatch = !pathname.includes('.') && this.router.match(request.url);
+		const fsMatch = !pathname.includes('.') && this.router.matchRequest(request.url);
 
 		const response = await (fsMatch
 			? this.fileSystemResponseMatcher.handleMatch(fsMatch, request)

package/src/adapters/shared/server-static-builder.test.ts

@@ -8,8 +8,8 @@ import {
 } from './server-static-builder';
 import type { EcoPagesAppConfig } from '../../types/internal-types';
 import type { StaticSiteGenerator } from '../../static-site-generator/static-site-generator';
-import type { FSRouter } from '../../router/server/fs-router';
-import type { RouteRendererFactory } from '../../route-renderer/route-renderer';
+import type { RouteRegistry } from '../../router/server/route-registry';
+import type { StaticGenerationRendererResolver } from '../../route-renderer/route-renderer';
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
@@ -68,8 +68,8 @@ function createMockDependencies() {
 		port: 3000,
 	};
 
-	const Router = {} as FSRouter;
-	const RouteRendererFactory = {} as RouteRendererFactory;
+	const Router = {} as RouteRegistry;
+	const RouteRendererFactory = {} as StaticGenerationRendererResolver;
 	const logger: ServerStaticBuilderLogger = {
 		warn: (message: string, detail?: string) => {
 			calls.warn.push([message, detail]);

package/src/adapters/shared/server-static-builder.ts

@@ -5,9 +5,9 @@ import { StaticContentServer } from '../../dev/sc-server.ts';
 import { appLogger } from '../../global/app-logger.ts';
 import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
 import type { ApiHandler, StaticRoute } from '../../types/public-types.ts';
-import type { RouteRendererFactory } from '../../route-renderer/route-renderer.ts';
-import type { FSRouter } from '../../router/server/fs-router.ts';
+import type { RouteRegistry } from '../../router/server/route-registry.ts';
 import type { StaticSiteGenerator } from '../../static-site-generator/static-site-generator.ts';
+import type { StaticGenerationRendererResolver } from '../../route-renderer/route-renderer.ts';
 
 export interface StaticBuildOptions {
 	preview?: boolean;
@@ -128,8 +128,8 @@ export class ServerStaticBuilder {
 	async build(
 		options: StaticBuildOptions | undefined,
 		dependencies: {
-			router: FSRouter;
-			routeRendererFactory: RouteRendererFactory;
+			router: RouteRegistry;
+			routeRendererFactory: StaticGenerationRendererResolver;
 			staticRoutes?: StaticRoute[];
 		},
 	): Promise<void> {

package/src/config/README.md

@@ -12,7 +12,7 @@ It is responsible for:
 
 - validating integration, processor, and loader registration
 - resolving semantic paths such as `html` and `404` templates
-- selecting explicit build ownership and creating app-owned runtime state such as the build adapter, build executor, build manifest, dev graph service, runtime specifier registry, and remaining compatibility-only runtime state
+- selecting explicit build ownership and creating app-owned runtime state such as the build adapter, build executor, build manifest, dev graph service, and remaining compatibility-only runtime state
 - enforcing runtime capability requirements before startup
 - carrying host-injected runtime dependencies only through abstract slots such as host module loaders, never through bundler-specific core defaults
 

package/src/config/config-builder.test.ts

@@ -67,7 +67,6 @@ describe('EcoConfigBuilder', () => {
 		expect(createVitePluginsFromAppSourceTransforms(config).length).toBeGreaterThan(0);
 		expect(config.runtime?.serverInvalidationState).toBeDefined();
 		expect(config.runtime?.entrypointDependencyGraph).toBeDefined();
-		expect(config.runtime?.runtimeSpecifierRegistry).toBeDefined();
 	});
 
 	test('should allow explicit Vite-host build ownership during config build', async () => {

package/src/config/config-builder.ts

@@ -26,7 +26,7 @@ import { ghtmlPlugin } from '../integrations/ghtml/ghtml.plugin.ts';
 import type { EcoPagesAppConfig, RobotsPreference } from '../types/internal-types.ts';
 import { createEcoComponentMetaPlugin } from '../plugins/eco-component-meta-plugin.ts';
 import { createEcoComponentMetaTransform } from '../plugins/eco-component-meta-plugin.ts';
-import type { IntegrationPlugin } from '../plugins/integration-plugin.ts';
+import type { AnyIntegrationPlugin } from '../plugins/integration-plugin.ts';
 import type { Processor } from '../plugins/processor.ts';
 import type { EcoSourceTransform } from '../plugins/source-transform.ts';
 import type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from '../plugins/runtime-capability.ts';
@@ -36,10 +36,6 @@ import {
 	NoopEntrypointDependencyGraph,
 	setAppEntrypointDependencyGraph,
 } from '../services/runtime-state/entrypoint-dependency-graph.service.ts';
-import {
-	InMemoryRuntimeSpecifierRegistry,
-	setAppRuntimeSpecifierRegistry,
-} from '../services/runtime-state/runtime-specifier-registry.service.ts';
 import {
 	CounterServerInvalidationState,
 	setAppServerInvalidationState,
@@ -283,7 +279,7 @@ export class ConfigBuilder {
 	 * @param integrations - An array of integration plugins
 	 * @returns The ConfigBuilder instance for method chaining
 	 */
-	setIntegrations(integrations: IntegrationPlugin<unknown>[]): this {
+	setIntegrations(integrations: AnyIntegrationPlugin[]): this {
 		this.config.integrations = integrations;
 		return this;
 	}
@@ -727,7 +723,6 @@ export class ConfigBuilder {
 		updateAppBuildManifest(this.config, await collectConfiguredAppBuildManifestContributions(this.config));
 		setAppServerInvalidationState(this.config, new CounterServerInvalidationState());
 		setAppEntrypointDependencyGraph(this.config, new NoopEntrypointDependencyGraph());
-		setAppRuntimeSpecifierRegistry(this.config, new InMemoryRuntimeSpecifierRegistry());
 		setAppBuildExecutor(
 			this.config,
 			createAppBuildExecutor({