@web-widget/node 3.0.0-beta.2 → 3.0.0-beta.5

package/dist/node.d.ts

@@ -1,7 +1,20 @@
 import { IncomingMessage, ServerResponse } from 'node:http';
-import { RequestOptions, NodeHandler } from '@edge-runtime/node-utils';
+import primitives from '@edge-runtime/primitives';
 
-type WebHandler = (req: Request, env: Record<string, unknown>, event: FetchEvent) => Promise<Response> | Response | null | undefined;
+interface BuildDependencies {
+    Headers: typeof Headers;
+    ReadableStream: typeof ReadableStream;
+    Request: typeof Request;
+    Uint8Array: typeof Uint8Array;
+    FetchEvent: typeof primitives.FetchEvent;
+}
+interface RequestOptions {
+    defaultOrigin: string;
+}
+type NodeHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void> | void;
+type EdgeFetchEvent = InstanceType<BuildDependencies['FetchEvent']>;
+
+type WebHandler = (req: Request, env: Record<string, unknown>, event: EdgeFetchEvent) => Promise<Response> | Response | null | undefined;
 interface NodeAdapterOptions extends RequestOptions {
     /** builds a transformer, using Node.js@18 globals, and a base url for URL constructor. */
     defaultOrigin: string;
@@ -17,5 +30,7 @@ declare class NodeAdapter {
     get middleware(): Middleware;
     get handler(): NodeHandler;
 }
+declare function toServerResponse(webResponse: Response | null | undefined, serverResponse: ServerResponse): void | Promise<void>;
+declare function buildToNodeHandler(dependencies: BuildDependencies, options: RequestOptions): (webHandler: WebHandler) => NodeHandler;
 
-export { type Middleware, type NodeAdapterOptions, NodeAdapter as default };
+export { type Middleware, type NodeAdapterOptions, buildToNodeHandler, NodeAdapter as default, toServerResponse };

package/dist/node.js

@@ -1,11 +1,3 @@
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-
 // src/global.ts
 import primitives from "@edge-runtime/primitives";
 if (!Reflect.get(global, "DISABLE_INSTALL_MCA_SHIMS")) {
@@ -17,15 +9,28 @@ if (!Reflect.get(global, "DISABLE_INSTALL_MCA_SHIMS")) {
 }
 
 // src/adapter.ts
-import {
-  buildToFetchEvent,
-  mergeIntoServerResponse,
-  toOutgoingHeaders
-} from "@edge-runtime/node-utils";
 import primitives2 from "@edge-runtime/primitives";
 
+// src/node-utils.ts
+function buildToFetchEvent(dependencies2) {
+  return function toFetchEvent(request) {
+    return new dependencies2.FetchEvent(request);
+  };
+}
+function buildToHeaders({ Headers: HeadersCtor }) {
+  return function toHeaders(nodeHeaders) {
+    const headers = new HeadersCtor();
+    for (const [key, value] of Object.entries(nodeHeaders)) {
+      const values = Array.isArray(value) ? value : [value];
+      for (const item of values) {
+        if (item !== void 0) headers.append(key, item);
+      }
+    }
+    return headers;
+  };
+}
+
 // src/incoming-request.ts
-import { buildToHeaders } from "@edge-runtime/node-utils";
 function isHttp2PseudoHeader(name) {
   return name.startsWith(":");
 }
@@ -50,29 +55,6 @@ function sanitizeIncomingHttpHeaders(headers) {
   }
   return sanitized;
 }
-function computeRequestOrigin(headers, defaultOrigin) {
-  var _a;
-  const authority = (_a = headerValue(headers.host)) != null ? _a : headerValue(headers[":authority"]);
-  if (!authority) {
-    return defaultOrigin;
-  }
-  let protocol = "http";
-  if (defaultOrigin) {
-    try {
-      protocol = new URL(defaultOrigin).protocol.replace(":", "") || "http";
-    } catch {
-    }
-  }
-  const scheme = headerValue(headers[":scheme"]);
-  if (scheme === "http" || scheme === "https") {
-    protocol = scheme;
-  }
-  const [, port] = authority.split(":");
-  if (port === "443") {
-    protocol = "https";
-  }
-  return `${protocol}://${authority}`;
-}
 function buildToReadableStream(dependencies2) {
   const { ReadableStream: ReadableStreamCtor, Uint8Array: Uint8ArrayCtor } = dependencies2;
   return function toReadableStream(stream) {
@@ -99,63 +81,401 @@ function buildToReadableStream(dependencies2) {
     });
   };
 }
-function buildToRequestWithHttp2Compat(dependencies2) {
+function buildToRequest(dependencies2) {
   const toHeaders = buildToHeaders(dependencies2);
   const toReadableStream = buildToReadableStream(dependencies2);
   const { Request: Request2 } = dependencies2;
+  const getRequestHeaders = (incomingHeaders) => {
+    const headers = incomingHeaders[":authority"] ? sanitizeIncomingHttpHeaders(incomingHeaders) : incomingHeaders;
+    if (incomingHeaders[":authority"] || Array.isArray(headers["set-cookie"])) {
+      return toHeaders(headers);
+    }
+    return headers;
+  };
+  let cachedDefaultOrigin = "";
+  let cachedDefaultProtocol = "http";
+  const getDefaultProtocol = (defaultOrigin) => {
+    if (defaultOrigin === cachedDefaultOrigin) {
+      return cachedDefaultProtocol;
+    }
+    cachedDefaultOrigin = defaultOrigin;
+    try {
+      cachedDefaultProtocol = new URL(defaultOrigin).protocol.replace(":", "") || "http";
+    } catch {
+      cachedDefaultProtocol = "http";
+    }
+    return cachedDefaultProtocol;
+  };
   return function toRequest(request, options) {
-    var _a, _b;
-    const base = computeRequestOrigin(request.headers, options.defaultOrigin);
-    const headers = sanitizeIncomingHttpHeaders(request.headers);
-    return new Request2(
-      String(
-        ((_a = request.url) == null ? void 0 : _a.startsWith("//")) ? new URL(base + request.url) : new URL(request.url || "/", base)
-      ),
-      {
-        method: request.method,
-        headers: toHeaders(headers),
-        body: !["HEAD", "GET"].includes((_b = request.method) != null ? _b : "") ? toReadableStream(request) : null
+    const requestHeaders = request.headers;
+    const authority = headerValue(requestHeaders.host) ?? headerValue(requestHeaders[":authority"]);
+    let protocol = getDefaultProtocol(options.defaultOrigin);
+    const scheme = headerValue(requestHeaders[":scheme"]);
+    if (scheme === "http" || scheme === "https") {
+      protocol = scheme;
+    } else if (authority?.endsWith(":443")) {
+      protocol = "https";
+    }
+    const base = authority ? `${protocol}://${authority}` : options.defaultOrigin;
+    const rawUrl = request.url || "/";
+    const url = authority && rawUrl.startsWith("/") ? base + rawUrl : String(new URL(rawUrl, base));
+    const method = request.method || "GET";
+    const headers = getRequestHeaders(requestHeaders);
+    if (method === "GET") {
+      return new Request2(url, { headers });
+    }
+    if (method === "HEAD") {
+      return new Request2(url, { method, headers });
+    }
+    return new Request2(url, {
+      method,
+      headers,
+      body: toReadableStream(request),
+      duplex: "half"
+    });
+  };
+}
+var buildToRequestWithHttp2Compat = buildToRequest;
+function buildToRequestSource(dependencies2, options) {
+  const toRequest = buildToRequest(dependencies2);
+  const incomingKey = Symbol("incomingMessage");
+  const nativeKey = Symbol("nativeRequest");
+  const sourcePrototype = {
+    method: "GET",
+    url: "",
+    toRequest() {
+      return this[nativeKey] ??= toRequest(this[incomingKey], options);
+    },
+    cancel() {
+      const request = this[nativeKey];
+      if (request) {
+        const body = request.body;
+        if (body && !body.locked) body.cancel().catch(() => {
+        });
+      } else if (this.method !== "GET" && this.method !== "HEAD") {
+        this[incomingKey].destroy();
       }
-    );
+    }
+  };
+  let cachedDefaultOrigin = "";
+  let cachedDefaultProtocol = "http";
+  const getDefaultProtocol = (defaultOrigin) => {
+    if (defaultOrigin === cachedDefaultOrigin) return cachedDefaultProtocol;
+    cachedDefaultOrigin = defaultOrigin;
+    try {
+      cachedDefaultProtocol = new URL(defaultOrigin).protocol.replace(":", "") || "http";
+    } catch {
+      cachedDefaultProtocol = "http";
+    }
+    return cachedDefaultProtocol;
+  };
+  return function toRequestSource(incomingMessage) {
+    const headers = incomingMessage.headers;
+    const authority = headerValue(headers.host) ?? headerValue(headers[":authority"]);
+    let protocol = getDefaultProtocol(options.defaultOrigin);
+    const scheme = headerValue(headers[":scheme"]);
+    if (scheme === "http" || scheme === "https") protocol = scheme;
+    else if (authority?.endsWith(":443")) protocol = "https";
+    const base = authority ? `${protocol}://${authority}` : options.defaultOrigin;
+    const rawUrl = incomingMessage.url || "/";
+    const source = Object.create(sourcePrototype);
+    source.method = incomingMessage.method || "GET";
+    source.url = authority && rawUrl.startsWith("/") ? base + rawUrl : String(new URL(rawUrl, base));
+    source[incomingKey] = incomingMessage;
+    return source;
   };
 }
 
+// src/response.ts
+var RESPONSE_CACHE = Symbol.for("@web-widget/node.response-cache");
+var installed = false;
+var HEADER_NAME = /^[!#$%&'*+\-.^`|~\w]+$/;
+function toUnsignedShort(value) {
+  if (typeof value === "bigint" || typeof value === "symbol") {
+    throw new TypeError("Status is not a number");
+  }
+  const number = Number(value);
+  if (!Number.isFinite(number) || number === 0) return 0;
+  const integer = Math.trunc(number);
+  return (integer % 65536 + 65536) % 65536;
+}
+function toByteString(value, name) {
+  if (typeof value === "symbol") {
+    throw new TypeError(`${name} is not a valid ByteString`);
+  }
+  const result = value === void 0 ? "" : String(value);
+  for (let index = 0; index < result.length; index++) {
+    if (result.charCodeAt(index) > 255) {
+      throw new TypeError(`${name} is not a valid ByteString`);
+    }
+  }
+  return result;
+}
+function normalizeHeaderValue(value, name) {
+  let start = 0;
+  let end = value.length;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code > 255)
+      throw new TypeError("Header value is not a valid ByteString");
+    if (code === 0 || code === 10 || code === 13) {
+      throw new TypeError(`Invalid header value for ${name}`);
+    }
+    if (index === start && (code === 9 || code === 32)) start++;
+  }
+  while (end > start) {
+    const code = value.charCodeAt(end - 1);
+    if (code !== 9 && code !== 32) break;
+    end--;
+  }
+  return start === 0 && end === value.length ? value : value.slice(start, end);
+}
+function snapshotCachedHeaders(headers, cache) {
+  if (!headers) return;
+  if (headers instanceof Headers || Array.isArray(headers)) {
+    cache.headers = new Headers(headers);
+    return;
+  }
+  if (Symbol.iterator in headers) {
+    cache.headers = new Headers(headers);
+    return;
+  }
+  const prototype = Object.getPrototypeOf(headers);
+  if (prototype !== Object.prototype && prototype !== null) {
+    cache.headers = new Headers(headers);
+    return;
+  }
+  let firstName;
+  let firstValue;
+  let snapshot;
+  for (const name in headers) {
+    if (!Object.hasOwn(headers, name)) continue;
+    const value = headers[name];
+    if (typeof value !== "string") {
+      cache.headers = new Headers(headers);
+      return;
+    }
+    if (!HEADER_NAME.test(name)) {
+      throw new TypeError(`Invalid header name: ${name}`);
+    }
+    const normalizedName = name.toLowerCase();
+    if (normalizedName === firstName || snapshot !== void 0 && normalizedName in snapshot) {
+      cache.headers = new Headers(headers);
+      return;
+    }
+    const normalizedValue = normalizeHeaderValue(value, name);
+    if (firstName === void 0) {
+      firstName = normalizedName;
+      firstValue = normalizedValue;
+    } else {
+      snapshot ??= Object.assign(/* @__PURE__ */ Object.create(null), {
+        [firstName]: firstValue
+      });
+      snapshot[normalizedName] = normalizedValue;
+    }
+  }
+  if (snapshot) cache.headers = snapshot;
+  else if (firstName !== void 0) {
+    cache.headerName = firstName;
+    cache.headerValue = firstValue;
+  }
+}
+function getCachedResponse(response) {
+  return response[RESPONSE_CACHE];
+}
+function installCachedResponse() {
+  if (installed) return;
+  installed = true;
+  if (Reflect.get(globalThis, "DISABLE_INSTALL_MCA_SHIMS")) return;
+  const NativeResponse = globalThis.Response;
+  const defaultContentType = "text/plain;charset=UTF-8";
+  const getNative = Symbol("getNativeResponse");
+  class CachedWebResponse {
+    #body;
+    #init;
+    #native;
+    constructor(body = null, init) {
+      const status = init?.status === void 0 ? 200 : toUnsignedShort(init.status);
+      if (status < 200 || status > 599) {
+        throw new RangeError(
+          'init["status"] must be in the range of 200 to 599, inclusive.'
+        );
+      }
+      const statusText = toByteString(init?.statusText, "statusText");
+      if (/[^\t\x20-\x7e\x80-\xff]/.test(statusText)) {
+        throw new TypeError("Invalid statusText");
+      }
+      if (body !== null && (status === 204 || status === 205 || status === 304)) {
+        throw new TypeError(
+          "Response constructor: Invalid response status code"
+        );
+      }
+      if (body === null || typeof body === "string" || body instanceof Uint8Array || body instanceof Blob) {
+        const cachedBody = body instanceof Uint8Array ? new Uint8Array(body) : body;
+        this.#body = cachedBody;
+        const cache = {
+          body: cachedBody,
+          status,
+          statusText
+        };
+        snapshotCachedHeaders(init?.headers, cache);
+        this[RESPONSE_CACHE] = cache;
+      } else {
+        const headers = new Headers(init?.headers);
+        const normalizedInit = { ...init, headers, status, statusText };
+        this.#body = body;
+        this.#init = normalizedInit;
+        this.#native = new NativeResponse(body, normalizedInit);
+      }
+    }
+    [getNative]() {
+      if (!this.#native) {
+        const cache = this[RESPONSE_CACHE];
+        if (cache) {
+          delete this[RESPONSE_CACHE];
+          this.#init = {
+            headers: cache.headers ?? (cache.headerName ? { [cache.headerName]: cache.headerValue } : void 0),
+            status: cache.status,
+            statusText: cache.statusText
+          };
+        }
+        this.#native = new NativeResponse(this.#body, this.#init);
+      }
+      return this.#native;
+    }
+    get headers() {
+      const cache = this[RESPONSE_CACHE];
+      if (!cache) return this[getNative]().headers;
+      if (cache.headerName) {
+        cache.headers = new Headers({
+          [cache.headerName]: cache.headerValue
+        });
+        cache.headerName = void 0;
+        cache.headerValue = void 0;
+      } else if (!(cache.headers instanceof Headers)) {
+        cache.headers = new Headers(cache.headers);
+      }
+      if (typeof cache.body === "string" && !cache.headers.has("content-type")) {
+        cache.headers.set("content-type", defaultContentType);
+      }
+      return cache.headers;
+    }
+    get status() {
+      return this[RESPONSE_CACHE]?.status ?? this[getNative]().status;
+    }
+    get ok() {
+      const status = this.status;
+      return status >= 200 && status < 300;
+    }
+  }
+  for (const property of [
+    "body",
+    "bodyUsed",
+    "redirected",
+    "statusText",
+    "type",
+    "url"
+  ]) {
+    Object.defineProperty(CachedWebResponse.prototype, property, {
+      get() {
+        return this[getNative]()[property];
+      }
+    });
+  }
+  for (const method of [
+    "arrayBuffer",
+    "blob",
+    "bytes",
+    "clone",
+    "formData",
+    "json",
+    "text"
+  ]) {
+    if (typeof NativeResponse.prototype[method] !== "function") {
+      continue;
+    }
+    Object.defineProperty(CachedWebResponse.prototype, method, {
+      value() {
+        const native = this[getNative]();
+        return native[method].call(native);
+      }
+    });
+  }
+  Object.defineProperty(CachedWebResponse, "json", {
+    value(data, init) {
+      const body = JSON.stringify(data);
+      if (body === void 0) {
+        throw new TypeError("The data is not JSON serializable");
+      }
+      const headers = new Headers(init?.headers);
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+      return new CachedWebResponse(body, { ...init, headers });
+    },
+    configurable: true,
+    writable: true
+  });
+  Object.defineProperty(CachedWebResponse, Symbol.hasInstance, {
+    value(value) {
+      if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+        return false;
+      }
+      return Object.prototype.isPrototypeOf.call(NativeResponse.prototype, value) || Object.prototype.isPrototypeOf.call(CachedWebResponse.prototype, value);
+    }
+  });
+  Object.setPrototypeOf(CachedWebResponse, NativeResponse);
+  Object.setPrototypeOf(CachedWebResponse.prototype, NativeResponse.prototype);
+  Object.defineProperty(CachedWebResponse, "name", { value: "Response" });
+  globalThis.Response = CachedWebResponse;
+}
+
 // src/adapter.ts
+var REQUEST_SOURCE_HANDLER = Symbol.for(
+  "@web-widget/web-router.request-source-handler"
+);
+var NODE_EXECUTION_CONTEXT = {
+  waitUntil(promise) {
+    void Promise.resolve(promise).catch((error) => {
+      console.error("Background task failed.", error);
+    });
+  },
+  passThroughOnException() {
+  }
+};
 var dependencies = {
   Headers,
   ReadableStream,
-  Request: class extends Request {
-    constructor(input, init) {
-      super(input, addDuplexToInit(init));
-    }
-  },
+  Request,
   Uint8Array,
   FetchEvent: primitives2.FetchEvent
 };
-var _handler, _middleware;
 var NodeAdapter = class {
+  #handler;
+  #middleware;
   constructor(webRouter, options) {
-    __privateAdd(this, _handler);
-    __privateAdd(this, _middleware);
+    installCachedResponse();
+    const requestSourceHandler = Reflect.get(
+      webRouter,
+      REQUEST_SOURCE_HANDLER
+    );
+    if (typeof requestSourceHandler === "function") {
+      const handler2 = requestSourceHandler.bind(webRouter);
+      this.#handler = buildToNodeSourceHandler(dependencies, options)(handler2);
+      this.#middleware = toRequestSourceMiddleware(handler2, options);
+      return;
+    }
     const handler = webRouter.handler.bind(webRouter);
-    __privateSet(this, _handler, buildToNodeHandler(dependencies, options)(handler));
-    __privateSet(this, _middleware, toMiddleware(handler, options));
+    this.#handler = buildToNodeHandler(dependencies, options)(handler);
+    this.#middleware = toMiddleware(handler, options);
   }
   get middleware() {
-    return __privateGet(this, _middleware);
+    return this.#middleware;
   }
   get handler() {
-    return __privateGet(this, _handler);
+    return this.#handler;
   }
 };
-_handler = new WeakMap();
-_middleware = new WeakMap();
-function addDuplexToInit(init) {
-  if (typeof init === "undefined" || typeof init === "object") {
-    return { duplex: "half", ...init };
-  }
-  return init;
-}
 function isHttp2ServerResponse(serverResponse) {
   if ("stream" in serverResponse && serverResponse.stream) return true;
   const httpVersionMajor = serverResponse.httpVersionMajor;
@@ -170,8 +490,9 @@ function toMiddleware(webHandler, options) {
   const toRequest = buildToRequestWithHttp2Compat(dependencies);
   const toFetchEvent = buildToFetchEvent(dependencies);
   return async function middleware(incomingMessage, serverResponse, next) {
-    const request = toRequest(incomingMessage, options);
+    let request;
     try {
+      request = toRequest(incomingMessage, options);
       const env = process.env;
       const event = toFetchEvent(request);
       const webResponse = await webHandler(request, env, event);
@@ -189,11 +510,40 @@ function toMiddleware(webHandler, options) {
         next(error);
       }
     } finally {
-      cancelRequestBody(request);
+      if (request) cancelRequestBody(request);
+    }
+  };
+}
+function toRequestSourceMiddleware(webHandler, options) {
+  const toRequestSource = buildToRequestSource(dependencies, options);
+  return async function middleware(incomingMessage, serverResponse, next) {
+    let source;
+    try {
+      source = toRequestSource(incomingMessage);
+      const webResponse = await webHandler(
+        source,
+        process.env,
+        NODE_EXECUTION_CONTEXT
+      );
+      await toServerResponse(webResponse, serverResponse);
+      if (!serverResponse.headersSent && !serverResponse.writableEnded) {
+        await next();
+      }
+    } catch (error) {
+      if (sendServerError(
+        serverResponse,
+        error instanceof Error ? error.message : void 0
+      )) {
+        next();
+      } else {
+        next(error);
+      }
+    } finally {
+      source?.cancel();
     }
   };
 }
-async function toServerResponse(webResponse, serverResponse) {
+function toServerResponse(webResponse, serverResponse) {
   if (!checkWritable(serverResponse)) {
     return;
   }
@@ -201,15 +551,23 @@ async function toServerResponse(webResponse, serverResponse) {
     serverResponse.end();
     return;
   }
+  const cached = getCachedResponse(webResponse);
+  if (cached) {
+    return writeCachedResponse(cached, serverResponse);
+  }
   const isHttp2 = isHttp2ServerResponse(serverResponse);
-  const headers = toOutgoingHeaders(webResponse.headers);
+  const headers = {};
+  const responseHeaders = webResponse.headers;
+  const setCookies = responseHeaders.getSetCookie?.();
+  for (const [name, value] of responseHeaders) {
+    headers[name] = name === "set-cookie" && setCookies?.length ? setCookies : value;
+  }
   const status = webResponse.status;
   if (!serverResponse.headersSent) {
-    mergeIntoServerResponse(headers, serverResponse);
-    serverResponse.statusCode = status;
     if (!isHttp2) {
       setHttp1StatusMessage(serverResponse, webResponse.statusText);
     }
+    serverResponse.writeHead(status, headers);
   } else if (!isHttp2) {
     serverResponse.statusCode = status;
     setHttp1StatusMessage(serverResponse, webResponse.statusText);
@@ -218,53 +576,140 @@ async function toServerResponse(webResponse, serverResponse) {
     serverResponse.end();
     return;
   }
-  await writeReadableStreamToWritable(webResponse.body, serverResponse);
+  return writeReadableStreamToWritable(webResponse.body, serverResponse);
 }
-async function writeReadableStreamToWritable(stream, writable) {
+function writeCachedResponse(response, serverResponse) {
+  const { body } = response;
+  const cachedHeaders = response.headers;
+  if (!cachedHeaders || !Array.isArray(cachedHeaders) && !(cachedHeaders instanceof Headers)) {
+    const outgoingHeaders2 = {
+      ...cachedHeaders
+    };
+    if (response.headerName) {
+      outgoingHeaders2[response.headerName] = response.headerValue;
+    }
+    if (typeof body === "string" && !outgoingHeaders2["content-type"]) {
+      outgoingHeaders2["content-type"] = "text/plain;charset=UTF-8";
+    } else if (body instanceof Blob && body.type && !outgoingHeaders2["content-type"]) {
+      outgoingHeaders2["content-type"] = body.type;
+    }
+    if (!outgoingHeaders2["content-length"]) {
+      if (typeof body === "string") {
+        outgoingHeaders2["content-length"] = String(Buffer.byteLength(body));
+      } else if (body instanceof Uint8Array) {
+        outgoingHeaders2["content-length"] = String(body.byteLength);
+      } else if (body instanceof Blob) {
+        outgoingHeaders2["content-length"] = String(body.size);
+      }
+    }
+    return writeCachedBody(response, body, outgoingHeaders2, serverResponse);
+  }
+  const headers = new Headers(cachedHeaders);
+  if (typeof body === "string" && !headers.has("content-type")) {
+    headers.set("content-type", "text/plain;charset=UTF-8");
+  } else if (body instanceof Blob && body.type && !headers.has("content-type")) {
+    headers.set("content-type", body.type);
+  }
+  if (!headers.has("content-length")) {
+    if (typeof body === "string") {
+      headers.set("content-length", String(Buffer.byteLength(body)));
+    } else if (body instanceof Uint8Array) {
+      headers.set("content-length", String(body.byteLength));
+    } else if (body instanceof Blob) {
+      headers.set("content-length", String(body.size));
+    }
+  }
+  const outgoingHeaders = {};
+  const setCookies = headers.getSetCookie?.();
+  for (const [name, value] of headers) {
+    outgoingHeaders[name] = name === "set-cookie" && setCookies?.length ? setCookies : value;
+  }
+  return writeCachedBody(response, body, outgoingHeaders, serverResponse);
+}
+function writeCachedBody(response, body, outgoingHeaders, serverResponse) {
+  if (!serverResponse.headersSent) {
+    if (!isHttp2ServerResponse(serverResponse) && response.statusText) {
+      setHttp1StatusMessage(serverResponse, response.statusText);
+    }
+    serverResponse.writeHead(response.status, outgoingHeaders);
+  }
+  if (body === null) {
+    serverResponse.end();
+  } else if (typeof body === "string" || body instanceof Uint8Array) {
+    serverResponse.end(body);
+  } else if (body instanceof Blob) {
+    return body.arrayBuffer().then((buffer) => {
+      serverResponse.end(new Uint8Array(buffer));
+    });
+  } else {
+    return writeReadableStreamToWritable(body, serverResponse);
+  }
+}
+function writeReadableStreamToWritable(stream, writable) {
   if (stream.locked) {
     throw new TypeError("ReadableStream is locked.");
   }
   const reader = stream.getReader();
   const flushable = writable;
-  const onAbort = () => {
-    reader.cancel().catch(() => {
-    });
-  };
-  writable.once("close", onAbort);
-  writable.once("error", onAbort);
-  try {
-    while (!writable.destroyed) {
-      const { done, value } = await reader.read();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      writable.removeListener("close", onAbort);
+      writable.removeListener("error", onAbort);
+      writable.removeListener("drain", read);
+      try {
+        reader.releaseLock();
+      } catch {
+      }
+    };
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (error !== void 0) reject(error);
+      else resolve();
+    };
+    const onAbort = () => {
+      reader.cancel().then(
+        () => finish(),
+        () => finish()
+      );
+    };
+    const handleError = (error) => {
+      try {
+        if (!writable.destroyed) {
+          writable.destroy();
+        }
+      } catch {
+      }
+      finish(error);
+    };
+    function read() {
+      if (writable.destroyed) {
+        onAbort();
+        return;
+      }
+      reader.read().then(flow).catch(handleError);
+    }
+    const flow = ({ done, value }) => {
       if (done) {
         if (!writable.destroyed) writable.end();
-        break;
+        finish();
+        return;
       }
       if (writable.write(value) === false) {
-        await new Promise((resolve) => {
-          if (writable.destroyed) {
-            resolve();
-          } else {
-            writable.once("drain", resolve);
-          }
-        });
+        writable.once("drain", read);
+      } else {
+        read();
       }
       if (typeof flushable.flush === "function") {
         flushable.flush();
       }
-    }
-  } catch (error) {
-    if (!writable.destroyed) {
-      writable.destroy(error instanceof Error ? error : void 0);
-      throw error;
-    }
-  } finally {
-    writable.removeListener("close", onAbort);
-    writable.removeListener("error", onAbort);
-    try {
-      reader.releaseLock();
-    } catch {
-    }
-  }
+    };
+    writable.once("close", onAbort);
+    writable.once("error", onAbort);
+    read();
+  });
 }
 function checkWritable(serverResponse) {
   if (serverResponse.writableEnded || serverResponse.finished) return false;
@@ -303,18 +748,119 @@ function buildToNodeHandler(dependencies2, options) {
       const env = process.env;
       const event = toFetchEvent(request);
       const maybePromise = webHandler(request, env, event);
-      const respond = (response) => toServerResponse(response, serverResponse).finally(
-        () => cancelRequestBody(request)
+      if (maybePromise instanceof Promise) {
+        maybePromise.then(
+          (response) => {
+            try {
+              const writing = toServerResponse(response, serverResponse);
+              if (writing instanceof Promise) {
+                writing.then(
+                  () => cancelRequestBody(request),
+                  () => {
+                    cancelRequestBody(request);
+                    sendServerError(serverResponse);
+                  }
+                );
+              } else {
+                cancelRequestBody(request);
+              }
+            } catch {
+              cancelRequestBody(request);
+              sendServerError(serverResponse);
+            }
+          },
+          () => {
+            cancelRequestBody(request);
+            sendServerError(serverResponse);
+          }
+        );
+        return;
+      }
+      try {
+        const writing = toServerResponse(maybePromise, serverResponse);
+        if (writing instanceof Promise) {
+          writing.then(
+            () => cancelRequestBody(request),
+            () => {
+              cancelRequestBody(request);
+              sendServerError(serverResponse);
+            }
+          );
+        } else {
+          cancelRequestBody(request);
+        }
+      } catch {
+        cancelRequestBody(request);
+        sendServerError(serverResponse);
+      }
+    };
+  };
+}
+function buildToNodeSourceHandler(dependencies2, options) {
+  const toRequestSource = buildToRequestSource(dependencies2, options);
+  return function toNodeHandler(webHandler) {
+    return (incomingMessage, serverResponse) => {
+      const source = toRequestSource(incomingMessage);
+      const needsSourceCleanup = source.method !== "GET" && source.method !== "HEAD";
+      const maybePromise = webHandler(
+        source,
+        process.env,
+        NODE_EXECUTION_CONTEXT
       );
-      const fail = () => sendServerError(serverResponse);
       if (maybePromise instanceof Promise) {
-        maybePromise.then(respond).catch(fail);
-      } else {
-        respond(maybePromise).catch(fail);
+        maybePromise.then(
+          (response) => {
+            try {
+              const writing = toServerResponse(response, serverResponse);
+              if (writing instanceof Promise) {
+                writing.then(
+                  () => {
+                    if (needsSourceCleanup) source.cancel();
+                  },
+                  () => {
+                    if (needsSourceCleanup) source.cancel();
+                    sendServerError(serverResponse);
+                  }
+                );
+              } else if (needsSourceCleanup) {
+                source.cancel();
+              }
+            } catch {
+              if (needsSourceCleanup) source.cancel();
+              sendServerError(serverResponse);
+            }
+          },
+          () => {
+            if (needsSourceCleanup) source.cancel();
+            sendServerError(serverResponse);
+          }
+        );
+        return;
+      }
+      try {
+        const writing = toServerResponse(maybePromise, serverResponse);
+        if (writing instanceof Promise) {
+          writing.then(
+            () => {
+              if (needsSourceCleanup) source.cancel();
+            },
+            () => {
+              if (needsSourceCleanup) source.cancel();
+              sendServerError(serverResponse);
+            }
+          );
+        } else if (needsSourceCleanup) {
+          source.cancel();
+        }
+      } catch {
+        if (needsSourceCleanup) source.cancel();
+        sendServerError(serverResponse);
       }
     };
   };
 }
 export {
-  NodeAdapter as default
+  buildToNodeHandler,
+  NodeAdapter as default,
+  toServerResponse
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@web-widget/node",
   "description": "Node.js adapter",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.5",
   "homepage": "https://github.com/web-widget/web-widget#readme",
   "repository": {
     "type": "git",
@@ -13,13 +13,13 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@edge-runtime/node-utils": "^4.0.0",
     "@edge-runtime/primitives": "^6.0.0"
   },
   "devDependencies": {
-    "@types/node": "^22.2.0",
-    "tsup": "^8.3.4",
-    "typescript": "^5.9.3"
+    "@types/node": "catalog:",
+    "tsup": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
   },
   "engines": {
     "node": ">=18"
@@ -27,6 +27,7 @@
   "exports": {
     ".": {
       "types": "./dist/node.d.ts",
+      "development": "./src/index.ts",
       "default": "./dist/node.js"
     }
   },
@@ -34,15 +35,23 @@
     "dist/"
   ],
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/node.d.ts",
+        "default": "./dist/node.js"
+      }
+    }
   },
-  "type": "module",
   "scripts": {
     "build": "pnpm exec tsup",
     "clean:build": "rm -rf dist",
     "clean:node": "rm -rf node_modules",
     "dev": "pnpm exec tsup --watch",
     "lint": "eslint src",
-    "prebuild": "pnpm run clean:build"
-  }
-}
+    "prebuild": "pnpm run clean:build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "type": "module"
+}