Printing Contents of a .txt file in x86 NASM Assembly Language

I am learning Assembly Language and am trying to print a .txt file. Here's my code:

[org 0x0100] 
 jmp start 
filename: db 'test1.txt', 0 ;file that is to be loaded
buffer:   times 4096 db 0 ;allocating 4K of space to store file contents
handle:   dw 0      ;handle for the file

start:
    ; open the file
    mov ah, 0x3d     ; service 3d - open file
    mov al, 0       ; read-only mode
    mov dx, filename
    int 0x21
    mov [handle], ax  ; save the file handle

    ; read the file into buffer
    mov ah, 0x3f     ; service 3f - read from file
    mov bx, [handle]
    mov cx, 4096     ; read up to 4096 bytes
    mov dx, buffer
    int 0x21

    ; print the buffer to the console
    mov dx, buffer  ; making sure it actually prints buffer
    mov ah, 9       ; service 9 - print string
    int 0x21

    ; close the file
    mov ah, 0x3e     ; service 3e - close file
    mov bx, [handle]
    int 0x21

    ; exit the program
    mov ax, 0x4c00 ; terminate program 
    int 0x21

However, it only prints whitespace followed by 6-8 lines of garbage. Inside the file is only a single word.

I am using DOS Box portable to compile and run my COM format assembly code and here's how I'm doing it.
I compile the program and make a .com executable for it and in addition the .lst is made for debugging:
nasm myProgram.asm -o myProgram.com -l myProgram.lst
to run the program, I just enter myProgram.com

After researching, and reviewing a similar question the problem in my code seems to be not adding an offset while printing. And the code is supposed to be mov dx, offset buffer . As it turns out, my compiler does not support this syntax and gives a syntax error. I have tried to manually ad the offset mov dx, [buffer + 2] (I've tried changing the offset size) but it just prints more garbage, just in a different pattern.

Code below uses function AH=0x40 to write data to standard output, console instead of using AH=0x9.

org 100h

jmp start 

filename: db 'test1.txt', 0 ;file that is to be loaded
buffer:    times 4096 db 0 ;allocating 4K of space to store file 
handle:   dw 0      ;handle for the file
BytesRead: dw 0

start:
; open the file
mov ah, 0x3d     ; service 3d - open file
mov al, 0       ; read-only mode
mov dx, filename
int 0x21

mov [handle], ax  ; save the file handle

; read the file into buffer
mov ah, 0x3f     ; service 3f - read from file
mov bx, [handle]
mov cx, 4096     ; read up to 4096 bytes
mov dx, buffer
int 0x21

;-- Print to file,device AH=0x40
; We use 1, output to screen. 
;0 - input stream (console)
;1 - output stream (console)
;2 - diagnostic stream (console)
;3 - aux stream (serial port)
;4 - prn stream (printer) 

mov [BytesRead],ax

mov ah, 0x40     ; service 0x40 - read to file/device
mov bx, 0x1     ;change current file handle to standard output, console
mov cx, [BytesRead]     
mov dx, buffer
int 0x21

;-- Print character one by one AH=0x2
;mov [BytesRead],ax

;mov cx, [BytesRead]
;mov bx, buffer

;    Print:
;    mov ah,0x2
;    mov dl,[bx]
;    int 0x21
;    inc bx
;loop Print

;----------------------------

; mov dx, buffer  ; making sure it actually prints buffer
;mov ah, 9       ; service 9 - print string
;int 0x21

; close the file
mov ah, 0x3e     ; service 3e - close file
mov bx, [handle]
int 0x21

End:
; exit the program
mov ax, 0x4c00 ; terminate program 
int 0x21

Based on 0Signal's previous answer I was a able to make a code to print the file, I also took vitsoft's suggestion to add a check if the files actually opened or read and print an error if they didn't.

However, in this I have to add a null terminator character '$' at the end of my text. There does exist a way to manually calculate the length of a string and then add the null terminator character at the length's index but it seems too cumbersome.

Instead, there is a more viable approach i.e. to use service ax3f or ax40 which are used to read, write the file. As suggested by Nate, these services return the length(the characters this service actually reads) of the file in the ax register.

I had the ax register which included the length of the file and added the starting index of the buffer. This pointed to the last index where I added the null terminator of DOS which is $.

Here's how I implemented it:

[org 0x0100] 
 jmp start 
filename: db 'test1.txt', 0 ;file that is to be loaded
buffer:   times 4096 db 0 ;allocating 4K of space to store file contents
handle:   dw 0      ;handle for the file
length:   dw 0      ;length of the file

openfailed: db 'File could not be opened$' 
readfailed: db 'File could not be read$' 

start:
    ; open the file
    mov ah, 0x3d     ; service 3d - open file
    mov al, 0       ; read-only mode
    mov dx, filename
    int 0x21
    jnc read        ;proceed if no errors
    mov dx, openfailed ;print the error
    jmp finalexit
    
read:
    mov [handle], ax  ; save the file handle

    ; read the file into buffer
    mov ah, 0x3f     ; service 3f - read from file
    mov bx, [handle]
    mov cx, 4096     ; read up to 4096 bytes
    mov dx, buffer
    int 0x21
    jnc printbuffer ;proceed if no errors
    mov dx, openfailed ;print the error
    jmp finalexit

printbuffer:
    ; print the buffer to the console
    mov si, 0 ;initialize the si register to zero
    lea si, [buffer] ;load the buffer's staring index in si register
    add si, ax  ;ax already has the size of the bytes that were read
    mov byte[si], '$' ;adding the null terminator at the end of buffer.
    mov dx, buffer

finalexit:
    mov ah, 9       ; service 9 - print string
    int 0x21

    ; close the file
    mov ah, 0x3e     ; service 3e - close file
    mov bx, [handle]
    int 0x21

    ; exit the program
    mov ax, 0x4c00 ; terminate program 
    int 0x21