@ecopages/core 0.2.0-alpha.1 → 0.2.0-alpha.10

package/src/adapters/bun/hmr-manager.d.ts

@@ -1,7 +1,7 @@
 import type { WebSocketHandler } from 'bun';
 import type { DefaultHmrContext, EcoPagesAppConfig, IHmrManager } from '../../internal-types';
 import type { EcoBuildPlugin } from '../../build/build-types.js';
-import type { HmrStrategy } from '../../hmr/hmr-strategy';
+import { type HmrStrategy } from '../../hmr/hmr-strategy';
 import type { ClientBridge } from './client-bridge';
 import type { ClientBridgeEvent } from '../../public-types';
 type BunSocketHandler = WebSocketHandler<unknown>;
@@ -9,19 +9,35 @@ export interface HmrManagerParams {
     appConfig: EcoPagesAppConfig;
     bridge: ClientBridge;
 }
+type HandleFileChangeOptions = {
+    broadcast?: boolean;
+};
+/**
+ * Bun development HMR manager.
+ *
+ * @remarks
+ * Bun shares the same public contract as the Node manager: page entrypoints are
+ * strict integration-owned registrations, while generic script assets use their
+ * own explicit registration path.
+ */
 export declare class HmrManager implements IHmrManager {
+    private static readonly entrypointRegistrationTimeoutMs;
     readonly appConfig: EcoPagesAppConfig;
     private readonly bridge;
     /** Keep track of watchers */
     private watchers;
     /** entrypoint -> output path */
     private watchedFiles;
-    /** bare specifier -> runtime URL (e.g., 'react' -> '/assets/vendors/react.js') */
-    private specifierMap;
+    private entrypointRegistrations;
     private distDir;
     private plugins;
     private enabled;
     private strategies;
+    private readonly entrypointRegistrar;
+    private readonly browserBundleService;
+    private readonly entrypointDependencyGraph;
+    private readonly runtimeSpecifierRegistry;
+    private readonly serverModuleTranspiler;
     private wsHandler;
     constructor({ appConfig, bridge }: HmrManagerParams);
     /**
@@ -31,6 +47,15 @@ export declare class HmrManager implements IHmrManager {
      * can share the same dist path during e2e runs.
      */
     private cleanDistDir;
+    /**
+     * Returns whether the generic JS strategy may rebuild an entrypoint.
+     *
+     * @remarks
+     * Integration-owned page entrypoints are excluded so a shared dependency
+     * invalidation cannot replace framework-owned browser output with a generic JS
+     * rebuild.
+     */
+    private shouldJsStrategyProcessEntrypoint;
     /**
      * Initializes core HMR strategies.
      * Strategies are evaluated in priority order (highest first).
@@ -46,9 +71,13 @@ export declare class HmrManager implements IHmrManager {
     setEnabled(enabled: boolean): void;
     isEnabled(): boolean;
     /**
-     * Registers a mapping from bare specifiers to vendor URLs.
-     * Used by integrations to provide their module resolution mappings.
-     * @param map - Object mapping bare specifiers to vendor URLs
+     * Registers runtime bare-specifier mappings exposed by integrations.
+     *
+     * @remarks
+     * These mappings are consumed by framework-owned HMR strategies that preserve
+     * shared runtime imports in browser bundles. The registry stays generic so
+     * these mappings can later support broader import-map-style runtime features
+     * without moving integration semantics into core.
      */
     registerSpecifierMap(map: Record<string, string>): void;
     getWebSocketHandler(): BunSocketHandler;
@@ -58,27 +87,57 @@ export declare class HmrManager implements IHmrManager {
     buildRuntime(): Promise<void>;
     getRuntimePath(): string;
     broadcast(event: ClientBridgeEvent): void;
-    /**
-     * Handles file changes using registered HMR strategies.
-     * Strategies are evaluated in priority order until one matches.
-     * @param filePath - Absolute path to the changed file
-     */
-    handleFileChange(filePath: string): Promise<void>;
-    /**
-     * Registers a client entrypoint to be built and watched by Bun.
-     */
+    handleFileChange(filePath: string, options?: HandleFileChangeOptions): Promise<void>;
     getOutputUrl(entrypointPath: string): string | undefined;
     getWatchedFiles(): Map<string, string>;
     getSpecifierMap(): Map<string, string>;
     getDistDir(): string;
     getPlugins(): EcoBuildPlugin[];
     getDefaultContext(): DefaultHmrContext;
+    private clearFailedEntrypointRegistration;
+    /**
+     * Registers one integration-owned page entrypoint.
+     *
+     * @remarks
+     * Concurrent callers share one in-flight registration. The registration is
+     * cleared from the dedupe map when it settles so later callers cannot inherit a
+     * stale promise.
+     */
     registerEntrypoint(entrypointPath: string): Promise<string>;
     /**
-     * Encodes dynamic route segments (brackets) in file paths.
-     * Converts `[slug]` to `_slug_` to avoid filesystem/URL issues.
+     * Registers one generic script entrypoint.
+     *
+     * @remarks
+     * This explicit path keeps the page-entrypoint contract strict while still
+     * allowing generic script assets to use the fallback build path.
+     */
+    registerScriptEntrypoint(entrypointPath: string): Promise<string>;
+    /**
+     * Performs strict integration-owned registration for one normalized path.
+     *
+     * @remarks
+     * The manager reserves the output URL, removes any stale emitted file, runs
+     * strategy processing without broadcasting, and then verifies that the owning
+     * integration emitted the expected file.
+     */
+    private emitStrictEntrypoint;
+    /**
+     * Performs registration for a generic script asset.
+     *
+     * @remarks
+     * Strategies get the first chance to emit output. If no output exists after
+     * that pass, Bun falls back to the generic browser build for this explicit
+     * script-only path.
+     */
+    private emitScriptEntrypoint;
+    /**
+     * Stops active watchers and releases retained registration state.
+     *
+     * @remarks
+     * Emitted `_hmr` files remain on disk because parallel app processes may share
+     * the same dist directory. The in-memory indexes are cleared so stale
+     * entrypoints and specifier maps cannot leak through a reused manager object.
      */
-    private encodeDynamicSegments;
     stop(): void;
 }
 export {};

package/src/adapters/bun/hmr-manager.js

@@ -1,29 +1,59 @@
 import fs from "node:fs";
 import path from "node:path";
 import { RESOLVED_ASSETS_DIR } from "../../constants";
-import { defaultBuildAdapter } from "../../build/build-adapter.js";
+import { getAppBuildExecutor } from "../../build/build-adapter.js";
 import { fileSystem } from "@ecopages/file-system";
+import { HmrStrategyType } from "../../hmr/hmr-strategy";
 import { DefaultHmrStrategy } from "../../hmr/strategies/default-hmr-strategy";
 import { JsHmrStrategy } from "../../hmr/strategies/js-hmr-strategy";
 import { appLogger } from "../../global/app-logger";
+import { HmrEntrypointRegistrar } from "../shared/hmr-entrypoint-registrar.js";
+import { BrowserBundleService } from "../../services/assets/browser-bundle.service.js";
+import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service";
+import {
+  getAppEntrypointDependencyGraph,
+  NoopEntrypointDependencyGraph,
+  setAppEntrypointDependencyGraph
+} from "../../services/runtime-state/entrypoint-dependency-graph.service.js";
+import { getAppRuntimeSpecifierRegistry } from "../../services/runtime-state/runtime-specifier-registry.service.js";
+import { resolveInternalExecutionDir, resolveInternalWorkDir } from "../../utils/resolve-work-dir.js";
 class HmrManager {
+  static entrypointRegistrationTimeoutMs = 4e3;
   appConfig;
   bridge;
   /** Keep track of watchers */
   watchers = /* @__PURE__ */ new Map();
   /** entrypoint -> output path */
   watchedFiles = /* @__PURE__ */ new Map();
-  /** bare specifier -> runtime URL (e.g., 'react' -> '/assets/vendors/react.js') */
-  specifierMap = /* @__PURE__ */ new Map();
+  entrypointRegistrations = /* @__PURE__ */ new Map();
   distDir;
   plugins = [];
   enabled = true;
   strategies = [];
+  entrypointRegistrar;
+  browserBundleService;
+  entrypointDependencyGraph;
+  runtimeSpecifierRegistry;
+  serverModuleTranspiler;
   wsHandler;
   constructor({ appConfig, bridge }) {
     this.appConfig = appConfig;
     this.bridge = bridge;
-    this.distDir = path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR, "_hmr");
+    this.distDir = path.join(resolveInternalWorkDir(this.appConfig), RESOLVED_ASSETS_DIR, "_hmr");
+    this.entrypointRegistrar = new HmrEntrypointRegistrar({
+      srcDir: this.appConfig.absolutePaths.srcDir,
+      distDir: this.distDir,
+      entrypointRegistrations: this.entrypointRegistrations,
+      watchedFiles: this.watchedFiles,
+      clearFailedRegistration: (entrypointPath) => this.clearFailedEntrypointRegistration(entrypointPath),
+      registrationTimeoutMs: HmrManager.entrypointRegistrationTimeoutMs
+    });
+    this.browserBundleService = new BrowserBundleService(appConfig);
+    const existingEntrypointDependencyGraph = getAppEntrypointDependencyGraph(appConfig);
+    this.entrypointDependencyGraph = existingEntrypointDependencyGraph instanceof NoopEntrypointDependencyGraph ? existingEntrypointDependencyGraph : new NoopEntrypointDependencyGraph();
+    setAppEntrypointDependencyGraph(this.appConfig, this.entrypointDependencyGraph);
+    this.runtimeSpecifierRegistry = getAppRuntimeSpecifierRegistry(this.appConfig);
+    this.serverModuleTranspiler = getAppServerModuleTranspiler(this.appConfig);
     this.cleanDistDir();
     this.initializeStrategies();
   }
@@ -36,6 +66,27 @@ class HmrManager {
   cleanDistDir() {
     fileSystem.ensureDir(this.distDir);
   }
+  /**
+   * Returns whether the generic JS strategy may rebuild an entrypoint.
+   *
+   * @remarks
+   * Integration-owned page entrypoints are excluded so a shared dependency
+   * invalidation cannot replace framework-owned browser output with a generic JS
+   * rebuild.
+   */
+  shouldJsStrategyProcessEntrypoint(entrypointPath) {
+    return !this.strategies.some((strategy) => {
+      if (strategy.type !== HmrStrategyType.INTEGRATION || strategy.priority <= HmrStrategyType.SCRIPT) {
+        return false;
+      }
+      try {
+        return strategy.matches(entrypointPath);
+      } catch (error) {
+        appLogger.error(error);
+        return false;
+      }
+    });
+  }
   /**
    * Initializes core HMR strategies.
    * Strategies are evaluated in priority order (highest first).
@@ -43,10 +94,16 @@ class HmrManager {
   initializeStrategies() {
     const jsContext = {
       getWatchedFiles: () => this.watchedFiles,
-      getSpecifierMap: () => this.specifierMap,
+      getSpecifierMap: () => this.runtimeSpecifierRegistry.getAll(),
       getDistDir: () => this.distDir,
       getPlugins: () => this.plugins,
-      getSrcDir: () => this.appConfig.absolutePaths.srcDir
+      getSrcDir: () => this.appConfig.absolutePaths.srcDir,
+      getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
+      getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
+      getTemplateExtensions: () => this.appConfig.templatesExt,
+      getBrowserBundleService: () => this.browserBundleService,
+      getEntrypointDependencyGraph: () => this.entrypointDependencyGraph,
+      shouldProcessEntrypoint: (entrypointPath) => this.shouldJsStrategyProcessEntrypoint(entrypointPath)
     };
     this.strategies = [new JsHmrStrategy(jsContext), new DefaultHmrStrategy()];
   }
@@ -68,14 +125,16 @@ class HmrManager {
     return this.enabled;
   }
   /**
-   * Registers a mapping from bare specifiers to vendor URLs.
-   * Used by integrations to provide their module resolution mappings.
-   * @param map - Object mapping bare specifiers to vendor URLs
+   * Registers runtime bare-specifier mappings exposed by integrations.
+   *
+   * @remarks
+   * These mappings are consumed by framework-owned HMR strategies that preserve
+   * shared runtime imports in browser bundles. The registry stays generic so
+   * these mappings can later support broader import-map-style runtime features
+   * without moving integration semantics into core.
    */
   registerSpecifierMap(map) {
-    for (const [specifier, url] of Object.entries(map)) {
-      this.specifierMap.set(specifier, url);
-    }
+    this.runtimeSpecifierRegistry.register(map);
   }
   getWebSocketHandler() {
     const open = (ws) => {
@@ -100,12 +159,12 @@ class HmrManager {
    */
   async buildRuntime() {
     const runtimeSource = path.resolve(import.meta.dirname, "../../hmr/client/hmr-runtime.js");
-    const result = await defaultBuildAdapter.build({
+    const result = await this.browserBundleService.bundle({
+      profile: "hmr-runtime",
       entrypoints: [runtimeSource],
       outdir: this.distDir,
       naming: "_hmr_runtime.js",
       minify: false,
-      ...defaultBuildAdapter.getTranspileOptions("hmr-runtime"),
       plugins: this.plugins
     });
     if (!result.success) {
@@ -121,18 +180,13 @@ class HmrManager {
     );
     this.bridge.broadcast(event);
   }
-  /**
-   * Handles file changes using registered HMR strategies.
-   * Strategies are evaluated in priority order until one matches.
-   * @param filePath - Absolute path to the changed file
-   */
-  async handleFileChange(filePath) {
+  async handleFileChange(filePath, options = {}) {
     const sorted = [...this.strategies].sort((a, b) => b.priority - a.priority);
     const strategy = sorted.find((s) => {
       try {
         return s.matches(filePath);
       } catch (err) {
-        appLogger.error(`[HmrManager] Error checking match for ${s.constructor.name}:`, err);
+        appLogger.error(err);
         return false;
       }
     });
@@ -142,7 +196,8 @@ class HmrManager {
     }
     appLogger.debug(`[HmrManager] Selected strategy: ${strategy.constructor.name}`);
     const action = await strategy.process(filePath);
-    if (action.type === "broadcast") {
+    const shouldBroadcast = options.broadcast ?? true;
+    if (shouldBroadcast && action.type === "broadcast") {
       if (action.events) {
         for (const event of action.events) {
           this.broadcast(event);
@@ -150,9 +205,6 @@ class HmrManager {
       }
     }
   }
-  /**
-   * Registers a client entrypoint to be built and watched by Bun.
-   */
   getOutputUrl(entrypointPath) {
     return this.watchedFiles.get(entrypointPath);
   }
@@ -160,7 +212,7 @@ class HmrManager {
     return this.watchedFiles;
   }
   getSpecifierMap() {
-    return this.specifierMap;
+    return this.runtimeSpecifierRegistry.getAll();
   }
   getDistDir() {
     return this.distDir;
@@ -171,55 +223,110 @@ class HmrManager {
   getDefaultContext() {
     return {
       getWatchedFiles: () => this.watchedFiles,
-      getSpecifierMap: () => this.specifierMap,
+      getSpecifierMap: () => this.runtimeSpecifierRegistry.getAll(),
       getDistDir: () => this.distDir,
       getPlugins: () => this.plugins,
       getSrcDir: () => this.appConfig.absolutePaths.srcDir,
       getLayoutsDir: () => this.appConfig.absolutePaths.layoutsDir,
-      getPagesDir: () => this.appConfig.absolutePaths.pagesDir
+      getPagesDir: () => this.appConfig.absolutePaths.pagesDir,
+      getBuildExecutor: () => getAppBuildExecutor(this.appConfig),
+      getBrowserBundleService: () => this.browserBundleService,
+      importServerModule: async (filePath) => await this.serverModuleTranspiler.importModule({
+        filePath,
+        outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-modules"),
+        externalPackages: true
+      })
     };
   }
+  clearFailedEntrypointRegistration(entrypointPath) {
+    this.watchedFiles.delete(entrypointPath);
+  }
+  /**
+   * Registers one integration-owned page entrypoint.
+   *
+   * @remarks
+   * Concurrent callers share one in-flight registration. The registration is
+   * cleared from the dedupe map when it settles so later callers cannot inherit a
+   * stale promise.
+   */
   async registerEntrypoint(entrypointPath) {
-    if (this.watchedFiles.has(entrypointPath)) {
-      return this.watchedFiles.get(entrypointPath);
-    }
-    const srcDir = this.appConfig.absolutePaths.srcDir;
-    const relativePath = path.relative(srcDir, entrypointPath);
-    const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, ".js");
-    const encodedPathJs = this.encodeDynamicSegments(relativePathJs);
-    const urlPath = encodedPathJs.split(path.sep).join("/");
-    const outputUrl = `/${path.join(RESOLVED_ASSETS_DIR, "_hmr", urlPath)}`;
-    const outputPath = path.join(this.distDir, urlPath);
-    this.watchedFiles.set(entrypointPath, outputUrl);
-    await this.handleFileChange(entrypointPath);
+    return await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
+      emit: async (normalizedEntrypoint, outputPath) => await this.emitStrictEntrypoint(normalizedEntrypoint, outputPath),
+      getMissingOutputError: (normalizedEntrypoint, outputPath) => new Error(
+        `[HMR] Integration failed to emit entrypoint ${normalizedEntrypoint} to ${outputPath}. Page entrypoints must be produced by their owning integration.`
+      )
+    });
+  }
+  /**
+   * Registers one generic script entrypoint.
+   *
+   * @remarks
+   * This explicit path keeps the page-entrypoint contract strict while still
+   * allowing generic script assets to use the fallback build path.
+   */
+  async registerScriptEntrypoint(entrypointPath) {
+    return await this.entrypointRegistrar.registerEntrypoint(entrypointPath, {
+      emit: async (normalizedEntrypoint, outputPath) => await this.emitScriptEntrypoint(normalizedEntrypoint, outputPath),
+      getMissingOutputError: (normalizedEntrypoint) => new Error(`[HMR] Failed to register script entrypoint: ${normalizedEntrypoint}`)
+    });
+  }
+  /**
+   * Performs strict integration-owned registration for one normalized path.
+   *
+   * @remarks
+   * The manager reserves the output URL, removes any stale emitted file, runs
+   * strategy processing without broadcasting, and then verifies that the owning
+   * integration emitted the expected file.
+   */
+  async emitStrictEntrypoint(entrypointPath, _outputPath) {
+    await this.handleFileChange(entrypointPath, { broadcast: false });
+  }
+  /**
+   * Performs registration for a generic script asset.
+   *
+   * @remarks
+   * Strategies get the first chance to emit output. If no output exists after
+   * that pass, Bun falls back to the generic browser build for this explicit
+   * script-only path.
+   */
+  async emitScriptEntrypoint(entrypointPath, outputPath) {
+    const naming = path.relative(this.distDir, outputPath).split(path.sep).join("/");
+    await this.handleFileChange(entrypointPath, { broadcast: false });
     if (!fileSystem.exists(outputPath)) {
-      const fallback = await defaultBuildAdapter.build({
+      const buildResult = await this.browserBundleService.bundle({
+        profile: "hmr-entrypoint",
         entrypoints: [entrypointPath],
         outdir: this.distDir,
-        naming: encodedPathJs,
+        naming,
         minify: false,
-        external: Array.from(this.specifierMap.keys()),
-        ...defaultBuildAdapter.getTranspileOptions("hmr-entrypoint"),
         plugins: this.plugins
       });
-      if (!fallback.success) {
-        appLogger.error(`[HMR] Fallback build failed for ${entrypointPath}:`, fallback.logs);
+      if (!buildResult.success) {
+        appLogger.error(
+          `[HMR] Generic script entrypoint build failed for ${entrypointPath}:`,
+          buildResult.logs
+        );
       }
     }
-    return outputUrl;
   }
   /**
-   * Encodes dynamic route segments (brackets) in file paths.
-   * Converts `[slug]` to `_slug_` to avoid filesystem/URL issues.
+   * Stops active watchers and releases retained registration state.
+   *
+   * @remarks
+   * Emitted `_hmr` files remain on disk because parallel app processes may share
+   * the same dist directory. The in-memory indexes are cleared so stale
+   * entrypoints and specifier maps cannot leak through a reused manager object.
    */
-  encodeDynamicSegments(filepath) {
-    return filepath.replace(/\[([^\]]+)\]/g, "_$1_");
-  }
   stop() {
+    this.entrypointRegistrations.clear();
     for (const watcher of this.watchers.values()) {
       watcher.close();
     }
     this.watchers.clear();
+    this.watchedFiles.clear();
+    this.runtimeSpecifierRegistry.clear();
+    this.entrypointDependencyGraph.reset();
+    this.plugins = [];
   }
 }
 export {

package/src/adapters/bun/index.d.ts

@@ -1,3 +1,2 @@
 export { EcopagesApp, createApp } from './create-app.js';
-export { defineApiHandler, defineGroupHandler } from './define-api-handler.js';
-export type { GroupHandler } from './define-api-handler.js';
+export { defineApiHandler, defineGroupHandler, type GroupHandler } from '../shared/define-api-handler.js';

package/src/adapters/bun/index.js

@@ -1,5 +1,5 @@
 import { EcopagesApp, createApp } from "./create-app.js";
-import { defineApiHandler, defineGroupHandler } from "./define-api-handler.js";
+import { defineApiHandler, defineGroupHandler } from "../shared/define-api-handler.js";
 export {
   EcopagesApp,
   createApp,

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

@@ -4,8 +4,14 @@ import { createRequire } from "../../utils/locals-utils.js";
 import { fileSystem } from "@ecopages/file-system";
 import { SharedServerAdapter } from "../shared/server-adapter.js";
 import { ApiResponseBuilder } from "../shared/api-response.js";
+import { installSharedRuntimeBuildExecutor } from "../shared/runtime-bootstrap.js";
 import { ServerRouteHandler } from "../shared/server-route-handler.js";
 import { ServerStaticBuilder } from "../shared/server-static-builder";
+import {
+  injectHmrRuntimeIntoHtmlResponse,
+  isHtmlResponse,
+  shouldInjectHmrHtmlResponse
+} from "../shared/hmr-html-response";
 import { ClientBridge } from "./client-bridge";
 import { HmrManager } from "./hmr-manager";
 import { ServerLifecycle } from "./server-lifecycle.js";
@@ -52,14 +58,13 @@ class BunServerAdapter extends SharedServerAdapter {
    * Only injects in watch mode when HMR manager is enabled.
    */
   shouldInjectHmrScript() {
-    return this.options?.watch === true && this.hmrManager?.isEnabled() === true;
+    return shouldInjectHmrHtmlResponse(this.options?.watch === true, this.hmrManager);
   }
   /**
    * Checks if a response contains HTML content.
    */
   isHtmlResponse(response) {
-    const contentType = response.headers.get("Content-Type");
-    return contentType !== null && contentType.startsWith("text/html");
+    return isHtmlResponse(response);
   }
   /**
    * Injects HMR script into HTML responses in development mode.
@@ -67,16 +72,7 @@ class BunServerAdapter extends SharedServerAdapter {
    */
   async maybeInjectHmrScript(response) {
     if (this.shouldInjectHmrScript() && this.isHtmlResponse(response)) {
-      const html = await response.text();
-      const hmrScript = `<script type="module">import '/_hmr_runtime.js';<\/script>`;
-      const updatedHtml = html.replace(/<\/html>/i, `${hmrScript}</html>`);
-      const headers = new Headers(response.headers);
-      headers.delete("Content-Length");
-      return new Response(updatedHtml, {
-        status: response.status,
-        statusText: response.statusText,
-        headers
-      });
+      return injectHmrRuntimeIntoHtmlResponse(response);
     }
     return response;
   }
@@ -85,6 +81,9 @@ class BunServerAdapter extends SharedServerAdapter {
    * Delegates to ServerLifecycle for setup.
    */
   async initialize() {
+    installSharedRuntimeBuildExecutor(this.appConfig, {
+      development: this.options?.watch === true
+    });
     this.bridge = this.bridgeFactory ?? new ClientBridge();
     this.hmrManager = this.hmrManagerFactory ?? new HmrManager({ appConfig: this.appConfig, bridge: this.bridge });
     this.lifecycle = this.lifecycleFactory ?? new ServerLifecycle({
@@ -97,7 +96,8 @@ class BunServerAdapter extends SharedServerAdapter {
     const staticBuilderOptions = {
       appConfig: this.appConfig,
       staticSiteGenerator: this.staticSiteGenerator,
-      serveOptions: this.serveOptions
+      serveOptions: this.serveOptions,
+      apiHandlers: this.apiHandlers
     };
     this.staticBuilder = this.staticBuilderFactory ? this.staticBuilderFactory(staticBuilderOptions) : new ServerStaticBuilder(staticBuilderOptions);
     await this.lifecycle.initializePlugins({ watch: this.options?.watch });
@@ -106,22 +106,23 @@ class BunServerAdapter extends SharedServerAdapter {
    * Refreshes the router routes during watch mode.
    */
   async refreshRouterRoutes() {
-    if (this.serverInstance && typeof this.serverInstance.reload === "function") {
-      try {
-        await this.initSharedRouter();
-        this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+    if (!this.serverInstance || typeof this.serverInstance.reload !== "function") {
+      appLogger.error("Server instance is not available for reloading");
+      return;
+    }
+    await this.createSharedWatchRefreshCallback({
+      staticRoutes: this.staticRoutes,
+      hmrManager: this.hmrManager,
+      onRoutesReady: () => {
         const options = this.getServerOptions({ enableHmr: true });
         this.serverInstance.reload(options);
         appLogger.debug("Server routes updated with dynamic routes");
-      } catch (error) {
-        if (error instanceof Error) {
-          this.hmrManager.broadcast({ type: "error", message: error.message });
-          appLogger.error("Failed to refresh router routes:", error);
-        }
+      },
+      onError: (error) => {
+        this.hmrManager.broadcast({ type: "error", message: error.message });
+        appLogger.error("Failed to refresh router routes:", error);
       }
-    } else {
-      appLogger.error("Server instance is not available for reloading");
-    }
+    })();
   }
   async watch() {
     await this.lifecycle.startWatching({
@@ -246,8 +247,10 @@ class BunServerAdapter extends SharedServerAdapter {
    */
   async buildStatic(options) {
     if (!this.fullyInitialized) {
-      await this.initSharedRouter();
-      this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+      await this.initializeSharedRouteHandling({
+        staticRoutes: this.staticRoutes,
+        hmrManager: this.hmrManager
+      });
     }
     await this.staticBuilder.build(options, {
       router: this.router,
@@ -278,8 +281,10 @@ class BunServerAdapter extends SharedServerAdapter {
   async _performInitialization(server) {
     this.serverInstance = server;
     appLogger.debug("Completing server initialization with dynamic routes");
-    await this.initSharedRouter();
-    this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
+    await this.initializeSharedRouteHandling({
+      staticRoutes: this.staticRoutes,
+      hmrManager: this.hmrManager
+    });
     this.fullyInitialized = true;
     if (this.options?.watch) await this.watch();
     if (server && typeof server.reload === "function") {