@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.28

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

@@ -1,15 +1,21 @@
 import { AbstractServerAdapter } from '../abstract/server-adapter.js';
 import type { ServerAdapterOptions, ServerAdapterResult } from '../abstract/server-adapter.js';
 import { RouteRendererFactory } from '../../route-renderer/route-renderer.js';
-import { FSRouter } from '../../router/server/fs-router.js';
+import { RouteRegistry } from '../../router/server/route-registry.js';
 import { SchemaValidationService } from '../../services/validation/schema-validation-service.js';
 import { StaticSiteGenerator } from '../../static-site-generator/static-site-generator.js';
 import { ServerStaticBuilder } from './server-static-builder.js';
 import { FileSystemResponseMatcher } from './fs-server-response-matcher.js';
 import { ServerRouteHandler } from './server-route-handler.js';
 import type { ApiHandler, CacheInvalidator, ErrorHandler, RenderContext, StaticRoute } from '../../types/public-types.js';
+type SharedRequestContext = {
+    apiHandlers: ApiHandler[];
+    errorHandler?: ErrorHandler;
+    serverInstance?: any;
+    hmrManager?: any;
+};
 export declare 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;
@@ -27,14 +33,15 @@ export declare abstract class SharedServerAdapter<TOptions extends ServerAdapter
         onError?: (error: Error) => Promise<void> | void;
     }): () => Promise<void>;
     /**
-     * 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 initSharedRouter(): Promise<void>;
+    private createRouteRegistryPageModuleAdapter;
     /**
      * Sets up the unified rendering pipeline and response matching chain.
      *
@@ -50,6 +57,8 @@ export declare abstract class SharedServerAdapter<TOptions extends ServerAdapter
      * @param hmrManager - The runtime-specific Hot Module Replacement orchestrator (if watching).
      */
     protected configureSharedResponseHandlers(staticRoutes: StaticRoute[], hmrManager?: any): void;
+    private createSharedResponseHandlerDependencies;
+    private createSharedPageCacheService;
     protected getCacheService(): CacheInvalidator | null;
     protected getRenderContext(): RenderContext;
     /**
@@ -70,6 +79,10 @@ export declare abstract class SharedServerAdapter<TOptions extends ServerAdapter
      * @returns The resulting Web standard `Response` constructed by the user's handler.
      */
     protected executeApiHandler(request: Request, params: Record<string, string | string[]>, routeConfig: ApiHandler, serverInstance: any, errorHandler?: ErrorHandler): Promise<Response>;
+    private createApiHandlerContext;
+    private normalizeApiParams;
+    private applyApiRequestSchema;
+    private runApiMiddlewareChain;
     private normalizePath;
     private matchApiPath;
     private getApiPathScore;
@@ -77,6 +90,8 @@ export declare abstract class SharedServerAdapter<TOptions extends ServerAdapter
         routeConfig: ApiHandler;
         params: Record<string, string | string[]>;
     } | null;
+    private tryHandleSharedHmrRequest;
+    private tryHandleSharedApiRequest;
     /**
      * Universally processes an incoming WinterCG Web standard Request.
      *
@@ -88,10 +103,6 @@ export declare abstract class SharedServerAdapter<TOptions extends ServerAdapter
      * Both Bun and Node bindings fall back to this exact function once they have mapped their
      * native HTTP objects into Web Standard Requests.
      */
-    handleSharedRequest(request: Request, context: {
-        apiHandlers: ApiHandler[];
-        errorHandler?: ErrorHandler;
-        serverInstance?: any;
-        hmrManager?: any;
-    }): Promise<Response>;
+    handleSharedRequest(request: Request, context: SharedRequestContext): Promise<Response>;
 }
+export {};

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

@@ -1,8 +1,7 @@
 import path from "node:path";
 import { AbstractServerAdapter } from "../abstract/server-adapter.js";
 import { RouteRendererFactory } from "../../route-renderer/route-renderer.js";
-import { FSRouter } from "../../router/server/fs-router.js";
-import { FSRouterScanner } from "../../router/server/fs-router-scanner.js";
+import { RouteRegistry } from "../../router/server/route-registry.js";
 import { MemoryCacheStore } from "../../services/cache/memory-cache-store.js";
 import { PageCacheService } from "../../services/cache/page-cache-service.js";
 import { SchemaValidationService } from "../../services/validation/schema-validation-service.js";
@@ -18,6 +17,8 @@ import { HttpError } from "../../errors/http-error.js";
 import { ApiResponseBuilder } from "./api-response.js";
 import { appLogger } from "../../global/app-logger.js";
 import { fileSystem } from "@ecopages/file-system";
+import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
 class SharedServerAdapter extends AbstractServerAdapter {
   router;
   fileSystemResponseMatcher;
@@ -50,30 +51,43 @@ class SharedServerAdapter extends AbstractServerAdapter {
     };
   }
   /**
-   * 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.
    */
   async initSharedRouter() {
-    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();
   }
+  createRouteRegistryPageModuleAdapter() {
+    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}`
+        });
+        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.
    *
@@ -94,40 +108,50 @@ class SharedServerAdapter extends AbstractServerAdapter {
       rendererModules: this.appConfig.runtime?.rendererModuleContext,
       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
+    });
+  }
+  createSharedResponseHandlerDependencies(staticRoutes) {
     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 = 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"
-    });
-    const explicitStaticRouteMatcher = staticRoutes.length > 0 ? new ExplicitStaticRouteMatcher({
-      appConfig: this.appConfig,
-      routeRendererFactory: this.routeRendererFactory,
-      staticRoutes
-    }) : void 0;
-    this.routeHandler = new ServerRouteHandler({
-      router: this.router,
-      fileSystemResponseMatcher: this.fileSystemResponseMatcher,
-      explicitStaticRouteMatcher,
-      watch: !!this.options?.watch,
-      hmrManager
+      defaultCacheStrategy: this.appConfig.cache?.defaultStrategy ?? "static"
     });
+    return {
+      cacheService,
+      fileSystemResponseMatcher,
+      explicitStaticRouteMatcher: staticRoutes.length > 0 ? new ExplicitStaticRouteMatcher({
+        appConfig: this.appConfig,
+        routeRendererFactory: this.routeRendererFactory,
+        staticRoutes
+      }) : void 0
+    };
+  }
+  createSharedPageCacheService() {
+    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 });
   }
   getCacheService() {
     return this.fileSystemResponseMatcher?.getCacheService() ?? null;
@@ -158,87 +182,18 @@ class SharedServerAdapter extends AbstractServerAdapter {
   async executeApiHandler(request, params, routeConfig, serverInstance, errorHandler) {
     let context;
     try {
-      const middleware = routeConfig.middleware || [];
-      const schema = routeConfig.schema;
-      const locals = {};
-      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(() => 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;
-        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 !== void 0) context.body = validated.body;
-        if (validated.query !== void 0) context.query = validated.query;
-        if (validated.headers !== void 0) context.headers = validated.headers;
-        if (validated.params !== void 0) context.params = validated.params;
+      context = this.createApiHandlerContext(request, params, serverInstance);
+      const schemaResponse = await this.applyApiRequestSchema(context, routeConfig.schema);
+      if (schemaResponse) {
+        return schemaResponse;
       }
-      if (middleware.length === 0) {
-        return await routeConfig.handler(context);
-      }
-      let index = 0;
-      const executeNext = async () => {
-        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 = {};
-            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(() => locals),
-              services: { cache: this.getCacheService() },
-              ...this.getRenderContext()
-            };
+            context = this.createApiHandlerContext(request, params, serverInstance);
           }
           return await errorHandler(error, context);
         } catch (handlerError) {
@@ -250,6 +205,76 @@ class SharedServerAdapter extends AbstractServerAdapter {
       return new Response("Internal Server Error", { status: 500 });
     }
   }
+  createApiHandlerContext(request, params, serverInstance) {
+    const locals = {};
+    const normalizedParams = this.normalizeApiParams(params);
+    return {
+      request,
+      params: normalizedParams,
+      response: new ApiResponseBuilder(),
+      server: serverInstance,
+      locals,
+      require: createRequire(() => locals),
+      services: {
+        cache: this.getCacheService()
+      },
+      ...this.getRenderContext()
+    };
+  }
+  normalizeApiParams(params) {
+    return Object.fromEntries(
+      Object.entries(params).map(([key, value]) => [key, Array.isArray(value) ? value.join("/") : value])
+    );
+  }
+  async applyApiRequestSchema(context, schema) {
+    if (!schema) {
+      return void 0;
+    }
+    const url = new URL(context.request.url);
+    const queryParams = Object.fromEntries(url.searchParams);
+    const headers = Object.fromEntries(context.request.headers);
+    let body;
+    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 !== void 0) context.body = validated.body;
+    if (validated.query !== void 0) context.query = validated.query;
+    if (validated.headers !== void 0) context.headers = validated.headers;
+    if (validated.params !== void 0) context.params = validated.params;
+    return void 0;
+  }
+  async runApiMiddlewareChain(context, routeConfig) {
+    const middleware = routeConfig.middleware || [];
+    if (middleware.length === 0) {
+      return await routeConfig.handler(context);
+    }
+    let index = 0;
+    const executeNext = async () => {
+      if (index < middleware.length) {
+        const currentMiddleware = middleware[index++];
+        return await currentMiddleware(context, executeNext);
+      }
+      return await routeConfig.handler(context);
+    };
+    return await executeNext();
+  }
   normalizePath(pathname) {
     if (pathname.length > 1 && pathname.endsWith("/")) {
       return pathname.slice(0, -1);
@@ -342,18 +367,7 @@ class SharedServerAdapter extends AbstractServerAdapter {
     }
     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.
-   */
-  async handleSharedRequest(request, context) {
+  tryHandleSharedHmrRequest(request, context) {
     const url = new URL(request.url);
     if (url.pathname === "/_hmr_runtime.js" && context.hmrManager) {
       const runtimePath = context.hmrManager.getRuntimePath();
@@ -372,15 +386,40 @@ class SharedServerAdapter extends AbstractServerAdapter {
         });
       }
     }
+    return null;
+  }
+  async tryHandleSharedApiRequest(request, context) {
     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.
+   */
+  async handleSharedRequest(request, context) {
+    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.d.ts

@@ -1,5 +1,5 @@
 import type { IHmrManager } from '../../types/public-types.js';
-import type { FSRouter } from '../../router/server/fs-router.js';
+import type { RouteRegistry } from '../../router/server/route-registry.js';
 import type { ExplicitStaticRouteMatcher } from './explicit-static-route-matcher.js';
 import type { FileSystemResponseMatcher } from './fs-server-response-matcher.js';
 /**
@@ -7,7 +7,7 @@ import type { FileSystemResponseMatcher } from './fs-server-response-matcher.js'
  */
 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. */

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

@@ -60,7 +60,7 @@ class ServerRouteHandler {
       const response2 = await this.explicitStaticRouteMatcher.handleMatch(explicitMatch);
       return this.maybeInjectHmrScript(response2);
     }
-    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) : this.handleNoMatch(request));
     return this.maybeInjectHmrScript(response);
   }

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

@@ -1,8 +1,8 @@
 import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 import type { ApiHandler, StaticRoute } from '../../types/public-types.js';
-import type { RouteRendererFactory } from '../../route-renderer/route-renderer.js';
-import type { FSRouter } from '../../router/server/fs-router.js';
+import type { RouteRegistry } from '../../router/server/route-registry.js';
 import type { StaticSiteGenerator } from '../../static-site-generator/static-site-generator.js';
+import type { StaticGenerationRendererResolver } from '../../route-renderer/route-renderer.js';
 export interface StaticBuildOptions {
     preview?: boolean;
     baseUrl?: string;
@@ -64,8 +64,8 @@ export declare class ServerStaticBuilder {
      * @param dependencies.staticRoutes - Explicit static routes registered via app.static()
      */
     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.d.ts

@@ -5,7 +5,7 @@
 import { type BuildOwnership } from '../build/build-adapter.js';
 import type { EcoBuildPlugin } from '../build/build-types.js';
 import type { EcoPagesAppConfig, RobotsPreference } from '../types/internal-types.js';
-import type { IntegrationPlugin } from '../plugins/integration-plugin.js';
+import type { AnyIntegrationPlugin } from '../plugins/integration-plugin.js';
 import type { Processor } from '../plugins/processor.js';
 import type { EcoSourceTransform } from '../plugins/source-transform.js';
 import type { PageMetadataProps } from '../types/public-types.js';
@@ -136,7 +136,7 @@ export declare 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;
     /**
      * Sets the output directory for the built application.
      *

package/src/config/config-builder.js

@@ -22,10 +22,6 @@ import {
   NoopEntrypointDependencyGraph,
   setAppEntrypointDependencyGraph
 } from "../services/runtime-state/entrypoint-dependency-graph.service.js";
-import {
-  InMemoryRuntimeSpecifierRegistry,
-  setAppRuntimeSpecifierRegistry
-} from "../services/runtime-state/runtime-specifier-registry.service.js";
 import {
   CounterServerInvalidationState,
   setAppServerInvalidationState
@@ -585,7 +581,6 @@ 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({

package/src/dev/host-runtime.d.ts

@@ -0,0 +1,10 @@
+import type { EcoPagesAppConfig } from '../types/public-types.js';
+import { type DevelopmentInvalidationPlan } from '../services/invalidation/development-invalidation.service.js';
+export type HostRuntimeModuleLoader = (id: string) => Promise<unknown>;
+export interface DevelopmentHostRuntime {
+    registerHostModuleLoader(loader: HostRuntimeModuleLoader): void;
+    planFileChange(filePath: string): DevelopmentInvalidationPlan;
+    invalidateServerModules(changedFiles?: string[]): void;
+    resetRuntimeState(changedFiles?: string[]): void;
+}
+export declare function createDevelopmentHostRuntime(appConfig: EcoPagesAppConfig): DevelopmentHostRuntime;

package/src/dev/host-runtime.js

@@ -0,0 +1,24 @@
+import {
+  DevelopmentInvalidationService
+} from "../services/invalidation/development-invalidation.service.js";
+import { setHostModuleLoader } from "../services/module-loading/host-module-loader-registry.js";
+function createDevelopmentHostRuntime(appConfig) {
+  const invalidationService = new DevelopmentInvalidationService(appConfig);
+  return {
+    registerHostModuleLoader(loader) {
+      setHostModuleLoader(loader);
+    },
+    planFileChange(filePath) {
+      return invalidationService.planFileChange(filePath);
+    },
+    invalidateServerModules(changedFiles) {
+      invalidationService.invalidateServerModules(changedFiles);
+    },
+    resetRuntimeState(changedFiles) {
+      invalidationService.resetRuntimeState(changedFiles);
+    }
+  };
+}
+export {
+  createDevelopmentHostRuntime
+};

package/src/eco/eco.js

@@ -1,6 +1,6 @@
 import {
   finalizeComponentRender,
-  interceptComponentBoundary
+  interceptForeignChild
 } from "../route-renderer/orchestration/component-render-context.js";
 import { isThenable } from "../route-renderer/orchestration/render-output.utils.js";
 function createComponentFactory(options) {
@@ -8,18 +8,18 @@ function createComponentFactory(options) {
   const comp = ((props) => {
     const componentProps = props ?? {};
     const renderInline = () => finalizeComponentRender(comp, options.render(props));
-    const boundaryRender = interceptComponentBoundary({
+    const foreignChildRender = interceptForeignChild({
       component: comp,
       props: componentProps,
       targetIntegration: integrationName
     });
-    if (isThenable(boundaryRender)) {
-      return boundaryRender.then(
-        (resolvedBoundaryRender) => resolvedBoundaryRender !== void 0 ? resolvedBoundaryRender : renderInline()
+    if (isThenable(foreignChildRender)) {
+      return foreignChildRender.then(
+        (resolvedForeignChildRender) => resolvedForeignChildRender !== void 0 ? resolvedForeignChildRender : renderInline()
       );
     }
-    if (boundaryRender !== void 0) {
-      return boundaryRender;
+    if (foreignChildRender !== void 0) {
+      return foreignChildRender;
     }
     return renderInline();
   });

package/src/eco/eco.types.d.ts

@@ -2,7 +2,7 @@
  * Type definitions for the eco namespace API
  * @module
  */
-import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, Middleware, RequestLocals, RequestPageContext } from '../types/public-types.js';
+import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, FileRouteMiddleware, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, RequestLocals, RequestPageContext } from '../types/public-types.js';
 import type { CacheStrategy } from '../services/cache/cache.types.js';
 type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
     [P in K]-?: Exclude<RequestLocals[P], null | undefined>;
@@ -86,7 +86,7 @@ interface PageOptionsWithMiddleware<T, E = EcoPagesElement> extends PageOptionsB
      * Request-time middleware for file-based routes.
      * Runs before rendering and can short-circuit by returning a Response.
      */
-    middleware: Middleware[];
+    middleware: FileRouteMiddleware[];
 }
 /**
  * Options for creating a page with eco.page()
@@ -127,7 +127,7 @@ export type EcoPageComponent<T> = EcoComponent<PagePropsFor<T> & Partial<Request
     metadata?: GetMetadata<T>;
     cache?: CacheStrategy;
     requires?: PageRequires;
-    middleware?: Middleware[];
+    middleware?: FileRouteMiddleware[];
 };
 /**
  * The eco namespace interface