goscript 0.2.6 → 0.2.7

package/gs/net/http/index.test.ts

@@ -7,6 +7,7 @@ import * as context from '../../context/index.js'
 import * as io from '../../io/index.js'
 import * as strings from '../../strings/index.js'
 import {
+  AllowQuerySemicolons,
   CanonicalHeaderKey,
   Client,
   Cookie,
@@ -25,6 +26,8 @@ import {
   FS,
   Get,
   Handle,
+  HandleFunc,
+  Head,
   Header,
   Header_Add,
   Header_Clone,
@@ -35,10 +38,12 @@ import {
   Header_Write,
   HandlerFunc_ServeHTTP,
   ListenAndServe,
+  ListenAndServeTLS,
   MaxBytesError,
   MaxBytesHandler,
   MaxBytesReader,
   NewFileTransport,
+  NewFileTransportFS,
   MethodGet,
   MethodHead,
   MethodOptions,
@@ -50,6 +55,7 @@ import {
   NewRequest,
   NewRequestWithContext,
   NewResponseController,
+  NewServeMux,
   NoBody,
   NotFound,
   NotFoundHandler,
@@ -58,8 +64,15 @@ import {
   ParseSetCookie,
   ParseTime,
   PostForm,
+  Post,
   Protocols,
+  ProxyFromEnvironment,
+  ProxyURL,
   RegisterInProcessServer,
+  ReadRequest,
+  ReadResponse,
+  Redirect,
+  RedirectHandler,
   SameSiteStrictMode,
   SetCookie,
   StatusBadGateway,
@@ -68,12 +81,18 @@ import {
   ResponseWriter,
   ServeContent,
   ServeFile,
+  ServeFileFS,
+  Serve,
   Server,
+  ServeTLS,
   StatusCreated,
   StatusForbidden,
+  StatusFound,
   StatusMethodNotAllowed,
   StatusNotFound,
   StatusOK,
+  StatusPartialContent,
+  StatusRequestedRangeNotSatisfiable,
   StatusServiceUnavailable,
   StatusTeapot,
   StatusText,
@@ -82,7 +101,9 @@ import {
   StatusUnsupportedMediaType,
   StatusNetworkAuthenticationRequired,
   TimeFormat,
+  TimeoutHandler,
   TrailerPrefix,
+  StripPrefix,
   Transport,
   UnregisterInProcessServer,
 } from './index.js'
@@ -157,6 +178,181 @@ describe('net/http override', () => {
     expect(ErrServerClosed.Error()).toBe('http: Server closed')
   })
 
+  it('parses HTTP/1 request and response wire format like Go', async () => {
+    const requestCases = [
+      {
+        wire:
+          'GET /alpha?x=1 HTTP/1.1\r\n' +
+          'Host: example.com\r\n' +
+          'User-Agent: probe\r\n' +
+          'X-Test: one\r\n' +
+          'X-Test: two\r\n' +
+          'Content-Length: 0\r\n' +
+          '\r\n',
+        want: {
+          method: 'GET',
+          requestURI: '/alpha?x=1',
+          path: '/alpha',
+          rawQuery: 'x=1',
+          protoMajor: 1,
+          protoMinor: 1,
+          host: 'example.com',
+          userAgent: 'probe',
+          xTestValues: 2,
+          contentLength: 0,
+          close: false,
+          transferEncoding: [],
+          body: '',
+        },
+      },
+      {
+        wire:
+          'POST /submit HTTP/1.0\r\n' +
+          'Host: example.com\r\n' +
+          'Content-Length: 4\r\n' +
+          'Connection: close\r\n' +
+          '\r\n' +
+          'body',
+        want: {
+          method: 'POST',
+          requestURI: '/submit',
+          path: '/submit',
+          rawQuery: '',
+          protoMajor: 1,
+          protoMinor: 0,
+          host: 'example.com',
+          userAgent: '',
+          xTestValues: 0,
+          contentLength: 4,
+          close: true,
+          transferEncoding: [],
+          body: 'body',
+        },
+      },
+      {
+        wire:
+          'POST /chunk HTTP/1.1\r\n' +
+          'Host: example.com\r\n' +
+          'Transfer-Encoding: chunked\r\n' +
+          '\r\n' +
+          '5\r\nhello\r\n0\r\n\r\n',
+        want: {
+          method: 'POST',
+          requestURI: '/chunk',
+          path: '/chunk',
+          rawQuery: '',
+          protoMajor: 1,
+          protoMinor: 1,
+          host: 'example.com',
+          userAgent: '',
+          xTestValues: 0,
+          contentLength: -1,
+          close: false,
+          transferEncoding: ['chunked'],
+          body: 'hello',
+        },
+      },
+    ]
+
+    for (const { wire, want } of requestCases) {
+      const [req, err] = await ReadRequest(strings.NewReader(wire))
+      const [body, bodyErr] = await io.ReadAll(req!.Body!)
+
+      expect(err).toBeNull()
+      expect(req!.Method).toBe(want.method)
+      expect(req!.RequestURI).toBe(want.requestURI)
+      expect(req!.URL.Path).toBe(want.path)
+      expect(req!.URL.RawQuery).toBe(want.rawQuery)
+      expect(req!.ProtoMajor).toBe(want.protoMajor)
+      expect(req!.ProtoMinor).toBe(want.protoMinor)
+      expect(req!.Host).toBe(want.host)
+      expect(req!.UserAgent()).toBe(want.userAgent)
+      expect(
+        Array.from(Header_Values(req!.Header, 'X-Test') ?? []),
+      ).toHaveLength(want.xTestValues)
+      expect(req!.ContentLength).toBe(want.contentLength)
+      expect(req!.Close).toBe(want.close)
+      expect(Array.from(req!.TransferEncoding ?? [])).toEqual(
+        want.transferEncoding,
+      )
+      expect($.bytesToString(body)).toBe(want.body)
+      expect(bodyErr).toBeNull()
+    }
+
+    const responseCases = [
+      {
+        wire:
+          'HTTP/1.1 201 Created\r\n' +
+          'Content-Type: text/plain\r\n' +
+          'Content-Length: 5\r\n' +
+          '\r\n' +
+          'hello',
+        want: {
+          status: '201 Created',
+          statusCode: 201,
+          protoMajor: 1,
+          protoMinor: 1,
+          contentType: 'text/plain',
+          contentLength: 5,
+          close: false,
+          transferEncoding: [],
+          body: 'hello',
+        },
+      },
+      {
+        wire: 'HTTP/1.0 204 No Content\r\nConnection: close\r\n\r\n',
+        want: {
+          status: '204 No Content',
+          statusCode: 204,
+          protoMajor: 1,
+          protoMinor: 0,
+          contentType: '',
+          contentLength: 0,
+          close: true,
+          transferEncoding: [],
+          body: '',
+        },
+      },
+      {
+        wire:
+          'HTTP/1.1 200 OK\r\n' +
+          'Transfer-Encoding: chunked\r\n' +
+          '\r\n' +
+          '5\r\nhello\r\n0\r\n\r\n',
+        want: {
+          status: '200 OK',
+          statusCode: 200,
+          protoMajor: 1,
+          protoMinor: 1,
+          contentType: '',
+          contentLength: -1,
+          close: false,
+          transferEncoding: ['chunked'],
+          body: 'hello',
+        },
+      },
+    ]
+
+    for (const { wire, want } of responseCases) {
+      const [resp, err] = await ReadResponse(strings.NewReader(wire), null)
+      const [body, bodyErr] = await io.ReadAll(resp!.Body!)
+
+      expect(err).toBeNull()
+      expect(resp!.Status).toBe(want.status)
+      expect(resp!.StatusCode).toBe(want.statusCode)
+      expect(resp!.ProtoMajor).toBe(want.protoMajor)
+      expect(resp!.ProtoMinor).toBe(want.protoMinor)
+      expect(Header_Get(resp!.Header, 'Content-Type')).toBe(want.contentType)
+      expect(resp!.ContentLength).toBe(want.contentLength)
+      expect(resp!.Close).toBe(want.close)
+      expect(Array.from(resp!.TransferEncoding ?? [])).toEqual(
+        want.transferEncoding,
+      )
+      expect($.bytesToString(body)).toBe(want.body)
+      expect(bodyErr).toBeNull()
+    }
+  })
+
   it('exports common header and protocol utility surfaces', () => {
     const header = new Header()
     Header_Add(header, 'content-type', 'text/plain')
@@ -293,6 +489,19 @@ describe('net/http override', () => {
     expect(noBodyReq?.Body).toBe(NoBody)
   })
 
+  it('decodes escaped request paths like native net/http', () => {
+    const [req, reqErr] = NewRequestWithContext(
+      context.Background(),
+      MethodGet,
+      'https://example.invalid/files/what%20is%20this.mp4?inline=1',
+      null,
+    )
+
+    expect(reqErr).toBeNull()
+    expect(req?.URL?.Path).toBe('/files/what is this.mp4')
+    expect(req?.URL?.RawQuery).toBe('inline=1')
+  })
+
   it('applies cross-origin protection checks', () => {
     const protection = NewCrossOriginProtection()
     const [sameOrigin] = NewRequest(
@@ -516,6 +725,11 @@ describe('net/http override', () => {
     expect(controller.Hijack()[2]).toBe(ErrNotSupported)
     expect(controller.SetReadDeadline({} as any)).toBe(ErrNotSupported)
     expect(ListenAndServe(':0', null)).toBe(ErrNotSupported)
+    expect(ListenAndServeTLS(':0', 'cert.pem', 'key.pem', null)).toBe(
+      ErrNotSupported,
+    )
+    expect(Serve(null, null)).toBe(ErrNotSupported)
+    expect(ServeTLS(null, null, 'cert.pem', 'key.pem')).toBe(ErrNotSupported)
     expect(new Transport().Clone()).toBeInstanceOf(Transport)
   })
 
@@ -970,6 +1184,42 @@ describe('net/http override', () => {
     expect(resp?.StatusCode).toBe(StatusOK)
   })
 
+  it('routes package Head and Post helpers through DefaultClient', async () => {
+    const oldTransport = DefaultClient.Transport
+    const seen: string[] = []
+    DefaultClient.Transport = {
+      async RoundTrip(
+        got: Request | $.VarRef<Request> | null,
+      ): Promise<[Response | null, $.GoError]> {
+        const request = $.pointerValue<Request>(got)
+        seen.push(request.Method)
+        if (request.Method === MethodPost) {
+          expect(Header_Get(request.Header, 'Content-Type')).toBe('text/plain')
+          const [data, err] = await io.ReadAll(request.Body!)
+          expect(err).toBeNull()
+          expect($.bytesToString(data)).toBe('payload')
+        }
+        return [new Response({ StatusCode: StatusOK }), null]
+      },
+    }
+    try {
+      const [headResp, headErr] = await Head('https://example.invalid/head')
+      const [postResp, postErr] = await Post(
+        'https://example.invalid/post',
+        'text/plain',
+        strings.NewReader('payload'),
+      )
+
+      expect(headErr).toBeNull()
+      expect(headResp?.StatusCode).toBe(StatusOK)
+      expect(postErr).toBeNull()
+      expect(postResp?.StatusCode).toBe(StatusOK)
+      expect(seen).toEqual([MethodHead, MethodPost])
+    } finally {
+      DefaultClient.Transport = oldTransport
+    }
+  })
+
   it('posts URL-encoded forms through clients and package helper', async () => {
     const transport = {
       async RoundTrip(
@@ -1202,6 +1452,148 @@ describe('net/http override', () => {
     ])
   })
 
+  it('covers remaining handler, proxy, redirect, timeout, and FS helpers', async () => {
+    const mux = NewServeMux()
+    const muxWriter = new testResponseWriter()
+    const [muxReq] = NewRequest(MethodGet, 'http://example.invalid/local', null)
+    mux.HandleFunc('/local', (w) => {
+      w?.WriteHeader(StatusOK)
+      w?.Write($.stringToBytes('local mux'))
+    })
+
+    mux.ServeHTTP(muxWriter, muxReq)
+
+    expect(muxWriter.Code).toBe(StatusOK)
+    expect(muxWriter.Body.String()).toBe('local mux')
+
+    const defaultWriter = new testResponseWriter()
+    const [defaultReq] = NewRequest(
+      MethodGet,
+      'http://example.invalid/phase10-handlefunc',
+      null,
+    )
+    HandleFunc('/phase10-handlefunc', (w) => {
+      w?.WriteHeader(StatusOK)
+      w?.Write($.stringToBytes('default handlefunc'))
+    })
+
+    DefaultServeMux.ServeHTTP(defaultWriter, defaultReq)
+
+    expect(defaultWriter.Code).toBe(StatusOK)
+    expect(defaultWriter.Body.String()).toBe('default handlefunc')
+
+    let strippedPath = ''
+    const [stripReq] = NewRequest(
+      MethodGet,
+      'http://example.invalid/static/app.js',
+      null,
+    )
+    const stripWriter = new testResponseWriter()
+
+    StripPrefix('/static', {
+      ServeHTTP(_w, r) {
+        strippedPath = $.pointerValue<Request>(r).URL.Path
+      },
+    }).ServeHTTP(stripWriter, stripReq)
+
+    expect(strippedPath).toBe('/app.js')
+    expect(stripReq!.URL.Path).toBe('/static/app.js')
+
+    let rewrittenQuery = ''
+    const [semicolonReq] = NewRequest(
+      MethodGet,
+      'http://example.invalid/search?a=1;b=2',
+      null,
+    )
+
+    AllowQuerySemicolons({
+      ServeHTTP(_w, r) {
+        rewrittenQuery = $.pointerValue<Request>(r).URL.RawQuery
+      },
+    }).ServeHTTP(null, semicolonReq)
+
+    expect(rewrittenQuery).toBe('a=1&b=2')
+    expect(semicolonReq!.URL.RawQuery).toBe('a=1;b=2')
+
+    const fixedProxy = { href: 'http://proxy.invalid' }
+    expect(ProxyURL(fixedProxy)(null)).toEqual([fixedProxy, null])
+    expect(ProxyFromEnvironment(null)).toEqual([null, null])
+
+    const redirectWriter = new testResponseWriter()
+    const [redirectReq] = NewRequest(
+      MethodGet,
+      'http://example.invalid/dir/page',
+      null,
+    )
+
+    await RedirectHandler('next?x=1', StatusFound).ServeHTTP(
+      redirectWriter,
+      redirectReq,
+    )
+
+    expect(redirectWriter.Code).toBe(StatusFound)
+    expect(Header_Get(redirectWriter.Header(), 'Location')).toBe(
+      '/dir/next?x=1',
+    )
+    expect(redirectWriter.Body.String()).toContain('Found')
+
+    const directRedirectWriter = new testResponseWriter()
+    await Redirect(directRedirectWriter, redirectReq, '/abs', StatusFound)
+
+    expect(Header_Get(directRedirectWriter.Header(), 'Location')).toBe('/abs')
+
+    const timeoutWriter = new testResponseWriter()
+    TimeoutHandler(null, 1, 'timed out').ServeHTTP(timeoutWriter, redirectReq)
+
+    expect(timeoutWriter.Code).toBe(StatusServiceUnavailable)
+    expect(timeoutWriter.Body.String()).toBe('timed out\n')
+
+    const makeFSFile = () => {
+      const data = $.stringToBytes('fs-body')
+      const reader = bytes.NewReader(data)
+      return {
+        Close: () => null,
+        Read: (p: $.Slice<number>) => reader.Read(p),
+        Stat: () =>
+          [
+            {
+              Name: () => 'asset.txt',
+              Size: () => data.length,
+              Mode: () => 0,
+              ModTime: () => new time.Time(),
+              IsDir: () => false,
+              Sys: () => null,
+            },
+            null,
+          ] as const,
+      }
+    }
+    const fsys = {
+      Open: (name: string) =>
+        name === 'asset.txt' ?
+          [makeFSFile(), null]
+        : [null, new Error('missing')],
+    }
+    const serveFileWriter = new testResponseWriter()
+
+    await ServeFileFS(serveFileWriter, redirectReq, fsys, 'asset.txt')
+
+    expect(serveFileWriter.Code).toBe(StatusOK)
+    expect(serveFileWriter.Body.String()).toBe('fs-body')
+
+    const [fileReq] = NewRequest(
+      MethodGet,
+      'file:///asset.txt',
+      io.NopCloser(bytes.NewReader($.stringToBytes('request'))),
+    )
+    const [fileResp, fileErr] =
+      await NewFileTransportFS(fsys).RoundTrip(fileReq)
+
+    expect(fileErr).toBeNull()
+    expect(fileResp?.StatusCode).toBe(StatusOK)
+    expect(fileResp?.Body).not.toBeNull()
+  })
+
   it('formats Set-Cookie headers for browser bootstrap routes', async () => {
     const header = new Header()
     const writer: ResponseWriter = {
@@ -1232,7 +1624,7 @@ describe('net/http override', () => {
     const [parsed, err] = ParseTime('Sun, 06 Nov 1994 08:49:37 GMT')
 
     expect(err).toBeNull()
-    expect(parsed.Unix()).toBe(784111777)
+    expect(parsed.Unix()).toBe(784111777n)
     expect(DetectContentType($.stringToBytes('<HTML>ok'))).toBe(
       'text/html; charset=utf-8',
     )
@@ -1361,6 +1753,261 @@ describe('net/http override', () => {
     expect(writes).toEqual(['status:200'])
   })
 
+  it('serves files whose request paths contain escaped spaces', async () => {
+    const opened: string[] = []
+    const root = FS({
+      Open: (name) => {
+        opened.push(name)
+        const reader = bytes.NewReader($.stringToBytes('video'))
+        return name === 'what is this.mp4' ?
+            [
+              {
+                Close: () => null,
+                Read: (p: Uint8Array) => reader.Read(p),
+                Seek: (offset: number, whence: number) =>
+                  reader.Seek(offset, whence),
+                Readdir: () => [null, null] as [null, null],
+                Stat: () =>
+                  [
+                    {
+                      IsDir: () => false,
+                      ModTime: () => null as never,
+                      Mode: () => 0,
+                      Name: () => name,
+                      Size: () => 5,
+                      Sys: () => null,
+                    },
+                    null,
+                  ] as const,
+              },
+              null,
+            ]
+          : [null, new Error('missing')]
+      },
+    })
+    const writes: string[] = []
+    const writer: ResponseWriter = {
+      Header: () => new Header(),
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => writes.push(`status:${code}`),
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/what%20is%20this.mp4',
+      null,
+    )
+
+    await FileServer(root).ServeHTTP(writer, req)
+
+    expect(opened).toEqual(['what is this.mp4'])
+    expect(writes).toEqual(['status:200', 'video'])
+  })
+
+  it('serves byte ranges from files like native net/http', async () => {
+    const data = $.stringToBytes('0123456789')
+    let offset = 0
+    const root = {
+      Open: () =>
+        [
+          {
+            Close: () => null,
+            Read: (p: $.Slice<number>) => {
+              if (offset >= data.length) {
+                return [0, io.EOF] as [number, $.GoError]
+              }
+              const n = Math.min(p?.length ?? 0, data.length - offset)
+              p?.set(data.subarray(offset, offset + n), 0)
+              offset += n
+              return [n, null] as [number, $.GoError]
+            },
+            Seek: (seekOffset: bigint, whence: number) => {
+              switch (whence) {
+                case io.SeekStart:
+                  offset = Number(seekOffset)
+                  break
+                case io.SeekCurrent:
+                  offset += Number(seekOffset)
+                  break
+                case io.SeekEnd:
+                  offset = data.length + Number(seekOffset)
+                  break
+              }
+              return [BigInt(offset), null] as [bigint, $.GoError]
+            },
+            Readdir: () => [null, null] as [null, $.GoError],
+            Stat: () =>
+              [
+                {
+                  IsDir: () => false,
+                  ModTime: () => null as never,
+                  Mode: () => 0,
+                  Name: () => 'media.mp4',
+                  Size: () => BigInt(data.length),
+                  Sys: () => null,
+                },
+                null,
+              ] as const,
+          },
+          null,
+        ] as [File, $.GoError],
+    }
+    const header = new Header()
+    const writes: string[] = []
+    const writer: ResponseWriter = {
+      Header: () => header,
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => writes.push(`status:${code}`),
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/media.mp4',
+      null,
+    )
+    Header_Set(req!.Header, 'Range', 'bytes=2-5')
+
+    await FileServer(root).ServeHTTP(writer, req)
+
+    expect(writes).toEqual([`status:${StatusPartialContent}`, '2345'])
+    expect(Header_Get(header, 'Accept-Ranges')).toBe('bytes')
+    expect(Header_Get(header, 'Content-Length')).toBe('4')
+    expect(Header_Get(header, 'Content-Range')).toBe('bytes 2-5/10')
+    expect(Header_Get(header, 'Content-Type')).toBe('video/mp4')
+  })
+
+  it('serves open-ended and suffix byte ranges from FileServer', async () => {
+    const serveRange = async (
+      range: string,
+    ): Promise<{
+      body: string
+      code: number
+      contentRange: string
+      length: string
+    }> => {
+      const reader = bytes.NewReader($.stringToBytes('0123456789'))
+      const root = {
+        Open: () =>
+          [
+            {
+              Close: () => null,
+              Read: (p: $.Slice<number>) => reader.Read(p),
+              Seek: (offset: number, whence: number) =>
+                reader.Seek(offset, whence),
+              Readdir: () => [null, null] as [null, $.GoError],
+              Stat: () =>
+                [
+                  {
+                    IsDir: () => false,
+                    ModTime: () => null as never,
+                    Mode: () => 0,
+                    Name: () => 'range.txt',
+                    Size: () => 10,
+                    Sys: () => null,
+                  },
+                  null,
+                ] as const,
+            },
+            null,
+          ] as [File, $.GoError],
+      }
+      let code = 0
+      const header = new Header()
+      const body: string[] = []
+      const writer: ResponseWriter = {
+        Header: () => header,
+        Write: (p) => {
+          body.push(Buffer.from(p ?? []).toString('utf8'))
+          return [p?.length ?? 0, null]
+        },
+        WriteHeader: (statusCode) => {
+          code = statusCode
+        },
+      }
+      const [req] = NewRequest(
+        MethodGet,
+        'http://example.invalid/range.txt',
+        null,
+      )
+      Header_Set(req!.Header, 'Range', range)
+
+      await FileServer(root).ServeHTTP(writer, req)
+
+      return {
+        body: body.join(''),
+        code,
+        contentRange: Header_Get(header, 'Content-Range'),
+        length: Header_Get(header, 'Content-Length'),
+      }
+    }
+
+    await expect(serveRange('bytes=6-')).resolves.toEqual({
+      body: '6789',
+      code: StatusPartialContent,
+      contentRange: 'bytes 6-9/10',
+      length: '4',
+    })
+    await expect(serveRange('bytes=-4')).resolves.toEqual({
+      body: '6789',
+      code: StatusPartialContent,
+      contentRange: 'bytes 6-9/10',
+      length: '4',
+    })
+  })
+
+  it('rejects unsatisfiable file ranges like native net/http', async () => {
+    const root = {
+      Open: () =>
+        [
+          {
+            Close: () => null,
+            Read: () => [0, io.EOF] as [number, $.GoError],
+            Seek: () => [0, null] as [number, $.GoError],
+            Readdir: () => [null, null] as [null, $.GoError],
+            Stat: () =>
+              [
+                {
+                  IsDir: () => false,
+                  ModTime: () => null as never,
+                  Mode: () => 0,
+                  Name: () => 'range.txt',
+                  Size: () => 10,
+                  Sys: () => null,
+                },
+                null,
+              ] as const,
+          },
+          null,
+        ] as [File, $.GoError],
+    }
+    const header = new Header()
+    const writes: string[] = []
+    const writer: ResponseWriter = {
+      Header: () => header,
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => writes.push(`status:${code}`),
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/range.txt',
+      null,
+    )
+    Header_Set(req!.Header, 'Range', 'bytes=99-100')
+
+    await FileServer(root).ServeHTTP(writer, req)
+
+    expect(writes[0]).toBe(`status:${StatusRequestedRangeNotSatisfiable}`)
+    expect(Header_Get(header, 'Content-Range')).toBe('bytes */10')
+    expect(Header_Get(header, 'Content-Length')).toBe('0')
+  })
+
   it('serves files from async file systems and file methods', async () => {
     const closeCalls: string[] = []
     const root = {
@@ -1601,7 +2248,9 @@ describe('net/http override', () => {
 
     expect(readSawHeader).toBe(true)
     expect(writes).toEqual(['status:200', 'streamed-body'])
-    expect(Header_Get(header, 'Content-Type')).toBe('text/javascript; charset=utf-8')
+    expect(Header_Get(header, 'Content-Type')).toBe(
+      'text/javascript; charset=utf-8',
+    )
   })
 
   it('awaits ServeContent writes before returning', async () => {
@@ -1647,6 +2296,38 @@ describe('net/http override', () => {
     expect(writes).toEqual(['status:200'])
   })
 
+  it('serves byte ranges from ServeContent like native net/http', async () => {
+    const writes: string[] = []
+    const header = new Header()
+    const writer: ResponseWriter = {
+      Header: () => header,
+      Write: (p) => {
+        writes.push(Buffer.from(p ?? []).toString('utf8'))
+        return [p?.length ?? 0, null]
+      },
+      WriteHeader: (code) => writes.push(`status:${code}`),
+    }
+    const [req] = NewRequest(
+      MethodGet,
+      'http://example.invalid/content.txt',
+      null,
+    )
+    Header_Set(req!.Header, 'Range', 'bytes=1-3')
+
+    await ServeContent(
+      writer,
+      req,
+      'content.txt',
+      null as never,
+      bytes.NewReader($.stringToBytes('served')),
+    )
+
+    expect(writes).toEqual([`status:${StatusPartialContent}`, 'erv'])
+    expect(Header_Get(header, 'Accept-Ranges')).toBe('bytes')
+    expect(Header_Get(header, 'Content-Length')).toBe('3')
+    expect(Header_Get(header, 'Content-Range')).toBe('bytes 1-3/6')
+  })
+
   it('closes request bodies after file transport requests', async () => {
     const root = FS({
       Open: () => [null, new Error('missing')],