@ecopages/core 0.2.0-alpha.39 → 0.2.0-alpha.40

package/src/adapters/node/runtime-host.js

@@ -0,0 +1,92 @@
+import { createServer } from "node:http";
+import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
+import { appLogger } from "../../global/app-logger.js";
+import { resolveServeRuntimeOrigin } from "../shared/runtime-app-bootstrap.js";
+import { isNodeClientAbortError, NodeHttpRequestBridge } from "./http-request-bridge.js";
+class NodeRuntimeHost {
+  /**
+   * Creates a Node runtime host with injectable request bridging and server
+   * creation seams for tests and alternate hosts.
+   */
+  constructor(requestBridge, serverFactory = createServer) {
+    this.requestBridge = requestBridge;
+    this.serverFactory = serverFactory;
+  }
+  requestBridge;
+  serverFactory;
+  /**
+   * Starts the Node HTTP server and wires each request through the shared Web
+   * request pipeline.
+   *
+   * @remarks
+   * Client disconnects are treated as normal aborts and do not trigger adapter
+   * error logging or the runtime host's `onError` callback.
+   */
+  async start(options) {
+    const hostname = String(options.serveOptions.hostname ?? DEFAULT_ECOPAGES_HOSTNAME);
+    const port = Number(options.serveOptions.port ?? DEFAULT_ECOPAGES_PORT);
+    const runtimeOrigin = resolveServeRuntimeOrigin({ hostname, port });
+    const server = this.serverFactory(async (req, res) => {
+      try {
+        const webRequest = this.requestBridge.createWebRequest(req, runtimeOrigin);
+        const response = await options.handleRequest(webRequest);
+        await this.requestBridge.sendNodeResponse(res, response);
+      } catch (error) {
+        if (isNodeClientAbortError(error)) {
+          return;
+        }
+        appLogger.error("Node server adapter request failed", error);
+        res.statusCode = 500;
+        res.end("Internal Server Error");
+        await options.onError(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+    await new Promise((resolve) => {
+      server.listen(port, hostname, () => resolve());
+    });
+    return server;
+  }
+  /**
+   * Stops the Node HTTP server and, by default, force-closes any remaining open
+   * connections.
+   */
+  async stop(server, options) {
+    await new Promise((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+      if (options?.force ?? true) {
+        server.closeAllConnections();
+      }
+    });
+  }
+  /**
+   * Resolves the public runtime origin from the bound Node listener.
+   *
+   * @remarks
+   * The host preserves the configured hostname rather than echoing the raw socket
+   * address because users care about the requested host contract, not the local
+   * bind interface that Node chose internally.
+   */
+  getOrigin(server, fallbackServeOptions) {
+    const address = server.address();
+    const fallbackHostname = fallbackServeOptions.hostname ?? DEFAULT_ECOPAGES_HOSTNAME;
+    if (address && typeof address === "object") {
+      return resolveServeRuntimeOrigin({
+        hostname: fallbackHostname,
+        port: address.port
+      });
+    }
+    return resolveServeRuntimeOrigin({
+      hostname: fallbackHostname,
+      port: fallbackServeOptions.port
+    });
+  }
+}
+export {
+  NodeRuntimeHost
+};

package/src/adapters/node/server-adapter-dependencies.d.ts

@@ -0,0 +1,19 @@
+import { WebSocketServer } from 'ws';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import { NodeClientBridge } from './node-client-bridge.js';
+import { NodeHmrManager } from './node-hmr-manager.js';
+export interface NodeServerDevRuntime {
+    websocketServer: WebSocketServer;
+    bridge: NodeClientBridge;
+    hmrManager: NodeHmrManager;
+}
+export interface NodeServerDevRuntimeFactory {
+    create(options: {
+        appConfig: EcoPagesAppConfig;
+    }): NodeServerDevRuntime;
+}
+export declare class DefaultNodeServerDevRuntimeFactory implements NodeServerDevRuntimeFactory {
+    create(options: {
+        appConfig: EcoPagesAppConfig;
+    }): NodeServerDevRuntime;
+}

package/src/adapters/node/server-adapter-dependencies.js

@@ -0,0 +1,18 @@
+import { WebSocketServer } from "ws";
+import { NodeClientBridge } from "./node-client-bridge.js";
+import { NodeHmrManager } from "./node-hmr-manager.js";
+class DefaultNodeServerDevRuntimeFactory {
+  create(options) {
+    const websocketServer = new WebSocketServer({ noServer: true });
+    const bridge = new NodeClientBridge();
+    const hmrManager = new NodeHmrManager({ appConfig: options.appConfig, bridge });
+    return {
+      websocketServer,
+      bridge,
+      hmrManager
+    };
+  }
+}
+export {
+  DefaultNodeServerDevRuntimeFactory
+};

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

@@ -3,6 +3,9 @@ import type { EcoPagesAppConfig } from '../../types/internal-types.js';
 import type { ApiHandler, ErrorHandler, StaticRoute } from '../../types/public-types.js';
 import { SharedServerAdapter } from '../shared/server-adapter.js';
 import type { ServerAdapterResult } from '../abstract/server-adapter.js';
+import { NodeHttpRequestBridge } from './http-request-bridge.js';
+import type { StaticPreviewHost } from '../shared/static-preview-host.js';
+import { type NodeServerDevRuntimeFactory } from './server-adapter-dependencies.js';
 export type NodeServerInstance = NodeHttpServer;
 export type NodeServeAdapterServerOptions = {
     port?: number;
@@ -19,6 +22,9 @@ export interface NodeServerAdapterParams {
     options?: {
         watch?: boolean;
     };
+    previewHost?: StaticPreviewHost;
+    requestBridge?: NodeHttpRequestBridge;
+    devRuntimeFactory?: NodeServerDevRuntimeFactory;
 }
 export interface NodeServerAdapterResult extends ServerAdapterResult {
     completeInitialization: (server: NodeServerInstance) => Promise<void>;
@@ -50,9 +56,11 @@ export declare class NodeServerAdapter extends SharedServerAdapter<NodeServerAda
     private apiHandlers;
     private staticRoutes;
     private errorHandler?;
-    private previewServer;
     private bridge;
     private hmrManager;
+    private readonly previewHost;
+    private readonly requestBridge;
+    private readonly devRuntimeFactory;
     private shouldInjectHmrScript;
     private isHtmlResponse;
     private maybeInjectHmrScript;
@@ -71,46 +79,11 @@ export declare class NodeServerAdapter extends SharedServerAdapter<NodeServerAda
      *    processors during their `setup()` calls.
      */
     initialize(): Promise<void>;
+    private prepareRuntimePublicDir;
     getServerOptions(): NodeServeAdapterServerOptions;
     buildStatic(options?: {
         preview?: boolean;
     }): Promise<void>;
-    /**
-     * Converts a Node.js `IncomingMessage` into a Web API `Request`.
-     *
-     * Multi-value headers (e.g. `set-cookie`) are appended individually so no
-     * value is silently dropped.
-     *
-     * For methods that carry a body (`POST`, `PUT`, `PATCH`, …), the raw
-     * `IncomingMessage` stream is wrapped in a `ReadableStream` rather than
-     * cast directly to `BodyInit`. See the inline doc block inside the `if`
-     * branch for the rationale (client-abort handling).
-     *
-     * `duplex: 'half'` is required by the `fetch` spec when a streaming body is
-     * provided — without it Node.js 18+ throws a `TypeError`.
-     */
-    private createWebRequest;
-    /**
-     * Writes a Web `Response` back to a Node.js `ServerResponse`.
-     *
-     * The entire body is buffered via `arrayBuffer()` before writing. This is
-     * intentional for the current use-case (SSR pages and API routes), where
-     * responses are typically small and fully materialised. Streaming responses
-     * are not yet supported.
-     */
-    private sendNodeResponse;
-    /**
-     * Starts an ephemeral HTTP server used *only* during a static site generation
-     * run.
-     *
-     * Static generation works by having the `StaticSiteGenerator` issue real HTTP
-     * requests to a live server for each route, capturing the rendered HTML. This
-     * approach reuses the normal request pipeline (middleware, caching, API
-     * handlers) without any special-casing for the build path.
-     *
-     * The server is torn down immediately after generation completes via
-     * `stopBuildRuntimeServer`, so it never overlaps with the actual dev/prod server.
-     */
     private startBuildRuntimeServer;
     private getListeningServerOrigin;
     /**

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

@@ -1,40 +1,38 @@
 import { createServer } from "node:http";
+import path from "node:path";
 import { WebSocketServer } from "ws";
+import { fileSystem } from "@ecopages/file-system";
+import { getAppBrowserBuildPlugins, setupAppRuntimePlugins } from "../../build/build-adapter.js";
+import { installAppRuntimeBuildExecutor } from "../../build/runtime-build-executor.js";
+import { RESOLVED_ASSETS_DIR } from "../../config/constants.js";
 import { appLogger } from "../../global/app-logger.js";
 import { NodeClientBridge } from "./node-client-bridge.js";
 import { NodeHmrManager } from "./node-hmr-manager.js";
+import { ProjectWatcher } from "../../watchers/project-watcher.js";
 import { StaticSiteGenerator } from "../../static-site-generator/static-site-generator.js";
 import { SharedServerAdapter } from "../shared/server-adapter.js";
 import { ServerStaticBuilder } from "../shared/server-static-builder.js";
-import {
-  bindSharedRuntimeHmrManager,
-  initializeSharedRuntimePlugins,
-  installSharedRuntimeBuildExecutor,
-  prepareSharedRuntimePublicDir,
-  startSharedProjectWatching
-} from "../shared/runtime-bootstrap.js";
-import { NodeStaticContentServer } from "./static-content-server.js";
 import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../config/constants.js";
 import {
   injectHmrRuntimeIntoHtmlResponse,
   isHtmlResponse,
   shouldInjectHmrHtmlResponse
 } from "../shared/hmr-html-response.js";
-class ClientAbortError extends Error {
-  constructor() {
-    super("Client closed the request");
-    this.name = "ClientAbortError";
-  }
-}
+import { resolveServeRuntimeOrigin } from "../shared/runtime-app-bootstrap.js";
+import { NodeClientAbortError, NodeHttpRequestBridge } from "./http-request-bridge.js";
+import { NodeStaticPreviewHost } from "./static-preview-host.js";
+import { DefaultNodeServerDevRuntimeFactory } from "./server-adapter-dependencies.js";
 class NodeServerAdapter extends SharedServerAdapter {
   serverInstance = null;
   initialized = false;
   apiHandlers;
   staticRoutes;
   errorHandler;
-  previewServer = null;
   bridge = null;
   hmrManager = null;
+  previewHost;
+  requestBridge;
+  devRuntimeFactory;
   shouldInjectHmrScript() {
     return shouldInjectHmrHtmlResponse(this.options?.watch === true, this.hmrManager ?? void 0);
   }
@@ -52,6 +50,9 @@ class NodeServerAdapter extends SharedServerAdapter {
     this.apiHandlers = options.apiHandlers || [];
     this.staticRoutes = options.staticRoutes || [];
     this.errorHandler = options.errorHandler;
+    this.previewHost = options.previewHost;
+    this.requestBridge = options.requestBridge;
+    this.devRuntimeFactory = options.devRuntimeFactory;
   }
   /**
    * Prepares the adapter for use.
@@ -67,11 +68,11 @@ class NodeServerAdapter extends SharedServerAdapter {
    *    processors during their `setup()` calls.
    */
   async initialize() {
-    installSharedRuntimeBuildExecutor(this.appConfig, {
+    installAppRuntimeBuildExecutor(this.appConfig, {
       development: this.options?.watch === true
     });
-    prepareSharedRuntimePublicDir(this.appConfig);
-    await initializeSharedRuntimePlugins({
+    this.prepareRuntimePublicDir();
+    await setupAppRuntimePlugins({
       appConfig: this.appConfig,
       runtimeOrigin: this.runtimeOrigin,
       hmrManager: this.hmrManager ?? void 0
@@ -89,6 +90,13 @@ class NodeServerAdapter extends SharedServerAdapter {
     });
     this.initialized = true;
   }
+  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));
+    }
+    fileSystem.ensureDir(path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR));
+  }
   getServerOptions() {
     return {
       ...this.serveOptions
@@ -115,117 +123,27 @@ class NodeServerAdapter extends SharedServerAdapter {
     if (!options?.preview) {
       return;
     }
-    if (this.previewServer) {
-      await this.previewServer.stop();
-    }
-    this.previewServer = new NodeStaticContentServer({
+    await this.previewHost.start({
       appConfig: this.appConfig,
-      options: {
-        hostname: this.serveOptions.hostname,
-        port: Number(this.serveOptions.port || DEFAULT_ECOPAGES_PORT)
-      }
+      hostname: String(this.serveOptions.hostname || DEFAULT_ECOPAGES_HOSTNAME),
+      port: Number(this.serveOptions.port || DEFAULT_ECOPAGES_PORT)
     });
-    await this.previewServer.start();
     const previewHostname = this.serveOptions.hostname || DEFAULT_ECOPAGES_HOSTNAME;
     const previewPort = this.serveOptions.port || DEFAULT_ECOPAGES_PORT;
     appLogger.info(`Preview running at http://${previewHostname}:${previewPort}`);
   }
-  /**
-   * Converts a Node.js `IncomingMessage` into a Web API `Request`.
-   *
-   * Multi-value headers (e.g. `set-cookie`) are appended individually so no
-   * value is silently dropped.
-   *
-   * For methods that carry a body (`POST`, `PUT`, `PATCH`, …), the raw
-   * `IncomingMessage` stream is wrapped in a `ReadableStream` rather than
-   * cast directly to `BodyInit`. See the inline doc block inside the `if`
-   * branch for the rationale (client-abort handling).
-   *
-   * `duplex: 'half'` is required by the `fetch` spec when a streaming body is
-   * provided — without it Node.js 18+ throws a `TypeError`.
-   */
-  createWebRequest(req) {
-    const url = new URL(req.url ?? "/", this.runtimeOrigin);
-    const headers = new Headers();
-    for (const [key, value] of Object.entries(req.headers)) {
-      if (Array.isArray(value)) {
-        for (const item of value) {
-          headers.append(key, item);
-        }
-        continue;
-      }
-      if (value !== void 0) {
-        headers.set(key, value);
-      }
-    }
-    const method = (req.method ?? "GET").toUpperCase();
-    const requestInit = {
-      method,
-      headers
-    };
-    if (method !== "GET" && method !== "HEAD") {
-      const body = new ReadableStream({
-        start(controller) {
-          req.on("data", (chunk) => controller.enqueue(chunk));
-          req.once("end", () => controller.close());
-          req.once("aborted", () => {
-            controller.error(new ClientAbortError());
-          });
-          req.once("error", (err) => {
-            const isClientAbort = err.code === "ECONNRESET";
-            controller.error(isClientAbort ? new ClientAbortError() : err);
-          });
-        },
-        cancel() {
-          req.destroy();
-        }
-      });
-      requestInit.body = body;
-      requestInit.duplex = "half";
-    }
-    return new Request(url, requestInit);
-  }
-  /**
-   * Writes a Web `Response` back to a Node.js `ServerResponse`.
-   *
-   * The entire body is buffered via `arrayBuffer()` before writing. This is
-   * intentional for the current use-case (SSR pages and API routes), where
-   * responses are typically small and fully materialised. Streaming responses
-   * are not yet supported.
-   */
-  async sendNodeResponse(res, response) {
-    res.statusCode = response.status;
-    response.headers.forEach((value, key) => {
-      res.setHeader(key, value);
-    });
-    if (!response.body) {
-      res.end();
-      return;
-    }
-    const body = Buffer.from(await response.arrayBuffer());
-    res.end(body);
-  }
-  /**
-   * Starts an ephemeral HTTP server used *only* during a static site generation
-   * run.
-   *
-   * Static generation works by having the `StaticSiteGenerator` issue real HTTP
-   * requests to a live server for each route, capturing the rendered HTML. This
-   * approach reuses the normal request pipeline (middleware, caching, API
-   * handlers) without any special-casing for the build path.
-   *
-   * The server is torn down immediately after generation completes via
-   * `stopBuildRuntimeServer`, so it never overlaps with the actual dev/prod server.
-   */
   async startBuildRuntimeServer() {
     const hostname = String(this.serveOptions.hostname || DEFAULT_ECOPAGES_HOSTNAME);
     const port = 0;
     const server = createServer(async (req, res) => {
       try {
-        const webRequest = this.createWebRequest(req);
+        const webRequest = this.requestBridge.createWebRequest(req, this.runtimeOrigin);
         const response = await this.handleRequest(webRequest);
-        await this.sendNodeResponse(res, response);
+        await this.requestBridge.sendNodeResponse(res, response);
       } catch (error) {
+        if (error instanceof NodeClientAbortError) {
+          return;
+        }
         appLogger.error("Node static build runtime request failed", error);
         res.statusCode = 500;
         res.end("Internal Server Error");
@@ -310,7 +228,7 @@ class NodeServerAdapter extends SharedServerAdapter {
       });
       return await this.maybeInjectHmrScript(response);
     } catch (error) {
-      if (error instanceof ClientAbortError) {
+      if (error instanceof NodeClientAbortError) {
         return new Response(null, { status: 499 });
       }
       throw error;
@@ -335,9 +253,10 @@ class NodeServerAdapter extends SharedServerAdapter {
   async completeInitialization(server) {
     this.serverInstance = server;
     if (this.options?.watch) {
-      const wss = new WebSocketServer({ noServer: true });
-      this.bridge = new NodeClientBridge();
-      this.hmrManager = new NodeHmrManager({ appConfig: this.appConfig, bridge: this.bridge });
+      const devRuntime = this.devRuntimeFactory.create({ appConfig: this.appConfig });
+      const wss = devRuntime.websocketServer;
+      this.bridge = devRuntime.bridge;
+      this.hmrManager = devRuntime.hmrManager;
       this.hmrManager.setEnabled(true);
       await this.hmrManager.buildRuntime();
       server.on("upgrade", (req, socket, head) => {
@@ -352,10 +271,14 @@ class NodeServerAdapter extends SharedServerAdapter {
           socket.destroy();
         }
       });
-      bindSharedRuntimeHmrManager(this.appConfig, this.hmrManager);
+      const browserBuildPlugins = getAppBrowserBuildPlugins(this.appConfig);
+      this.hmrManager.setPlugins(browserBuildPlugins);
+      for (const integration of this.appConfig.integrations) {
+        integration.setHmrManager(this.hmrManager);
+      }
       this.configureSharedResponseHandlers(this.staticRoutes, this.hmrManager);
-      await startSharedProjectWatching({
-        appConfig: this.appConfig,
+      const watcher = new ProjectWatcher({
+        config: this.appConfig,
         refreshRouterRoutesCallback: this.createSharedWatchRefreshCallback({
           staticRoutes: this.staticRoutes,
           hmrManager: this.hmrManager
@@ -363,6 +286,7 @@ class NodeServerAdapter extends SharedServerAdapter {
         hmrManager: this.hmrManager,
         bridge: this.bridge
       });
+      await watcher.createWatcherSubscription();
     }
     appLogger.debug("Node server adapter initialization completed", {
       apiHandlers: this.apiHandlers.length,
@@ -373,10 +297,16 @@ class NodeServerAdapter extends SharedServerAdapter {
   }
 }
 async function createNodeServerAdapter(params) {
-  const runtimeOrigin = params.runtimeOrigin ?? `http://${params.serveOptions.hostname || DEFAULT_ECOPAGES_HOSTNAME}:${params.serveOptions.port || DEFAULT_ECOPAGES_PORT}`;
+  const runtimeOrigin = params.runtimeOrigin ?? resolveServeRuntimeOrigin(params.serveOptions);
+  const previewHost = params.previewHost ?? new NodeStaticPreviewHost();
+  const requestBridge = params.requestBridge ?? new NodeHttpRequestBridge();
+  const devRuntimeFactory = params.devRuntimeFactory ?? new DefaultNodeServerDevRuntimeFactory();
   const adapter = new NodeServerAdapter({
     ...params,
-    runtimeOrigin
+    runtimeOrigin,
+    previewHost,
+    requestBridge,
+    devRuntimeFactory
   });
   return adapter.createAdapter();
 }

package/src/adapters/node/static-preview-host.d.ts

@@ -0,0 +1,55 @@
+import type { AddressInfo } from 'node:net';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { StaticPreviewHost, StaticPreviewHostStartOptions } from '../shared/static-preview-host.js';
+type NodeStaticPreviewServer = {
+    start(): Promise<{
+        address(): AddressInfo | string | null;
+    }>;
+    stop(force?: boolean): Promise<void>;
+};
+type NodeStaticPreviewServerFactory = new (args: {
+    appConfig: EcoPagesAppConfig;
+    options?: {
+        hostname?: string;
+        port?: number;
+    };
+}) => NodeStaticPreviewServer;
+/**
+ * Node preview-host wrapper that manages the lifecycle of the static preview
+ * server used after a build.
+ *
+ * @remarks
+ * The host separates preview-server construction from lifecycle control so the
+ * Node server adapter can restart preview serving safely across repeated build
+ * and preview flows.
+ */
+export declare class NodeStaticPreviewHost implements StaticPreviewHost {
+    private readonly previewServerFactory;
+    private previewServer;
+    private stopPromise;
+    /**
+     * Creates the preview host with an injectable preview-server constructor.
+     */
+    constructor(previewServerFactory?: NodeStaticPreviewServerFactory);
+    /**
+     * Starts the Node preview host after fully draining any previous preview server
+     * shutdown that may still be in flight.
+     *
+     * @remarks
+     * The host only publishes a new preview server after `start()` succeeds. That
+     * keeps failed startup attempts from replacing the last known-good server with a
+     * half-initialized instance.
+     */
+    start(options: StaticPreviewHostStartOptions): Promise<number | null>;
+    /**
+     * Stops the active preview server and coalesces overlapping stop requests onto
+     * the same shutdown promise.
+     *
+     * @remarks
+     * The host keeps the server reference until shutdown succeeds. If shutdown
+     * fails, callers can still retry `stop()` or inspect the same live instance
+     * instead of losing the handle during a rejected async stop.
+     */
+    stop(force?: boolean): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,68 @@
+import { NodeStaticContentServer } from "./static-content-server.js";
+class NodeStaticPreviewHost {
+  /**
+   * Creates the preview host with an injectable preview-server constructor.
+   */
+  constructor(previewServerFactory = NodeStaticContentServer) {
+    this.previewServerFactory = previewServerFactory;
+  }
+  previewServerFactory;
+  previewServer = null;
+  stopPromise = null;
+  /**
+   * Starts the Node preview host after fully draining any previous preview server
+   * shutdown that may still be in flight.
+   *
+   * @remarks
+   * The host only publishes a new preview server after `start()` succeeds. That
+   * keeps failed startup attempts from replacing the last known-good server with a
+   * half-initialized instance.
+   */
+  async start(options) {
+    await this.stop();
+    const previewServer = new this.previewServerFactory({
+      appConfig: options.appConfig,
+      options: {
+        hostname: options.hostname,
+        port: options.port
+      }
+    });
+    const server = await previewServer.start();
+    this.previewServer = previewServer;
+    const address = server.address();
+    if (address && typeof address === "object") {
+      return address.port;
+    }
+    return options.port;
+  }
+  /**
+   * Stops the active preview server and coalesces overlapping stop requests onto
+   * the same shutdown promise.
+   *
+   * @remarks
+   * The host keeps the server reference until shutdown succeeds. If shutdown
+   * fails, callers can still retry `stop()` or inspect the same live instance
+   * instead of losing the handle during a rejected async stop.
+   */
+  async stop(force = true) {
+    if (this.stopPromise) {
+      await this.stopPromise;
+      return;
+    }
+    if (!this.previewServer) {
+      return;
+    }
+    const activePreviewServer = this.previewServer;
+    this.stopPromise = activePreviewServer.stop(force).then(() => {
+      if (this.previewServer === activePreviewServer) {
+        this.previewServer = null;
+      }
+    }).finally(() => {
+      this.stopPromise = null;
+    });
+    await this.stopPromise;
+  }
+}
+export {
+  NodeStaticPreviewHost
+};

package/src/adapters/shared/runtime-app-bootstrap.d.ts

@@ -0,0 +1,26 @@
+import type { ReturnParseCliArgs } from '../../utils/parse-cli-args.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+export type RuntimeBinding = {
+    preferredPort: number;
+    preferredHostname: string;
+    runtimeOrigin: string;
+    serveOptions: Record<string, unknown>;
+    watch: boolean;
+};
+export type StaticRuntimeMode = {
+    requiresFetchRuntime: boolean;
+    canBuildWithoutRuntimeServer: boolean;
+};
+export declare function resolveServeRuntimeOrigin(serveOptions: {
+    hostname?: string;
+    port?: number | string;
+}): string;
+export declare function resolveRuntimeBinding(options: {
+    cliArgs: ReturnParseCliArgs;
+    serverOptions?: Record<string, unknown>;
+    env?: NodeJS.ProcessEnv;
+}): RuntimeBinding;
+export declare function resolveStaticRuntimeMode(options: {
+    appConfig: EcoPagesAppConfig;
+    cliArgs: ReturnParseCliArgs;
+}): StaticRuntimeMode;