refactor: hide internal event._res and event.res._headers

src/event.ts

@@ -9,6 +9,16 @@ import type {
 } from "./types/handler.ts";
 import type { H3Core } from "./h3.ts";
 
+const kEventNS = "h3.internal.event.";
+
+export const kEventRes: unique symbol = /* @__PURE__ */ Symbol.for(
+  `${kEventNS}res`,
+);
+
+export const kEventResHeaders: unique symbol = /* @__PURE__ */ Symbol.for(
+  `${kEventNS}res.headers`,
+);
+
 export interface HTTPEvent<
   _RequestT extends EventHandlerRequest = EventHandlerRequest,
 > {
@@ -53,11 +63,6 @@ export class H3Event<
    */
   static __is_event__ = true;
 
-  /**
-   * @internal
-   */
-  _res?: H3EventResponse;
-
   constructor(req: ServerRequest, context?: H3EventContext, app?: H3Core) {
     this.context = context || req.context || new EmptyObject();
     this.req = req;
@@ -71,10 +76,7 @@ export class H3Event<
    * Prepared HTTP response.
    */
   get res(): H3EventResponse {
-    if (!this._res) {
-      this._res = new H3EventResponse();
-    }
-    return this._res;
+    return ((this as any)[kEventRes] ||= new H3EventResponse());
   }
 
   /**
@@ -145,11 +147,8 @@ export class H3Event<
 class H3EventResponse {
   status?: number;
   statusText?: string;
-  _headers?: Headers;
+
   get headers(): Headers {
-    if (!this._headers) {
-      this._headers = new Headers();
-    }
-    return this._headers;
+    return ((this as any)[kEventResHeaders] ||= new Headers());
   }
 }

src/response.ts

@@ -3,7 +3,7 @@ import { HTTPError } from "./error.ts";
 import { isJSONSerializable } from "./utils/internal/object.ts";
 
 import type { H3Config } from "./types/h3.ts";
-import type { H3Event } from "./event.ts";
+import { kEventRes, kEventResHeaders, type H3Event } from "./event.ts";
 
 export const kNotFound: symbol = /* @__PURE__ */ Symbol.for("h3.notFound");
 export const kHandled: symbol = /* @__PURE__ */ Symbol.for("h3.handled");
@@ -74,34 +74,39 @@ function prepareResponse(
   }
 
   // Only set if event.res.headers is accessed
-  const eventHeaders = (event.res as { _headers?: Headers })._headers;
+  const preparedRes:
+    | undefined
+    | { status?: number; statusText?: string; [kEventResHeaders]?: Headers } = (
+    event as any
+  )[kEventRes];
+  const preparedHeaders = preparedRes?.[kEventResHeaders];
 
   if (!(val instanceof Response)) {
     const res = prepareResponseBody(val, event, config);
-    const status = event.res.status;
+    const status = preparedRes?.status;
     return new FastResponse(
       nullBody(event.req.method, status) ? null : res.body,
       {
         status,
-        statusText: event.res.statusText,
+        statusText: preparedRes?.statusText,
         headers:
-          res.headers && eventHeaders
-            ? mergeHeaders(res.headers, eventHeaders)
-            : res.headers || eventHeaders,
+          res.headers && preparedHeaders
+            ? mergeHeaders(res.headers, preparedHeaders)
+            : res.headers || preparedHeaders,
       },
     );
   }
 
   // Note: Only check _headers. res.status/statusText are not used as we use them from the response
-  if (!eventHeaders) {
+  if (!preparedHeaders) {
     return val; // Fast path: no headers to merge
   }
   return new FastResponse(
     nullBody(event.req.method, val.status) ? null : val.body,
     {
       status: val.status,
       statusText: val.statusText,
-      headers: mergeHeaders(eventHeaders, val.headers),
+      headers: mergeHeaders(preparedHeaders, val.headers),
     },
   ) as Response;
 }

test/bench/bundle.test.ts

@@ -21,7 +21,7 @@ describe("benchmark", () => {
       );
     }
     expect(bundle.bytes).toBeLessThanOrEqual(11_000); // <11kb
-    expect(bundle.gzipSize).toBeLessThanOrEqual(4000); // <4kb
+    expect(bundle.gzipSize).toBeLessThanOrEqual(4100); // <4.1kb
   });
 
   it("bundle size (H3Core)", async () => {