fix(ts-bindings): populate response headers in fetch() (#4691)

# Description of Changes

`fetch()` in TypeScript bindings was deserializing the full
`HttpResponse` from BSATN (including headers), but then discarding them
and always returning `new Headers()`. This adds a `deserializeHeaders()`
helper that converts BSATN-deserialized `HttpHeaders` into a
web-standard `Headers` object, so response headers are now correctly
populated on the returned `SyncResponse`.

# API and ABI breaking changes

None. Purely additive — no existing code depended on the (always-empty)
headers.

# Expected complexity level and risk

1 — Single-line behavioral change plus a small helper function. The fix
mirrors the existing request-side encoding pattern.

# Testing

- [x] Unit test: headers survive BSATN serialize/deserialize round-trip
- [x] Unit test: empty headers round-trip correctly
- [x] Verified `deserializeHeaders` uses the same `textDecoder` (UTF-8)
as existing body decoding

Author: philtrem

crates/bindings-typescript/src/server/http_internal.ts

@@ -27,6 +27,15 @@ export interface ResponseInit {
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder('utf-8' /* { fatal: true } */);
 
+function deserializeHeaders(headers: HttpHeaders): Headers {
+  return new Headers(
+    headers.entries.map(({ name, value }): [string, string] => [
+      name,
+      textDecoder.decode(value),
+    ])
+  );
+}
+
 const makeResponse = Symbol('makeResponse');
 
 // based on deno's type of the same name
@@ -187,7 +196,7 @@ function fetch(url: URL | string, init: RequestOptions = {}) {
     url: uri,
     status: response.code,
     statusText: status(response.code),
-    headers: new Headers(),
+    headers: deserializeHeaders(response.headers),
     aborted: false,
   });
 }

crates/bindings-typescript/tests/http_headers.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from 'vitest';
+import { BinaryReader, BinaryWriter } from '../src';
+import { HttpResponse } from '../src/lib/http_types';
+
+describe('HttpResponse header round-trip', () => {
+  test('headers survive BSATN serialize/deserialize', () => {
+    const textEncoder = new TextEncoder();
+    const textDecoder = new TextDecoder('utf-8');
+
+    const original: HttpResponse = {
+      headers: {
+        entries: [
+          {
+            name: 'content-type',
+            value: textEncoder.encode('text/event-stream'),
+          },
+          { name: 'x-request-id', value: textEncoder.encode('abc-123') },
+        ],
+      },
+      version: { tag: 'Http11' },
+      code: 200,
+    };
+
+    const writer = new BinaryWriter(256);
+    HttpResponse.serialize(writer, original);
+    const buf = writer.getBuffer();
+
+    const deserialized = HttpResponse.deserialize(new BinaryReader(buf));
+
+    expect(deserialized.code).toBe(200);
+    expect(deserialized.headers.entries).toHaveLength(2);
+
+    expect(deserialized.headers.entries[0].name).toBe('content-type');
+    expect(textDecoder.decode(deserialized.headers.entries[0].value)).toBe(
+      'text/event-stream'
+    );
+
+    expect(deserialized.headers.entries[1].name).toBe('x-request-id');
+    expect(textDecoder.decode(deserialized.headers.entries[1].value)).toBe(
+      'abc-123'
+    );
+  });
+
+  test('empty headers round-trip correctly', () => {
+    const original: HttpResponse = {
+      headers: { entries: [] },
+      version: { tag: 'Http11' },
+      code: 404,
+    };
+
+    const writer = new BinaryWriter(64);
+    HttpResponse.serialize(writer, original);
+    const deserialized = HttpResponse.deserialize(
+      new BinaryReader(writer.getBuffer())
+    );
+
+    expect(deserialized.code).toBe(404);
+    expect(deserialized.headers.entries).toHaveLength(0);
+  });
+});