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

package/src/adapters/index.js

@@ -1,14 +1,8 @@
-import { EcopagesApp, createApp } from "./bun/create-app.js";
+import { EcopagesApp, createApp } from "./create-app.js";
 import { defineApiHandler, defineGroupHandler } from "./shared/define-api-handler.js";
-import { NodeServerAdapter, createNodeServerAdapter } from "./node/server-adapter.js";
-import { EcopagesApp as EcopagesApp2, createNodeApp } from "./node/create-app.js";
 export {
   EcopagesApp,
-  EcopagesApp2 as NodeAdapterEcopagesApp,
-  NodeServerAdapter,
   createApp,
-  createNodeApp,
-  createNodeServerAdapter,
   defineApiHandler,
   defineGroupHandler
 };

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

@@ -1,21 +1,24 @@
-import { type Server as NodeServerInstance } from 'node:http';
-import type { EcoPagesAppConfig } from '../../internal-types.js';
-import { type ApplicationAdapterOptions } from '../abstract/application-adapter.js';
 import { SharedApplicationAdapter } from '../shared/application-adapter.js';
-import { type NodeServerAdapterResult } from './server-adapter.js';
-export interface EcopagesAppOptions extends ApplicationAdapterOptions {
-    appConfig: EcoPagesAppConfig;
-    serverOptions?: Record<string, any>;
-}
-export declare class EcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, NodeServerInstance, Request> {
+import type { RuntimeHost } from '../shared/runtime-host.js';
+import type { EcopagesAppOptions } from '../create-app.js';
+import { type NodeServerAdapterResult, createNodeServerAdapter } from './server-adapter.js';
+import type { NodeServerInstance } from './server-adapter.js';
+export declare class NodeEcopagesApp extends SharedApplicationAdapter<EcopagesAppOptions, NodeServerInstance, Request> {
     serverAdapter: NodeServerAdapterResult | undefined;
     private server;
     private runtimeOrigin;
+    private readonly runtimeHost;
+    constructor(options: EcopagesAppOptions, dependencies: {
+        runtimeHost: RuntimeHost<NodeServerInstance, {
+            port?: number;
+            hostname?: string;
+        }>;
+    });
+    protected createServerAdapter(params: Parameters<typeof createNodeServerAdapter>[0]): Promise<NodeServerAdapterResult>;
     stop(force?: boolean): Promise<void>;
     protected initializeServerAdapter(): Promise<NodeServerAdapterResult>;
     start(): Promise<NodeServerInstance | void>;
-    private createWebRequest;
-    private sendNodeResponse;
     fetch(request: Request): Promise<Response>;
 }
-export declare function createNodeApp(options: EcopagesAppOptions): Promise<EcopagesApp>;
+export declare function createNodeApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp>;
+export declare function createApp(options: EcopagesAppOptions): Promise<NodeEcopagesApp>;

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

@@ -1,53 +1,43 @@
-import { createServer } from "node:http";
-import { Readable } from "node:stream";
-import { DEFAULT_ECOPAGES_HOSTNAME, DEFAULT_ECOPAGES_PORT } from "../../constants.js";
 import { appLogger } from "../../global/app-logger.js";
-import {} from "../abstract/application-adapter.js";
 import { SharedApplicationAdapter } from "../shared/application-adapter.js";
+import { resolveRuntimeBinding } from "../shared/runtime-app-bootstrap.js";
 import { createNodeServerAdapter } from "./server-adapter.js";
-class EcopagesApp extends SharedApplicationAdapter {
+import { NodeHttpRequestBridge } from "./http-request-bridge.js";
+import { NodeRuntimeHost } from "./runtime-host.js";
+class NodeEcopagesApp extends SharedApplicationAdapter {
   serverAdapter;
   server = null;
   runtimeOrigin = "";
+  runtimeHost;
+  constructor(options, dependencies) {
+    super(options);
+    this.runtimeHost = dependencies.runtimeHost;
+  }
+  createServerAdapter(params) {
+    return createNodeServerAdapter(params);
+  }
   async stop(force = true) {
     if (!this.server) {
       return;
     }
     const activeServer = this.server;
     this.server = null;
-    await new Promise((resolve, reject) => {
-      activeServer.close((error) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve();
-      });
-      if (force) {
-        activeServer.closeAllConnections();
-      }
-    });
+    await this.runtimeHost.stop(activeServer, { force });
   }
   async initializeServerAdapter() {
-    const { dev } = this.cliArgs;
-    const { port: cliPort, hostname: cliHostname } = this.cliArgs;
-    const envPort = process.env.ECOPAGES_PORT;
-    const envHostname = process.env.ECOPAGES_HOSTNAME;
-    const preferredPort = cliPort ?? (envPort ? Number(envPort) : void 0) ?? DEFAULT_ECOPAGES_PORT;
-    const preferredHostname = cliHostname ?? envHostname ?? DEFAULT_ECOPAGES_HOSTNAME;
-    this.runtimeOrigin = `http://${preferredHostname}:${preferredPort}`;
-    return createNodeServerAdapter({
+    const binding = resolveRuntimeBinding({
+      cliArgs: this.cliArgs,
+      serverOptions: this.serverOptions
+    });
+    this.runtimeOrigin = binding.runtimeOrigin;
+    return this.createServerAdapter({
       runtimeOrigin: this.runtimeOrigin,
       appConfig: this.appConfig,
       apiHandlers: this.apiHandlers,
       staticRoutes: this.staticRoutes,
       errorHandler: this.errorHandler,
-      options: { watch: dev },
-      serveOptions: {
-        port: preferredPort,
-        hostname: preferredHostname,
-        ...this.serverOptions
-      }
+      options: { watch: binding.watch },
+      serveOptions: binding.serveOptions
     });
   }
   async start() {
@@ -69,64 +59,17 @@ class EcopagesApp extends SharedApplicationAdapter {
       return;
     }
     const serveOptions = this.serverAdapter.getServerOptions();
-    const hostname = String(serveOptions.hostname ?? DEFAULT_ECOPAGES_HOSTNAME);
-    const port = Number(serveOptions.port ?? DEFAULT_ECOPAGES_PORT);
-    this.runtimeOrigin = `http://${hostname}:${port}`;
-    this.server = createServer(async (req, res) => {
-      try {
-        const webRequest = this.createWebRequest(req);
-        const response = await this.serverAdapter.handleRequest(webRequest);
-        await this.sendNodeResponse(res, response);
-      } catch (error) {
-        appLogger.error("Node server adapter request failed", error);
-        res.statusCode = 500;
-        res.end("Internal Server Error");
+    this.server = await this.runtimeHost.start({
+      serveOptions,
+      handleRequest: async (request) => await this.serverAdapter.handleRequest(request),
+      onError: async () => {
       }
     });
-    await new Promise((resolve) => {
-      this.server.listen(port, hostname, () => resolve());
-    });
+    this.runtimeOrigin = this.runtimeHost.getOrigin(this.server, serveOptions);
     await this.serverAdapter.completeInitialization(this.server);
     appLogger.info(`Node server running at ${this.runtimeOrigin}`);
     return this.server;
   }
-  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") {
-      requestInit.body = Readable.toWeb(req);
-      requestInit.duplex = "half";
-    }
-    return new Request(url, requestInit);
-  }
-  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);
-  }
   async fetch(request) {
     if (!this.serverAdapter) {
       this.serverAdapter = await this.initializeServerAdapter();
@@ -135,9 +78,15 @@ class EcopagesApp extends SharedApplicationAdapter {
   }
 }
 async function createNodeApp(options) {
-  return new EcopagesApp(options);
+  return new NodeEcopagesApp(options, {
+    runtimeHost: new NodeRuntimeHost(new NodeHttpRequestBridge())
+  });
+}
+async function createApp(options) {
+  return createNodeApp(options);
 }
 export {
-  EcopagesApp,
+  NodeEcopagesApp,
+  createApp,
   createNodeApp
 };

package/src/adapters/node/http-request-bridge.d.ts

@@ -0,0 +1,57 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/**
+ * Signals that the remote client closed the HTTP exchange before the Node
+ * adapter finished reading or writing the body.
+ *
+ * @remarks
+ * This error represents a transport-level disconnect, not an application
+ * failure. Higher layers may safely suppress logging for this error when the
+ * client socket is already gone and no meaningful response can still be sent.
+ */
+export declare class NodeClientAbortError extends Error {
+    /**
+     * Creates the canonical Node transport abort error used across request-body
+     * reads and response-body writes.
+     */
+    constructor();
+}
+/**
+ * Type guard for the canonical client-abort error used by the Node adapter.
+ *
+ * @remarks
+ * Runtime hosts use this guard before logging so only explicitly classified
+ * client disconnects are muted. All other failures continue through the normal
+ * error-reporting path.
+ */
+export declare function isNodeClientAbortError(error: unknown): error is NodeClientAbortError;
+/**
+ * Bridges Node's `IncomingMessage` / `ServerResponse` pair to the Web
+ * `Request` / `Response` contract used by the shared routing pipeline.
+ *
+ * @remarks
+ * This class is the Node transport boundary. It owns the translation of request
+ * headers and bodies into Web primitives and the reverse translation of Web
+ * responses back onto Node streams, including client-abort normalization.
+ */
+export declare class NodeHttpRequestBridge {
+    /**
+     * Converts one incoming Node request into the Web `Request` shape consumed by
+     * the shared server adapter.
+     *
+     * @remarks
+     * Non-GET/HEAD requests retain streaming semantics via a `ReadableStream` so
+     * large request bodies do not need to be buffered before route handling begins.
+     */
+    createWebRequest(req: IncomingMessage, runtimeOrigin: string): Request;
+    /**
+     * Sends a Web `Response` through Node's `ServerResponse` without buffering the
+     * full body in memory first.
+     *
+     * @remarks
+     * Streaming responses matter for large payloads and long-lived transports such
+     * as server-sent events. The bridge therefore forwards the `ReadableStream`
+     * directly into the Node writable response instead of materializing an
+     * intermediate `ArrayBuffer`.
+     */
+    sendNodeResponse(res: ServerResponse, response: Response): Promise<void>;
+}

package/src/adapters/node/http-request-bridge.js

@@ -0,0 +1,118 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+class NodeClientAbortError extends Error {
+  /**
+   * Creates the canonical Node transport abort error used across request-body
+   * reads and response-body writes.
+   */
+  constructor() {
+    super("Client closed the request");
+    this.name = "ClientAbortError";
+  }
+}
+function isNodeClientDisconnectCode(code) {
+  return [
+    "ECONNRESET",
+    "EPIPE",
+    "ERR_STREAM_DESTROYED",
+    "ERR_STREAM_PREMATURE_CLOSE",
+    "ERR_STREAM_UNABLE_TO_PIPE"
+  ].includes(code ?? "");
+}
+function isNodeClientAbortError(error) {
+  return error instanceof NodeClientAbortError;
+}
+function toNodeClientAbortError(error) {
+  if (error instanceof NodeClientAbortError) {
+    return error;
+  }
+  if (typeof error === "object" && error !== null && "code" in error) {
+    const code = typeof error.code === "string" ? error.code : void 0;
+    if (isNodeClientDisconnectCode(code)) {
+      return new NodeClientAbortError();
+    }
+  }
+  return null;
+}
+class NodeHttpRequestBridge {
+  /**
+   * Converts one incoming Node request into the Web `Request` shape consumed by
+   * the shared server adapter.
+   *
+   * @remarks
+   * Non-GET/HEAD requests retain streaming semantics via a `ReadableStream` so
+   * large request bodies do not need to be buffered before route handling begins.
+   */
+  createWebRequest(req, runtimeOrigin) {
+    const url = new URL(req.url ?? "/", 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 NodeClientAbortError());
+          });
+          req.once("error", (err) => {
+            const isClientAbort = err.code === "ECONNRESET";
+            controller.error(isClientAbort ? new NodeClientAbortError() : err);
+          });
+        },
+        cancel() {
+          req.destroy();
+        }
+      });
+      requestInit.body = body;
+      requestInit.duplex = "half";
+    }
+    return new Request(url, requestInit);
+  }
+  /**
+   * Sends a Web `Response` through Node's `ServerResponse` without buffering the
+   * full body in memory first.
+   *
+   * @remarks
+   * Streaming responses matter for large payloads and long-lived transports such
+   * as server-sent events. The bridge therefore forwards the `ReadableStream`
+   * directly into the Node writable response instead of materializing an
+   * intermediate `ArrayBuffer`.
+   */
+  async sendNodeResponse(res, response) {
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+      res.setHeader(key, value);
+    });
+    if (!response.body) {
+      res.end();
+      return;
+    }
+    const responseBody = response.body;
+    try {
+      await pipeline(Readable.fromWeb(responseBody), res);
+    } catch (error) {
+      throw toNodeClientAbortError(error) ?? error;
+    }
+  }
+}
+export {
+  NodeClientAbortError,
+  NodeHttpRequestBridge,
+  isNodeClientAbortError
+};

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

@@ -1,5 +1,5 @@
 import type { WebSocket } from 'ws';
-import type { ClientBridgeEvent, IClientBridge } from '../../public-types.js';
+import type { ClientBridgeEvent, IClientBridge } from '../../types/public-types.js';
 export declare class NodeClientBridge implements IClientBridge {
     private subscribers;
     private heartbeatTimer;

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

@@ -1,14 +1,10 @@
-import type { DefaultHmrContext, EcoPagesAppConfig, IHmrManager, IClientBridge } from '../../internal-types.js';
-import type { EcoBuildPlugin } from '../../build/build-types.js';
-import { type HmrStrategy } from '../../hmr/hmr-strategy.js';
-import type { ClientBridgeEvent } from '../../public-types.js';
+import type { EcoPagesAppConfig, IClientBridge } from '../../types/internal-types.js';
+import { InMemoryEntrypointDependencyGraph, type EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.js';
+import { SharedHmrManager } from '../shared/shared-hmr-manager.js';
 export interface NodeHmrManagerParams {
     appConfig: EcoPagesAppConfig;
     bridge: IClientBridge;
 }
-type HandleFileChangeOptions = {
-    broadcast?: boolean;
-};
 /**
  * Node development HMR manager.
  *
@@ -22,112 +18,35 @@ type HandleFileChangeOptions = {
  * reserved for integration-owned page bundles, while generic script assets must
  * go through `registerScriptEntrypoint()`.
  */
-export declare class NodeHmrManager implements IHmrManager {
-    private static readonly entrypointRegistrationTimeoutMs;
-    readonly appConfig: EcoPagesAppConfig;
-    private readonly bridge;
-    private watchers;
-    private watchedFiles;
-    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;
-    constructor({ appConfig, bridge }: NodeHmrManagerParams);
-    /**
-     * 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.
-     */
-    private cleanDistDir;
+export declare class NodeHmrManager extends SharedHmrManager {
     /**
-     * Returns whether the generic JS strategy is allowed to rebuild an entrypoint.
+     * Creates the Node HMR manager over the shared coordination pipeline.
      *
      * @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.
+     * 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.
      */
-    private shouldJsStrategyProcessEntrypoint;
-    private initializeStrategies;
-    registerStrategy(strategy: HmrStrategy): void;
-    setPlugins(plugins: EcoBuildPlugin[]): void;
-    setEnabled(enabled: boolean): void;
-    isEnabled(): boolean;
-    /**
-     * 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: Record<string, string>): void;
-    buildRuntime(): Promise<void>;
-    getRuntimePath(): string;
-    broadcast(event: ClientBridgeEvent): void;
-    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
-     * removed from the dedupe map once it resolves or fails so later requests do
-     * not inherit stale state.
-     */
-    registerEntrypoint(entrypointPath: string): Promise<string>;
-    /**
-     * 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.
-     */
-    registerScriptEntrypoint(entrypointPath: string): Promise<string>;
+    constructor({ appConfig, bridge }: NodeHmrManagerParams);
     /**
-     * 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.
      */
-    private emitStrictEntrypoint;
+    protected createEntrypointDependencyGraph(existingEntrypointDependencyGraph: EntrypointDependencyGraph): 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.
      */
-    private emitScriptEntrypoint;
+    protected shouldSkipMissingFileChange(_filePath: string): boolean;
     /**
-     * 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(): void;
+    protected onRuntimeBundleFailure(error: unknown): void;
 }
-export {};