Derive the multipart content-type on routed requests

The probe Request built for cache sniffing derives a multipart content-type
that carries its own boundary. Copying that header onto the routed request
while re-encoding the body produced a boundary mismatch, so the browser VM
rejected direct fs.upload calls with "failed to read form part". Let the
routed fetch derive the header when the body derives its own content-type.

Author: tnsardesai

src/lib/browser-routing.ts

@@ -311,6 +311,12 @@ function buildRoutedInit(
     const body = requestBodyForFetch(request, originalInit);
     if (body !== undefined) {
       routedInit.body = body;
+      if (derivesOwnContentType(body) && !new Headers(originalInit?.headers).get('content-type')) {
+        // `request` was constructed from the same body, so its content-type carries
+        // that construction's multipart boundary. The routed fetch re-encodes the
+        // body with a new boundary, so let it derive the header again.
+        headers.delete('content-type');
+      }
     }
     if (originalInit?.duplex !== undefined) {
       routedInit.duplex = originalInit.duplex;
@@ -333,6 +339,14 @@ function requestBodyForFetch(
   return request.body ?? undefined;
 }
 
+function derivesOwnContentType(body: RequestInit['body'] | undefined): boolean {
+  return (
+    ((globalThis as any).FormData && body instanceof (globalThis as any).FormData) ||
+    ((globalThis as any).URLSearchParams && body instanceof (globalThis as any).URLSearchParams) ||
+    ((globalThis as any).Blob && body instanceof (globalThis as any).Blob)
+  );
+}
+
 function requiresHalfDuplex(body: RequestInit['body'] | undefined): boolean {
   return (
     ((globalThis as any).ReadableStream && body instanceof (globalThis as any).ReadableStream) ||

tests/lib/browser-routing.test.ts

@@ -1016,4 +1016,46 @@ describe('browser routing', () => {
       expect(calls[0]?.headers.get('authorization')).toBe('Bearer k');
     });
   });
+
+  test('lets the routed fetch derive the multipart content-type so the boundary matches the body', async () => {
+    await withBrowserRoutingEnv(undefined, async () => {
+      const parsed: Array<{ url: string; dest: unknown; file: string }> = [];
+      const kernel = new Kernel({
+        apiKey: 'k',
+        baseURL: 'https://api.example/',
+        fetch: async (input, init?: RequestInit) => {
+          const request = new Request(input as any, init);
+          if (request.url === formDataProbeURL) {
+            return new Response(null, { status: 204 });
+          }
+          // Throws or yields empty fields when the content-type boundary does not
+          // match the encoded body.
+          const form = await request.formData();
+          parsed.push({
+            url: request.url,
+            dest: form.get('files[0][dest_path]'),
+            file: await (form.get('files[0][file]') as File).text(),
+          });
+          return new Response(null, { status: 204 });
+        },
+      });
+      kernel.browserRouteCache.set({
+        sessionId: 'sess-1',
+        baseURL: 'http://browser-session.test/browser/kernel',
+        jwt: 'token-abc',
+      });
+
+      await kernel.browsers.fs.upload('sess-1', {
+        files: [{ dest_path: '/tmp/one', file: await toFile(Buffer.from('one'), 'one.txt') }],
+      });
+
+      expect(parsed).toEqual([
+        {
+          url: 'http://browser-session.test/browser/kernel/fs/upload?jwt=token-abc',
+          dest: '/tmp/one',
+          file: 'one',
+        },
+      ]);
+    });
+  });
 });