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

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

@@ -1,24 +1,28 @@
-import path from "node:path";
 import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
-import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
 import { appLogger } from "../../global/app-logger.js";
 import { HttpError } from "../../errors/http-error.js";
 import { createRequire } from "../../utils/locals-utils.js";
+import { findWebSocketRoute } from "../abstract/ws-pattern-matcher.js";
 import { fileSystem } from "@ecopages/file-system";
-import { getAppBrowserBuildPlugins, setupAppRuntimePlugins } from "../../build/build-adapter.js";
+import { setupAppRuntimePlugins } from "../../build/build-adapter.js";
 import { installAppRuntimeBuildExecutor } from "../../build/runtime-build-executor.js";
 import { StaticSiteGenerator } from "../../static-site-generator/static-site-generator.js";
 import { ProjectWatcher } from "../../watchers/project-watcher.js";
 import { SharedServerAdapter } from "../shared/server-adapter.js";
 import { ApiResponseBuilder } from "../shared/api-response.js";
 import { ServerStaticBuilder } from "../shared/server-static-builder.js";
-import {
-  injectHmrRuntimeIntoHtmlResponse,
-  isHtmlResponse,
-  shouldInjectHmrHtmlResponse
-} from "../shared/hmr-html-response.js";
+import { attachNodeHttpWebSocketUpgrades } from "../shared/node-http-websocket-upgrades.js";
+import { createBunUserWebSocketLifecycle } from "../shared/bun-user-websocket-lifecycle.js";
+import { createEcopagesSocket } from "../shared/websocket-lifecycle.js";
 import { resolveServeRuntimeOrigin } from "../shared/runtime-app-bootstrap.js";
+import {
+  disposeDevResources,
+  maybeInjectAdapterHmrHtmlResponse,
+  prepareRuntimePublicDir,
+  wireIntegrationHmrManagers
+} from "../shared/runtime-server-lifecycle.js";
 import { ClientBridge } from "./client-bridge.js";
+import { setAppDevClientBridge } from "../../dev/client-bridge-registry.js";
 import { HmrManager } from "./hmr-manager.js";
 import { BunStaticPreviewHost } from "./static-preview-host.js";
 class BunServerAdapter extends SharedServerAdapter {
@@ -29,7 +33,59 @@ class BunServerAdapter extends SharedServerAdapter {
   hmrManager;
   initializationPromise = null;
   fullyInitialized = false;
+  projectWatcher = null;
+  adapterDisposed = false;
+  deferRuntimeAssetSetup;
+  allowPortFallback;
   previewHost;
+  /**
+   * Reference to the application-level WebSocket handlers map.
+   *
+   * @remarks
+   * This is a reference to the map owned by `AbstractApplicationAdapter`,
+   * passed in via the constructor. The Bun adapter reads from it to wire
+   * WebSocket upgrades for user-registered patterns.
+   */
+  websocketHandlers = /* @__PURE__ */ new Map();
+  registerBunRuntimePlugin(plugin) {
+    Bun.plugin(plugin);
+  }
+  adaptBunWebSocket(ws, kind, params, search, context) {
+    return createEcopagesSocket(
+      {
+        send: (data) => ws.send(data),
+        close: (code, reason) => ws.close(code, reason)
+      },
+      { kind, params, search, context }
+    );
+  }
+  /**
+   * Resolves the per-connection context for a Bun user connection.
+   *
+   * @remarks
+   * `context()` is invoked exactly once per accepted connection. Its
+   * resolved value is shared by all subsequent lifecycle hooks. If
+   * `context()` throws, the connection is closed immediately with code
+   * 1011 (server error) and the error is logged.
+   *
+   * @param request - The original upgrade request (best-effort reconstructed)
+   * @param handler - The registered handler
+   * @param kind - The registered route pattern
+   * @param params - Dynamic path parameters
+   * @param search - Query string parameters
+   * @returns The resolved per-connection context
+   */
+  async resolveBunContext(request, handler, kind, params, search) {
+    if (!handler.context) {
+      return void 0;
+    }
+    try {
+      return await handler.context({ request, kind, params, search });
+    } catch (error) {
+      appLogger.error(`[WS:${kind}] context() failed; closing connection.`, error);
+      throw error;
+    }
+  }
   /**
    * Creates a Bun server adapter with already-resolved runtime collaborators.
    *
@@ -46,18 +102,38 @@ class BunServerAdapter extends SharedServerAdapter {
     apiHandlers,
     staticRoutes,
     errorHandler,
+    websocketHandlers,
     options,
+    hostOwnsDevClient,
+    deferRuntimeAssetSetup,
+    allowPortFallback,
     hmrManager,
     bridge,
     previewHost
   }) {
     super({ appConfig, runtimeOrigin, serveOptions, options });
+    this.deferRuntimeAssetSetup = deferRuntimeAssetSetup === true;
+    this.allowPortFallback = allowPortFallback !== false;
     this.apiHandlers = apiHandlers || [];
     this.staticRoutes = staticRoutes || [];
     this.errorHandler = errorHandler;
     this.bridge = bridge;
     this.hmrManager = hmrManager;
     this.previewHost = previewHost;
+    this.hostOwnsDevClient = hostOwnsDevClient === true;
+    if (websocketHandlers) {
+      this.websocketHandlers = websocketHandlers;
+    }
+  }
+  /**
+   * Wires user WebSocket routes onto a Node HTTP server used by host integrations.
+   */
+  attachUserWebSocketUpgrades(server, options) {
+    attachNodeHttpWebSocketUpgrades(server, {
+      runtimeOrigin: this.runtimeOrigin,
+      websocketHandlers: this.websocketHandlers,
+      passthroughUnmatched: options?.passthroughUnmatched
+    });
   }
   /**
    * Returns whether adapter-level HTML responses still need HMR runtime injection.
@@ -67,25 +143,12 @@ class BunServerAdapter extends SharedServerAdapter {
    * adapter-level check exists for explicit API handlers that return HTML and
    * would otherwise bypass the route wrapper entirely.
    */
-  shouldInjectHmrScript() {
-    return shouldInjectHmrHtmlResponse(this.options?.watch === true, this.hmrManager);
-  }
-  /**
-   * Delegates the HTML-response test to the shared response helper used by both
-   * adapters.
-   */
-  isHtmlResponse(response) {
-    return isHtmlResponse(response);
-  }
-  /**
-   * Injects HMR script into HTML responses in development mode.
-   * Ensures explicit API handlers that return HTML get auto-reload capability.
-   */
   async maybeInjectHmrScript(response) {
-    if (this.shouldInjectHmrScript() && this.isHtmlResponse(response)) {
-      return injectHmrRuntimeIntoHtmlResponse(response);
-    }
-    return response;
+    return maybeInjectAdapterHmrHtmlResponse(response, {
+      watch: this.options?.watch === true,
+      hmrManager: this.hmrManager,
+      hostOwnsDevClient: this.hostOwnsDevClient
+    });
   }
   /**
    * Initializes the server adapter's core runtime components.
@@ -93,27 +156,25 @@ class BunServerAdapter extends SharedServerAdapter {
   async initialize() {
     installAppRuntimeBuildExecutor(this.appConfig);
     this.staticSiteGenerator = new StaticSiteGenerator({ appConfig: this.appConfig });
-    await this.hmrManager.buildRuntime();
-    this.prepareRuntimePublicDir();
+    if (this.options?.watch) {
+      await this.hmrManager.buildRuntime();
+    }
+    prepareRuntimePublicDir(this.appConfig);
     const staticBuilderOptions = {
       appConfig: this.appConfig,
       staticSiteGenerator: this.staticSiteGenerator,
       serveOptions: this.serveOptions,
-      apiHandlers: this.apiHandlers
+      runtimeOrigin: this.runtimeOrigin,
+      apiHandlers: this.apiHandlers,
+      hmrManager: this.hmrManager,
+      onRuntimePlugin: (plugin) => {
+        this.registerBunRuntimePlugin(plugin);
+      }
     };
     this.staticBuilder = new ServerStaticBuilder(staticBuilderOptions);
-    await this.initializeRuntimePlugins({ watch: this.options?.watch });
-  }
-  /**
-   * Copies the source `public` directory into the runtime output and ensures the
-   * HMR assets directory exists before any runtime bundles are emitted.
-   */
-  prepareRuntimePublicDir() {
-    const srcPublicDir = path.join(this.appConfig.rootDir, this.appConfig.srcDir, this.appConfig.publicDir);
-    if (fileSystem.exists(srcPublicDir)) {
-      fileSystem.copyDir(srcPublicDir, path.join(this.appConfig.rootDir, this.appConfig.distDir));
+    if (!this.deferRuntimeAssetSetup) {
+      await this.initializeRuntimePlugins({ watch: this.options?.watch });
     }
-    fileSystem.ensureDir(path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
   }
   /**
    * Registers runtime plugins and propagates the final HMR manager into each
@@ -132,14 +193,10 @@ class BunServerAdapter extends SharedServerAdapter {
         runtimeOrigin: this.runtimeOrigin,
         hmrManager: this.hmrManager,
         onRuntimePlugin: (plugin) => {
-          Bun.plugin(plugin);
+          this.registerBunRuntimePlugin(plugin);
         }
       });
-      const browserBuildPlugins = getAppBrowserBuildPlugins(this.appConfig);
-      this.hmrManager.setPlugins(browserBuildPlugins);
-      for (const integration of this.appConfig.integrations) {
-        integration.setHmrManager(this.hmrManager);
-      }
+      wireIntegrationHmrManagers(this.appConfig, this.hmrManager);
     } catch (error) {
       appLogger.error(`Failed to initialize plugins: ${error instanceof Error ? error.message : String(error)}`);
       throw error;
@@ -173,54 +230,114 @@ class BunServerAdapter extends SharedServerAdapter {
       config: this.appConfig,
       refreshRouterRoutesCallback: this.refreshRouterRoutes.bind(this),
       hmrManager: this.hmrManager,
-      bridge: this.bridge
+      bridge: this.bridge,
+      hostOwnsDevClient: this.hostOwnsDevClient
     });
+    this.projectWatcher = watcher;
     await watcher.createWatcherSubscription();
   }
   /**
    * Builds the `Bun.serve()` options for the current adapter state.
    *
    * @remarks
-   * The HMR-enabled variant wraps the base fetch handler so one Bun server can
-   * serve normal requests, accept HMR websocket upgrades, and expose the HMR
-   * runtime asset without splitting responsibility across separate listeners.
+   * When HMR is enabled the websocket dispatcher merges HMR and user handlers,
+   * routing by the `kind` field embedded in socket data at upgrade time.
+   * This prevents user-registered websocket handlers from being silently overwritten
+   * by the HMR handler in development mode.
+   *
+   * User WebSocket paths are intercepted in the fetch handler via the pattern matcher.
+   * The upgrade happens implicitly — no manual GET route registration needed.
    */
   getServerOptions({ enableHmr = false } = {}) {
     appLogger.debug(`[BunServerAdapter] getServerOptions called with enableHmr: ${enableHmr}`);
     const serverOptions = this.buildServerSettings();
+    const hasUserWs = this.websocketHandlers.size > 0;
+    if (!enableHmr && !hasUserWs) {
+      return serverOptions;
+    }
+    const userLifecycle = this.createBunUserLifecycle();
     if (enableHmr) {
-      const originalFetch = serverOptions.fetch;
-      const hmrHandler = this.hmrManager.getWebSocketHandler();
-      const hmrManager = this.hmrManager;
       serverOptions.development = true;
-      serverOptions.websocket = hmrHandler;
-      serverOptions.fetch = async function(request, _server) {
-        const url = new URL(request.url);
-        appLogger.debug(`[HMR] Request: ${url.pathname}`);
+      serverOptions.websocket = this.createHmrAwareWebSocketHandler(userLifecycle);
+    } else {
+      serverOptions.websocket = userLifecycle;
+    }
+    serverOptions.fetch = this.wrapFetchWithWebSocketUpgrades(serverOptions.fetch, {
+      serveHmrEndpoints: enableHmr
+    });
+    return serverOptions;
+  }
+  createBunUserLifecycle() {
+    return createBunUserWebSocketLifecycle({
+      runtimeOrigin: this.runtimeOrigin,
+      userHandlers: this.websocketHandlers,
+      resolveContext: this.resolveBunContext.bind(this),
+      adaptSocket: (ws, kind, params, search, context) => this.adaptBunWebSocket(ws, kind, params, search, context)
+    });
+  }
+  /**
+   * @remarks
+   * HMR and user sockets share one Bun `websocket` handler. Upgrade tags HMR
+   * connections with `kind: '__hmr__'`; everything else routes to the user lifecycle.
+   */
+  createHmrAwareWebSocketHandler(userLifecycle) {
+    const hmrHandler = this.hmrManager.getWebSocketHandler();
+    const isHmrSocket = (ws) => (ws.data?.kind ?? "__hmr__") === "__hmr__";
+    return {
+      open(ws) {
+        if (isHmrSocket(ws)) return void hmrHandler.open?.(ws);
+        userLifecycle.open(ws);
+      },
+      message(ws, msg) {
+        if (isHmrSocket(ws)) return void hmrHandler.message?.(ws, msg);
+        userLifecycle.message(ws, msg);
+      },
+      close(ws, code, reason) {
+        if (isHmrSocket(ws)) return void hmrHandler.close?.(ws, code, reason);
+        userLifecycle.close(ws, code, reason);
+      },
+      error(ws, error) {
+        if (isHmrSocket(ws)) return void appLogger.error("[HMR] WebSocket error:", error);
+        userLifecycle.error(ws, error);
+      }
+    };
+  }
+  /**
+   * @remarks
+   * When `serveHmrEndpoints` is set, `/_hmr` and `/_hmr_runtime.js` are checked
+   * before user websocket patterns so HMR upgrades are never captured by app routes.
+   * Production mode with only user handlers skips the HMR branch entirely.
+   */
+  wrapFetchWithWebSocketUpgrades(originalFetch, { serveHmrEndpoints }) {
+    const matchRoute = (pathname) => findWebSocketRoute(this.websocketHandlers, pathname);
+    const hmrManager = this.hmrManager;
+    return async function(request, server) {
+      const url = new URL(request.url);
+      if (serveHmrEndpoints) {
         if (url.pathname === "/_hmr") {
-          const success = this.upgrade(request, {
-            data: void 0
-          });
-          if (success) return;
-          return new Response("WebSocket upgrade failed", { status: 400 });
+          const success = this.upgrade(request, { data: { kind: "__hmr__", params: {}, search: {} } });
+          return success ? void 0 : new Response("WebSocket upgrade failed", { status: 400 });
         }
         if (url.pathname === "/_hmr_runtime.js") {
-          appLogger.debug(`[HMR] Serving runtime from ${hmrManager.getRuntimePath()}`);
           return new Response(fileSystem.readFileAsBuffer(hmrManager.getRuntimePath()), {
             headers: { "Content-Type": "application/javascript" }
           });
         }
-        let response;
-        if (originalFetch) {
-          const res = await originalFetch.call(this, request, this);
-          response = res instanceof Response ? res : new Response("Not Found", { status: 404 });
-        } else {
-          response = new Response("Not Found", { status: 404 });
-        }
-        return response;
-      };
-    }
-    return serverOptions;
+      }
+      const wsMatch = matchRoute(url.pathname);
+      if (wsMatch && request.headers.get("upgrade")?.toLowerCase() === "websocket") {
+        const search = Object.fromEntries(url.searchParams.entries());
+        const success = this.upgrade(request, {
+          data: { kind: wsMatch.kind, params: wsMatch.params, search, upgradeUrl: request.url }
+        });
+        return success ? void 0 : new Response("WebSocket upgrade failed", { status: 400 });
+      }
+      if (!originalFetch) {
+        return new Response("Not Found", { status: 404 });
+      }
+      const res = await originalFetch.call(this, request, server);
+      return res instanceof Response ? res : new Response("Not Found", { status: 404 });
+    };
   }
   /**
    * Helper method to retrieve and parse the request body.
@@ -306,9 +423,9 @@ class BunServerAdapter extends SharedServerAdapter {
         hmrManager: this.hmrManager
       });
     }
-    const buildRuntimeOrigin = this.serverInstance ? `http://${this.serverInstance.hostname || DEFAULT_ECOPAGES_HOSTNAME}:${this.serverInstance.port || DEFAULT_ECOPAGES_PORT}` : void 0;
+    const buildRuntimeOrigin = resolveServeRuntimeOrigin(this.serveOptions);
     await this.staticBuilder.build(
-      { ...options, preview: false, baseUrl: buildRuntimeOrigin },
+      { baseUrl: buildRuntimeOrigin, force: options?.force },
       {
         router: this.router,
         routeRendererFactory: this.routeRendererFactory,
@@ -323,7 +440,8 @@ class BunServerAdapter extends SharedServerAdapter {
     const activePreviewPort = await this.previewHost.start({
       appConfig: this.appConfig,
       hostname: String(previewHostname),
-      port: previewPort
+      port: previewPort,
+      allowPortFallback: this.allowPortFallback
     });
     if (activePreviewPort) {
       appLogger.info(`Preview running at http://${previewHostname}:${activePreviewPort}`);
@@ -380,9 +498,32 @@ class BunServerAdapter extends SharedServerAdapter {
       getServerOptions: this.getServerOptions.bind(this),
       buildStatic: this.buildStatic.bind(this),
       completeInitialization: this.completeInitialization.bind(this),
-      handleRequest: this.handleRequest.bind(this)
+      handleRequest: this.handleRequest.bind(this),
+      attachUserWebSocketUpgrades: this.attachUserWebSocketUpgrades.bind(this),
+      dispose: this.dispose.bind(this)
     };
   }
+  /**
+   * Releases dev-time resources owned by the adapter.
+   *
+   * @remarks
+   * Safe to call multiple times. Does not stop the bound Bun server — callers
+   * should shut down transport through the runtime host before disposing.
+   */
+  async dispose() {
+    if (this.adapterDisposed) {
+      return;
+    }
+    this.adapterDisposed = true;
+    await disposeDevResources({
+      projectWatcher: this.projectWatcher,
+      appConfig: this.appConfig,
+      hmrManager: this.hmrManager,
+      bridge: this.bridge,
+      previewHost: this.previewHost
+    });
+    this.projectWatcher = null;
+  }
   /**
    * Handles HTTP requests by passing them securely to the shared core router adapter.
    *
@@ -434,6 +575,7 @@ async function createBunServerAdapter(params) {
   const runtimeOrigin = params.runtimeOrigin ?? resolveServeRuntimeOrigin(params.serveOptions);
   const bridge = params.bridge ?? new ClientBridge();
   const hmrManager = params.hmrManager ?? new HmrManager({ appConfig: params.appConfig, bridge });
+  setAppDevClientBridge(params.appConfig, bridge);
   const previewHost = params.previewHost ?? new BunStaticPreviewHost();
   const adapter = new BunServerAdapter({
     ...params,

package/src/adapters/bun/static-preview-host.js

@@ -1,5 +1,6 @@
 import { StaticContentServer } from "../../dev/sc-server.js";
 import { appLogger } from "../../global/app-logger.js";
+import { PortManager } from "../shared/port-manager.js";
 class BunStaticPreviewHost {
   constructor(previewServerFactory = StaticContentServer, logger = appLogger) {
     this.previewServerFactory = previewServerFactory;
@@ -10,30 +11,34 @@ class BunStaticPreviewHost {
   previewServer = null;
   async start(options) {
     await this.stop();
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    for (let attempt = 0; attempt < 20; attempt += 1) {
-      try {
-        this.previewServer = this.previewServerFactory.createServer({
+    let previewServer = null;
+    const portManager = new PortManager({
+      startOnPort: async (port) => {
+        const candidate = this.previewServerFactory.createServer({
           appConfig: options.appConfig,
-          options: { port: options.port }
+          options: { port }
         });
-        const previewPort = this.previewServer.server?.port;
-        if (previewPort) {
-          return previewPort;
+        const boundPort = candidate.server?.port ?? null;
+        if (!boundPort) {
+          candidate.stop();
+          return null;
         }
-        break;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const errorCode = typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
-        const isPortReleaseRace = errorCode === "EADDRINUSE" || errorMessage.includes("EADDRINUSE");
-        if (!isPortReleaseRace || attempt === 19) {
-          throw error;
-        }
-        await new Promise((resolve) => setTimeout(resolve, 100));
-      }
+        previewServer = candidate;
+        return boundPort;
+      },
+      warn: (message) => appLogger.warn(message)
+    });
+    const previewPort = await portManager.bind({
+      preferredPort: options.port,
+      allowPortFallback: options.allowPortFallback === true
+    });
+    if (!previewPort) {
+      this.previewServer = null;
+      this.logger.error("Failed to start preview server");
+      return null;
     }
-    this.logger.error("Failed to start preview server");
-    return null;
+    this.previewServer = previewServer;
+    return previewPort;
   }
   async stop() {
     this.previewServer?.stop();

package/src/adapters/create-app.d.ts

@@ -2,8 +2,20 @@ import type { EcoPagesAppConfig } from '../types/internal-types.js';
 import { AbstractApplicationAdapter } from './abstract/application-adapter.js';
 import type { ApplicationAdapterOptions } from './abstract/application-adapter.js';
 import { SharedApplicationAdapter } from './shared/application-adapter.js';
+export type EcopagesRuntimeAdapter = 'auto' | 'node' | 'bun';
 export interface EcopagesAppOptions extends ApplicationAdapterOptions {
     appConfig: EcoPagesAppConfig;
+    /**
+     * Selects the runtime adapter used by the universal `createApp()` entrypoint.
+     *
+     * @default 'auto'
+     *
+     * @remarks
+     * This is separate from `runtime`, which configures embedded host behavior.
+     * Use `auto` to select Bun when the current process exposes `globalThis.Bun`
+     * and Node otherwise.
+     */
+    adapter?: EcopagesRuntimeAdapter;
     serverOptions?: Record<string, any>;
 }
 export type UniversalEcopagesApp = AbstractApplicationAdapter<EcopagesAppOptions, unknown, Request>;
@@ -17,4 +29,5 @@ export declare class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOpt
     protected initializeServerAdapter(): Promise<UniversalEcopagesApp>;
     start(): Promise<unknown>;
     fetch(request: Request): Promise<Response>;
+    stop(force?: boolean): Promise<void>;
 }

package/src/adapters/create-app.js

@@ -3,8 +3,9 @@ import { SharedApplicationAdapter } from "./shared/application-adapter.js";
 import { createApp as createBunApp } from "./bun/create-app.js";
 import { createNodeApp } from "./node/create-app.js";
 async function createRuntimeApp(options) {
+  const adapter = options.adapter ?? "auto";
   const bun = globalThis.Bun;
-  if (bun) {
+  if (adapter === "bun" || adapter === "auto" && bun) {
     return await createBunApp(options);
   }
   return await createNodeApp(options);
@@ -59,6 +60,14 @@ class EcopagesApp extends SharedApplicationAdapter {
     }
     return candidate.fetch(request);
   }
+  async stop(force = true) {
+    const runtimeApp = this.runtimeApp ?? (this.runtimeAppPromise ? await this.runtimeAppPromise : null);
+    if (runtimeApp) {
+      await runtimeApp.stop(force);
+    }
+    this.runtimeApp = null;
+    this.runtimeAppPromise = null;
+  }
 }
 export {
   EcopagesApp,

package/src/adapters/node/create-app.d.ts

@@ -7,6 +7,7 @@ export declare class NodeEcopagesApp extends SharedApplicationAdapter<EcopagesAp
     serverAdapter: NodeServerAdapterResult | undefined;
     private server;
     private runtimeOrigin;
+    private stopped;
     private readonly runtimeHost;
     constructor(options: EcopagesAppOptions, dependencies: {
         runtimeHost: RuntimeHost<NodeServerInstance, {
@@ -19,6 +20,9 @@ export declare class NodeEcopagesApp extends SharedApplicationAdapter<EcopagesAp
     protected initializeServerAdapter(): Promise<NodeServerAdapterResult>;
     start(): Promise<NodeServerInstance | void>;
     fetch(request: Request): Promise<Response>;
+    attachWebSocketUpgrades(httpServer: import('node:http').Server, options?: {
+        passthroughUnmatched?: boolean;
+    }): Promise<void>;
 }
 export declare function createNodeApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp>;
 export declare function createApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp>;

package/src/adapters/node/create-app.js

@@ -1,13 +1,15 @@
 import { appLogger } from "../../global/app-logger.js";
 import { SharedApplicationAdapter } from "../shared/application-adapter.js";
-import { resolveRuntimeBinding } from "../shared/runtime-app-bootstrap.js";
+import { resolveRuntimeBinding, resolveStaticRuntimeMode } from "../shared/runtime-app-bootstrap.js";
 import { createNodeServerAdapter } from "./server-adapter.js";
 import { NodeHttpRequestBridge } from "./http-request-bridge.js";
 import { NodeRuntimeHost } from "./runtime-host.js";
+import { hostOwnsDevClient } from "../../dev/dev-client-ownership.js";
 class NodeEcopagesApp extends SharedApplicationAdapter {
   serverAdapter;
   server = null;
   runtimeOrigin = "";
+  stopped = false;
   runtimeHost;
   constructor(options, dependencies) {
     super(options);
@@ -17,12 +19,18 @@ class NodeEcopagesApp extends SharedApplicationAdapter {
     return createNodeServerAdapter(params);
   }
   async stop(force = true) {
-    if (!this.server) {
+    if (this.stopped) {
       return;
     }
-    const activeServer = this.server;
-    this.server = null;
-    await this.runtimeHost.stop(activeServer, { force });
+    if (this.server) {
+      const activeServer = this.server;
+      this.server = null;
+      await this.runtimeHost.stop(activeServer, { force });
+    }
+    if (this.serverAdapter) {
+      await this.serverAdapter.dispose();
+    }
+    this.stopped = true;
   }
   async initializeServerAdapter() {
     const binding = resolveRuntimeBinding({
@@ -36,22 +44,32 @@ class NodeEcopagesApp extends SharedApplicationAdapter {
       apiHandlers: this.apiHandlers,
       staticRoutes: this.staticRoutes,
       errorHandler: this.errorHandler,
+      websocketHandlers: this.websocketHandlers.size > 0 ? this.websocketHandlers : void 0,
       options: { watch: binding.watch },
-      serveOptions: binding.serveOptions
+      serveOptions: binding.serveOptions,
+      hostOwnsDevClient: hostOwnsDevClient(this.runtimeOptions),
+      deferRuntimeAssetSetup: resolveStaticRuntimeMode({
+        appConfig: this.appConfig,
+        cliArgs: this.cliArgs
+      }).canBuildWithoutRuntimeServer,
+      allowPortFallback: binding.allowPortFallback
     });
   }
   async start() {
+    if (this.stopped) {
+      this.serverAdapter = void 0;
+      this.stopped = false;
+    }
     if (!this.serverAdapter) {
       this.serverAdapter = await this.initializeServerAdapter();
     }
     if (this.server) {
       return this.server;
     }
-    const { build, preview } = this.cliArgs;
+    const { build, preview, force } = this.cliArgs;
     if (build || preview) {
       appLogger.debugTime("Building static pages");
-      await this.serverAdapter.buildStatic({ preview });
-      await this.stop(true);
+      await this.serverAdapter.buildStatic({ preview, force });
       appLogger.debugTimeEnd("Building static pages");
       if (build) {
         process.exit(0);
@@ -76,6 +94,17 @@ class NodeEcopagesApp extends SharedApplicationAdapter {
     }
     return this.serverAdapter.handleRequest(request);
   }
+  async attachWebSocketUpgrades(httpServer, options) {
+    if (!this.serverAdapter) {
+      this.serverAdapter = await this.initializeServerAdapter();
+    }
+    if (!this.server) {
+      this.server = httpServer;
+      await this.serverAdapter.completeInitialization(httpServer);
+      return;
+    }
+    this.serverAdapter.attachUserWebSocketUpgrades(httpServer, options);
+  }
 }
 async function createNodeApp(options) {
   return new NodeEcopagesApp(options, {

package/src/adapters/node/node-client-bridge.d.ts

@@ -23,4 +23,5 @@ export declare class NodeClientBridge implements IClientBridge {
      * Call this when the dev server is shutting down.
      */
     destroy(): void;
+    [Symbol.dispose](): void;
 }

package/src/adapters/node/node-client-bridge.js

@@ -60,6 +60,9 @@ class NodeClientBridge {
     }
     this.subscribers.clear();
   }
+  [Symbol.dispose]() {
+    this.destroy();
+  }
 }
 export {
   NodeClientBridge