@ecopages/core 0.2.0-alpha.9 → 0.2.1-beta.0

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

@@ -1,310 +1,47 @@
-import fs from "node:fs";
-import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../constants.js";
-import { getAppBuildExecutor } from "../../build/build-adapter.js";
-import { fileSystem } from "@ecopages/file-system";
-import { HmrStrategyType } from "../../hmr/hmr-strategy.js";
-import { DefaultHmrStrategy } from "../../hmr/strategies/default-hmr-strategy.js";
-import { JsHmrStrategy } from "../../hmr/strategies/js-hmr-strategy.js";
 import { appLogger } from "../../global/app-logger.js";
-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.js";
 import {
-  getAppEntrypointDependencyGraph,
-  InMemoryEntrypointDependencyGraph,
-  setAppEntrypointDependencyGraph
+  InMemoryEntrypointDependencyGraph
 } 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 NodeHmrManager {
-  static entrypointRegistrationTimeoutMs = 4e3;
-  appConfig;
-  bridge;
-  watchers = /* @__PURE__ */ new Map();
-  watchedFiles = /* @__PURE__ */ new Map();
-  entrypointRegistrations = /* @__PURE__ */ new Map();
-  distDir;
-  plugins = [];
-  enabled = true;
-  strategies = [];
-  entrypointRegistrar;
-  browserBundleService;
-  entrypointDependencyGraph;
-  runtimeSpecifierRegistry;
-  serverModuleTranspiler;
-  constructor({ appConfig, bridge }) {
-    this.appConfig = appConfig;
-    this.bridge = bridge;
-    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: NodeHmrManager.entrypointRegistrationTimeoutMs
-    });
-    this.browserBundleService = new BrowserBundleService(appConfig);
-    const existingEntrypointDependencyGraph = getAppEntrypointDependencyGraph(appConfig);
-    this.entrypointDependencyGraph = existingEntrypointDependencyGraph instanceof InMemoryEntrypointDependencyGraph ? existingEntrypointDependencyGraph : new InMemoryEntrypointDependencyGraph();
-    setAppEntrypointDependencyGraph(this.appConfig, this.entrypointDependencyGraph);
-    this.runtimeSpecifierRegistry = getAppRuntimeSpecifierRegistry(this.appConfig);
-    this.serverModuleTranspiler = getAppServerModuleTranspiler(this.appConfig);
-    this.cleanDistDir();
-    this.initializeStrategies();
-  }
-  /**
-   * Ensures the HMR output directory exists.
-   *
-   * This must not remove the directory because multiple app processes
-   * can share the same dist path during e2e runs.
-   */
-  cleanDistDir() {
-    fileSystem.ensureDir(this.distDir);
-  }
-  /**
-   * Returns whether the generic JS strategy is allowed to rebuild an entrypoint.
-   *
-   * @remarks
-   * Higher-priority integration strategies own framework page entrypoints. When
-   * one of them matches, the generic JS strategy must stay out of the way so a
-   * shared dependency invalidation does not overwrite framework-specific output.
-   */
-  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;
-      }
-    });
-  }
-  initializeStrategies() {
-    const jsContext = {
-      getWatchedFiles: () => this.watchedFiles,
-      getSpecifierMap: () => this.runtimeSpecifierRegistry.getAll(),
-      getDistDir: () => this.distDir,
-      getPlugins: () => this.plugins,
-      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()];
-  }
-  registerStrategy(strategy) {
-    this.strategies.push(strategy);
-  }
-  setPlugins(plugins) {
-    this.plugins = [...plugins];
-  }
-  setEnabled(enabled) {
-    this.enabled = enabled;
-  }
-  isEnabled() {
-    return this.enabled;
-  }
-  /**
-   * Registers runtime bare-specifier mappings exposed by integrations.
-   *
-   * @remarks
-   * These mappings are consumed by framework-owned HMR strategies such as the
-   * React integration strategy when they rewrite browser bundles. The registry
-   * stays generic so the same mappings can support broader import-map-style
-   * runtime features later without moving integration semantics into core.
-   */
-  registerSpecifierMap(map) {
-    this.runtimeSpecifierRegistry.register(map);
-  }
-  async buildRuntime() {
-    const runtimeSource = path.resolve(import.meta.dirname, "../../hmr/client/hmr-runtime.js");
-    try {
-      const result = await this.browserBundleService.bundle({
-        profile: "hmr-runtime",
-        entrypoints: [runtimeSource],
-        outdir: this.distDir,
-        naming: "_hmr_runtime.js",
-        minify: false,
-        plugins: this.plugins
-      });
-      if (!result.success) {
-        this.enabled = false;
-        appLogger.error("[HMR] Failed to build runtime script; continuing with HMR disabled.", result.logs);
-      }
-    } catch (error) {
-      this.enabled = false;
-      appLogger.error("[HMR] Failed to build runtime script; continuing with HMR disabled.", error);
-    }
-  }
-  getRuntimePath() {
-    return path.join(this.distDir, "_hmr_runtime.js");
-  }
-  broadcast(event) {
-    appLogger.debug(
-      `[HMR] Broadcasting ${event.type} event, path=${event.path || "all"}, subscribers=${this.bridge.subscriberCount}`
-    );
-    this.bridge.broadcast(event);
-  }
-  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(err);
-        return false;
-      }
-    });
-    if (!strategy) {
-      appLogger.warn(`[HMR] No strategy found for ${filePath}`);
-      return;
-    }
-    appLogger.debug(`[NodeHmrManager] Selected strategy: ${strategy.constructor.name}`);
-    const action = await strategy.process(filePath);
-    const shouldBroadcast = options.broadcast ?? true;
-    if (shouldBroadcast && action.type === "broadcast") {
-      if (action.events) {
-        for (const event of action.events) {
-          this.broadcast(event);
-        }
-      }
-    }
-  }
-  getOutputUrl(entrypointPath) {
-    return this.watchedFiles.get(entrypointPath);
-  }
-  getWatchedFiles() {
-    return this.watchedFiles;
-  }
-  getSpecifierMap() {
-    return this.runtimeSpecifierRegistry.getAll();
-  }
-  getDistDir() {
-    return this.distDir;
-  }
-  getPlugins() {
-    return this.plugins;
-  }
-  getDefaultContext() {
-    return {
-      getWatchedFiles: () => this.watchedFiles,
-      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,
-      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);
-    this.entrypointDependencyGraph.clearEntrypointDependencies(entrypointPath);
-  }
+import { SharedHmrManager } from "../shared/shared-hmr-manager.js";
+class NodeHmrManager extends SharedHmrManager {
   /**
-   * Registers one integration-owned page entrypoint.
+   * Creates the Node HMR manager over the shared coordination pipeline.
    *
    * @remarks
-   * Concurrent callers share one in-flight registration. The registration is
-   * removed from the dedupe map once it resolves or fails so later requests do
-   * not inherit stale state.
+   * Unlike Bun, Node keeps websocket subscription wiring in the server adapter,
+   * so this manager only specializes the shared manager where runtime behavior
+   * actually differs: dependency-graph storage, missing-file tolerance, and how
+   * runtime bundle failures disable HMR.
    */
-  async registerEntrypoint(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 path is intentionally separate from page entrypoints so non-framework
-   * scripts can still use the generic build fallback without weakening the page
-   * ownership contract.
-   */
-  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}`)
-    });
+  constructor({ appConfig, bridge }) {
+    super({ appConfig, bridge });
   }
   /**
-   * Performs strict integration-owned entrypoint registration for one normalized source path.
-   *
-   * @remarks
-   * The flow is:
-   * 1. Reserve the output URL in the watched map.
-   * 2. Remove any stale emitted file from an earlier process or failed build.
-   * 3. Let the strategy chain try to emit the entrypoint without broadcasting.
-   * 4. Fail if the owning integration did not emit the expected output.
+   * Reuses the shared in-memory dependency graph when the app already has one and
+   * otherwise creates the default Node development graph.
    */
-  async emitStrictEntrypoint(entrypointPath, _outputPath) {
-    await this.handleFileChange(entrypointPath, { broadcast: false });
+  createEntrypointDependencyGraph(existingEntrypointDependencyGraph) {
+    return existingEntrypointDependencyGraph instanceof InMemoryEntrypointDependencyGraph ? existingEntrypointDependencyGraph : new InMemoryEntrypointDependencyGraph();
   }
   /**
-   * Performs registration for a generic script asset.
+   * Tells the shared HMR manager to ignore missing-file events during Node watch
+   * mode.
    *
    * @remarks
-   * The manager first gives registered strategies a chance to emit the file so
-   * processor-owned or integration-owned behavior can still participate. Only
-   * when no output exists does it issue the generic build.
+   * Node file watching can briefly report remove-and-recreate sequences while a
+   * file is being rewritten. Treating those transient gaps as fatal would disable
+   * otherwise healthy development sessions.
    */
-  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 buildResult = await this.browserBundleService.bundle({
-        profile: "hmr-entrypoint",
-        entrypoints: [entrypointPath],
-        outdir: this.distDir,
-        naming,
-        minify: false,
-        plugins: this.plugins
-      });
-      if (!buildResult.success) {
-        appLogger.error(
-          `[HMR] Generic script entrypoint build failed for ${entrypointPath}:`,
-          buildResult.logs
-        );
-      }
-    }
+  shouldSkipMissingFileChange(_filePath) {
+    return true;
   }
   /**
-   * Stops active watchers and releases retained registration state.
-   *
-   * @remarks
-   * The manager intentionally does not remove emitted `_hmr` files from disk
-   * because multiple app processes may share the same dist directory during test
-   * runs. It does clear in-memory indexes so old entrypoints, dependencies, and
-   * specifier maps cannot leak across a reused manager instance.
+   * Disables HMR after a runtime bundle failure so the Node dev server can keep
+   * serving requests without repeatedly emitting broken updates.
    */
-  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 = [];
+  onRuntimeBundleFailure(error) {
+    this.enabled = false;
+    appLogger.error("[HMR] Failed to build runtime script; continuing with HMR disabled.", error);
   }
 }
 export {

package/src/adapters/node/runtime-host.d.ts

@@ -0,0 +1,57 @@
+import { createServer, type Server as NodeServerInstance } from 'node:http';
+import type { RuntimeHost, RuntimeHostStartOptions } from '../shared/runtime-host.js';
+import { NodeHttpRequestBridge } from './http-request-bridge.js';
+type NodeServerFactory = typeof createServer;
+/**
+ * Node runtime host that binds the shared Web-request pipeline onto a concrete
+ * Node HTTP server.
+ *
+ * @remarks
+ * The host owns only transport concerns: creating the Node listener, converting
+ * requests through `NodeHttpRequestBridge`, and handling socket-level failures.
+ * Routing and rendering remain in the shared server adapter.
+ */
+export declare class NodeRuntimeHost implements RuntimeHost<NodeServerInstance, {
+    port?: number;
+    hostname?: string;
+}> {
+    private readonly requestBridge;
+    private readonly serverFactory;
+    /**
+     * Creates a Node runtime host with injectable request bridging and server
+     * creation seams for tests and alternate hosts.
+     */
+    constructor(requestBridge: NodeHttpRequestBridge, serverFactory?: NodeServerFactory);
+    /**
+     * 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.
+     */
+    start(options: RuntimeHostStartOptions<{
+        port?: number;
+        hostname?: string;
+    }>): Promise<NodeServerInstance>;
+    /**
+     * Stops the Node HTTP server and, by default, force-closes any remaining open
+     * connections.
+     */
+    stop(server: NodeServerInstance, options?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * 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: NodeServerInstance, fallbackServeOptions: {
+        port?: number;
+        hostname?: string;
+    }): string;
+}
+export {};

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

@@ -1,8 +1,11 @@
 import { type Server as NodeHttpServer } from 'node:http';
-import type { EcoPagesAppConfig } from '../../internal-types.js';
-import type { ApiHandler, ErrorHandler, StaticRoute } from '../../public-types.js';
+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,14 @@ 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;
     constructor(options: NodeServerAdapterParams);
     /**
      * Prepares the adapter for use.
@@ -68,47 +79,13 @@ 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;
     /**
      * Gracefully shuts down the ephemeral build runtime server.
      *
@@ -132,7 +109,7 @@ export declare class NodeServerAdapter extends SharedServerAdapter<NodeServerAda
      * underlying socket closes early — into a 499 response so it does not
      * incorrectly surface as a 500 in application logs.
      */
-    handleRequest(_request: Request): Promise<Response>;
+    handleRequest(request: Request): Promise<Response>;
     /**
      * Called once the HTTP server is bound and listening.
      *
@@ -141,7 +118,7 @@ export declare class NodeServerAdapter extends SharedServerAdapter<NodeServerAda
      *   `upgrade` event (no separate port needed).
      * - `NodeClientBridge` tracks active WebSocket connections and handles
      *   broadcast + heartbeat cleanup.
-     * - `NodeHmrManager` watches the filesystem and triggers incremental esbuild
+     * - `NodeHmrManager` watches the filesystem and triggers incremental
      *   rebuilds, notifying connected clients via the bridge.
      * - Shared watcher bootstrapping listens for route-level file changes and
      *   refreshes the router and response handlers when pages are added or removed.
@@ -149,7 +126,7 @@ export declare class NodeServerAdapter extends SharedServerAdapter<NodeServerAda
      * WebSocket upgrade requests that do not target `/_hmr` are rejected with an
      * immediate socket destroy to prevent unhandled upgrade leaks.
      */
-    completeInitialization(_server: NodeServerInstance): Promise<void>;
+    completeInitialization(server: NodeServerInstance): Promise<void>;
 }
 /**
  * Factory function that creates and fully initialises a `NodeServerAdapter`.