diff --git a/examples/bogus_data.jmp b/examples/bogus_data.jmp
new file mode 100644
index 0000000..c317275
Binary files /dev/null and b/examples/bogus_data.jmp differ
diff --git a/examples/create_bogus_data.jsl b/examples/create_bogus_data.jsl
new file mode 100644
index 0000000..d159410
--- /dev/null
+++ b/examples/create_bogus_data.jsl
@@ -0,0 +1,43 @@
+Names Default To Here( 1 );
+
+out = "C:/GitHub/jmpio-python/examples/bogus_data_jmp17_native.jmp";
+
+dt = New Table( "Bogus Data JMP17 Native",
+	Add Rows( 5 ),
+	New Column(
+		"Batch",
+		Character,
+		Nominal,
+		Set Values( {"BOGUS-001", "BOGUS-002", "BOGUS-003", "BOGUS-004", "BOGUS-005"} )
+	),
+	New Column(
+		"Material",
+		Character,
+		Nominal,
+		Set Values( {"Placebo", "Control", "Reference", "Challenge", "Discard"} )
+	),
+	New Column(
+		"Assay",
+		Numeric,
+		Continuous,
+		Format( "Fixed Dec", 10, 2 ),
+		Set Values( [101.20, 98.70, ., 104.40, 99.90] )
+	),
+	New Column(
+		"Impurity_pct",
+		Numeric,
+		Continuous,
+		Format( "Fixed Dec", 10, 3 ),
+		Set Values( [0.120, 0.180, 0.090, ., 0.210] )
+	),
+	New Column(
+		"Result",
+		Character,
+		Nominal,
+		Set Values( {"Pass", "Pass", "Investigate", "Pass", "Fail"} )
+	)
+);
+
+dt << Save( out );
+Close( dt, No Save );
+Quit();
diff --git a/examples/empty_data.jmp b/examples/empty_data.jmp
new file mode 100644
index 0000000..55918bd
Binary files /dev/null and b/examples/empty_data.jmp differ
diff --git a/src/jmpio/column.py b/src/jmpio/column.py
index fc5c512..d9eef17 100644
--- a/src/jmpio/column.py
+++ b/src/jmpio/column.py
@@ -203,19 +203,19 @@ def read_column_data(file: BinaryIO, info: JMPInfo, column_idx: int) -> Any:
                 if len(row_data_bytes) < width:
                     raise EOFError(f"Not enough data for row state in {column_name}")
 
-                marker_idx = bit_cat(row_data_bytes[6], row_data_bytes[7])
-                marker = ROWSTATE_MARKERS[marker_idx] if marker_idx < len(ROWSTATE_MARKERS) else chr(marker_idx)
-
-                r, g, b = 0.0, 0.0, 0.0
-                if row_data_bytes[4] == 0xFF:
-                    r = row_data_bytes[3] / 255.0
-                    g = row_data_bytes[2] / 255.0
-                    b = row_data_bytes[1] / 255.0
-                else:
-                    color_idx = row_data_bytes[1]
-                    if 0 <= color_idx < len(ROWSTATE_COLORS):
-                        hex_color = ROWSTATE_COLORS[color_idx]
-                        r, g, b = hex_to_rgb(hex_color)
+                marker_idx = bit_cat(row_data_bytes[6], row_data_bytes[5])
+                marker = ROWSTATE_MARKERS[marker_idx] if marker_idx < len(ROWSTATE_MARKERS) else chr(marker_idx)
+
+                r, g, b = 0.0, 0.0, 0.0
+                if row_data_bytes[3] == 0xFF:
+                    r = row_data_bytes[2] / 255.0
+                    g = row_data_bytes[1] / 255.0
+                    b = row_data_bytes[0] / 255.0
+                else:
+                    color_idx = row_data_bytes[0]
+                    if 0 <= color_idx < len(ROWSTATE_COLORS):
+                        hex_color = ROWSTATE_COLORS[color_idx]
+                        r, g, b = hex_to_rgb(hex_color)
                 row_states.append(RowState(marker=marker, color=(r, g, b)))
             return pd.Series(row_states)
 
@@ -239,12 +239,12 @@ def read_column_data(file: BinaryIO, info: JMPInfo, column_idx: int) -> Any:
                 if len(all_string_data) < data_size:
                     raise EOFError(f"Not enough data for const char column {column_name}")
 
-                for i in range(info.nrows):
-                    start = i * width
-                    s_bytes = all_string_data[start : start + width]
-                    s = s_bytes.rstrip(b"\x00").decode("utf-8", errors="replace")
-                    strings.append(s)
-                return pd.Series(strings)
+                for i in range(info.nrows):
+                    start = i * width
+                    s_bytes = all_string_data[start : start + width]
+                    s = s_bytes.split(b"\x00", 1)[0].decode("utf-8", errors="replace")
+                    strings.append(s)
+                return pd.Series(strings)
 
             # Variable width
             elif [dt3, dt4, dt5] == [0x00, 0x00, 0x00]:
@@ -265,14 +265,17 @@ def read_column_data(file: BinaryIO, info: JMPInfo, column_idx: int) -> Any:
 
                         # Indices to pool
                         wb = buf.read(1)[0]
-                        if wb == 1:
-                            idx_dtype = np.int8
-                            idx_itemsize = 1
-                        elif wb == 2:
-                            idx_dtype = np.int16
-                            idx_itemsize = 2
-                        else:
-                            raise ValueError(f"Unknown index width byte {wb} for pooled var char in {column_name}")
+                        if wb == 1:
+                            idx_dtype = np.uint8
+                            idx_itemsize = 1
+                        elif wb == 2:
+                            idx_dtype = np.dtype("<u2")
+                            idx_itemsize = 2
+                        elif wb == 4:
+                            idx_dtype = np.dtype("<u4")
+                            idx_itemsize = 4
+                        else:
+                            raise ValueError(f"Unknown index width byte {wb} for pooled var char in {column_name}")
 
                         idx_raw = buf.read(idx_itemsize * info.nrows)
                         idx = np.frombuffer(idx_raw, dtype=idx_dtype)
@@ -302,8 +305,8 @@ def read_column_data(file: BinaryIO, info: JMPInfo, column_idx: int) -> Any:
                         return pd.Series(strings)
 
                     # Non-pooled compressed variable-width strings
-                    data_payload_source.seek(9)
-                    width_bytes_val = data_payload_source.read(1)[0]
+                    data_payload_source.seek(8)
+                    width_bytes_val = data_payload_source.read(1)[0]
                     lengths_offset_in_payload = 13
                     data_payload_source.seek(lengths_offset_in_payload)
 
@@ -320,12 +323,13 @@ def read_column_data(file: BinaryIO, info: JMPInfo, column_idx: int) -> Any:
                     lengths = np.frombuffer(lengths_raw, dtype=len_dtype)
                     string_data_block = data_payload_source.read()
                     current_offset_in_strings = 0
-                    for length in lengths:
-                        s_bytes = string_data_block[current_offset_in_strings : current_offset_in_strings + length]
-                        strings.append(s_bytes.decode("utf-8", errors="replace"))
-                        current_offset_in_strings += int(length)
-                    return pd.Series(strings)
-                else:
+                    for length in lengths:
+                        length_int = int(length)
+                        s_bytes = string_data_block[current_offset_in_strings : current_offset_in_strings + length_int]
+                        strings.append(s_bytes.decode("utf-8", errors="replace"))
+                        current_offset_in_strings += length_int
+                    return pd.Series(strings)
+                else:
                     # Uncompressed variable width
                     file.seek(start_pos_after_dt)
                     _ = file.read(6)
@@ -355,11 +359,29 @@ def read_column_data(file: BinaryIO, info: JMPInfo, column_idx: int) -> Any:
                     file.seek(col_end - sum_lengths)
                     all_string_data_bytes = file.read(sum_lengths)
                     current_offset = 0
-                    for length in lengths:
-                        s_bytes = all_string_data_bytes[current_offset : current_offset + length]
-                        strings.append(s_bytes.decode("utf-8", errors="replace"))
-                        current_offset += int(length)
-                    return pd.Series(strings)
+                    for length in lengths:
+                        length_int = int(length)
+                        s_bytes = all_string_data_bytes[current_offset : current_offset + length_int]
+                        strings.append(s_bytes.decode("utf-8", errors="replace"))
+                        current_offset += length_int
+                    return pd.Series(strings)
+
+        elif dt1 == 0x03 and dt2 == 0x03:
+            if not is_compressed:
+                file.seek(start_pos_after_dt)
+                uncompressed_data_block_bytes = file.read(col_end - start_pos_after_dt)
+                data_payload_source = io.BytesIO(uncompressed_data_block_bytes)
+
+            if data_payload_source is None:
+                raise ValueError("data_payload_source not initialized for Int64 row state type")
+
+            width = dt5
+            data_size = width * info.nrows
+            data_payload_source.seek(-data_size, 2)
+            raw_data = data_payload_source.read(data_size)
+            if len(raw_data) < data_size:
+                raise EOFError(f"Not enough data for Int64 row state column {column_name}")
+            return pd.Series(np.frombuffer(raw_data, dtype=np.dtype("<i8")))
 
     except struct.error as e:
         print(
diff --git a/src/jmpio/metadata.py b/src/jmpio/metadata.py
index fcb127b..04f2613 100644
--- a/src/jmpio/metadata.py
+++ b/src/jmpio/metadata.py
@@ -121,7 +121,7 @@ def column_info(file: BinaryIO, ncols: int) -> tuple[list[str], list[int]]:
             raise EOFError("Unexpected end of file when searching for column information")
 
         # Check for special marker bytes
-        if twobytes in [b"\xfd\xff", b"\xfe\xff", b"\xff\xff"]:
+        if twobytes in [b"\xfc\xff", b"\xfd\xff", b"\xfe\xff", b"\xff\xff"]:
             n = struct.unpack("<q", file.read(8))[0]  # Int64, little-endian
             _ = file.read(n)  # Skip this data
         else:
diff --git a/src/jmpio/writer.py b/src/jmpio/writer.py
index 6c7eff0..73257fb 100644
--- a/src/jmpio/writer.py
+++ b/src/jmpio/writer.py
@@ -18,10 +18,17 @@
     ROWSTATE_COLORS,
     ROWSTATE_MARKERS,
 )
-from .types import RowState
-
-
-def write_jmp(df: pd.DataFrame, filename: str, compress: bool = True, version: str = "16.0") -> None:
+from .types import RowState
+
+SUPPORTED_WRITE_VERSION = "17.2.0"
+
+
+def write_jmp(
+    df: pd.DataFrame,
+    filename: str,
+    compress: bool = True,
+    version: str = SUPPORTED_WRITE_VERSION,
+) -> None:
     """
     Write a pandas DataFrame to a JMP file
 
@@ -33,8 +40,8 @@ def write_jmp(df: pd.DataFrame, filename: str, compress: bool = True, version: s
         Path to the output file
     compress : bool, default=True
         Whether to compress the data
-    version : str, default="16.0"
-        JMP version to use in the file header
+    version : str, default="17.2.0"
+        JMP file version to write. Currently only "17.2.0" is supported.
 
     Returns:
     --------
@@ -52,29 +59,43 @@ def write_jmp(df: pd.DataFrame, filename: str, compress: bool = True, version: s
     >>>     'strings': ['a', 'bb', 'ccc', 'dddd']
     >>> })
     >>>
-    >>> # Write to a JMP file
-    >>> jmpio.write_jmp(df, 'output.jmp')
-    """
-    # Create directory if it doesn't exist
-    directory = os.path.dirname(os.path.abspath(filename))
+    >>> # Write to a JMP file
+    >>> jmpio.write_jmp(df, 'output.jmp')
+    """
+    if version != SUPPORTED_WRITE_VERSION:
+        raise ValueError(
+            f"Unsupported JMP write version {version!r}; "
+            f"only {SUPPORTED_WRITE_VERSION!r} is currently supported"
+        )
+
+    # Create directory if it doesn't exist
+    directory = os.path.dirname(os.path.abspath(filename))
     if directory and not os.path.exists(directory):
         os.makedirs(directory)
 
-    # Open file in binary write mode
-    with open(filename, "wb") as file:
-        # Write file header
-        write_file_header(file, df, version)
-
-        # Write column metadata
-        column_offsets = write_column_metadata(file, df)
-
-        # Write column data
-        for i, column_name in enumerate(df.columns):
-            column_data = df[column_name]
-            write_column_data(file, column_data, column_offsets[i], column_name, compress)
-
-        # Any final corrections or clean-up
-        finalize_file(file)
+    # Open file in binary write mode
+    with open(filename, "wb") as file:
+        # Write file header
+        write_file_header(file, df, version)
+
+        # Write column metadata
+        offset_table_pos = write_column_metadata(file, df)
+
+        # Write column data
+        column_offsets = []
+        for i, column_name in enumerate(df.columns):
+            column_offsets.append(file.tell())
+            column_data = df[column_name]
+            write_column_data(file, column_data, column_offsets[i], column_name, compress)
+
+        end_pos = file.tell()
+        file.seek(offset_table_pos)
+        for offset in column_offsets:
+            file.write(struct.pack("<q", offset))
+        file.seek(end_pos)
+
+        # Any final corrections or clean-up
+        finalize_file(file)
 
 
 def write_file_header(file: BinaryIO, df: pd.DataFrame, version: str) -> None:
@@ -90,34 +111,27 @@ def write_file_header(file: BinaryIO, df: pd.DataFrame, version: str) -> None:
     version : str
         JMP version to use in the header
     """
-    # Write magic bytes (signature)
-    file.write(MAGIC_JMP)
-
-    # Write padding up to the row offset
-    padding_size = 368 - len(MAGIC_JMP)
-    padding_data = bytearray([0] * padding_size)
-
-    # Add some metadata in the padding (this is reverse-engineered)
-    # Here we could add metadata like creation software, etc.
-    file.write(padding_data)
+    # JMPReader.jl finds the table metadata by scanning for the byte sequence
+    # written inside foo2 below and then backing up to offset 368. Keep the
+    # preamble size aligned with JMP 17 files observed in the fixture set.
+    file.write(MAGIC_JMP)
+    file.write(bytearray([0] * (368 - len(MAGIC_JMP))))
 
     # Write number of rows (Int64) and columns (Int32)
     file.write(struct.pack("<q", len(df)))
     file.write(struct.pack("<i", len(df.columns)))
 
-    # Write unknown values (5 Int16s)
-    for _ in range(5):
-        file.write(struct.pack("<h", 0))
-
-    # Write character set (typically ASCII or UTF-8)
-    charset = "UTF8"
-    file.write(struct.pack("<b", len(charset)))
-    file.write(charset.encode("utf-8"))
-    file.write(b"\0")  # Null terminator
-
-    # Write some unknown values (3 UInt16s)
-    for _ in range(3):
-        file.write(struct.pack("<H", 0))
+    # Unknown values observed in JMP 17.2 files. The last value is the length
+    # marker for the following charset string.
+    file.write(struct.pack("<5h", 0, 4, 93, 0, 6))
+
+    # JMP strings in this section use a 4-byte little-endian length prefix.
+    charset = b"utf-8\0"
+    file.write(struct.pack("<i", len(charset)))
+    file.write(charset)
+
+    # The reader searches for these bytes: 07 00 08 00 00 00.
+    file.write(struct.pack("<3H", 7, 8, 0))
 
     # Write save time (current time as seconds since JMP epoch)
     current_time = datetime.now()
@@ -127,13 +141,13 @@ def write_file_header(file: BinaryIO, df: pd.DataFrame, version: str) -> None:
     # Write more unknown values (1 UInt16)
     file.write(struct.pack("<H", 18))  # From observed files
 
-    # Write build string with version
-    build_string = f"JMP Version {version}"
-    file.write(struct.pack("<i", len(build_string)))
-    file.write(build_string.encode("utf-8"))
+    # Write build string with version.
+    build_string = f"Jul 23 2023, 19:09:15, Release, JMP, Version {version}".encode("utf-8")
+    file.write(struct.pack("<i", len(build_string)))
+    file.write(build_string)
 
 
-def write_column_metadata(file: BinaryIO, df: pd.DataFrame) -> list[int]:
+def write_column_metadata(file: BinaryIO, df: pd.DataFrame) -> int:
     """
     Write metadata about columns
 
@@ -146,14 +160,15 @@ def write_column_metadata(file: BinaryIO, df: pd.DataFrame) -> list[int]:
 
     Returns:
     --------
-    list[int]
-        List of file offsets for each column's data
+    int
+        File position where the Int64 column-offset table starts
     """
     # Write column metadata section marker
     file.write(b"\xff\xff")
 
-    # Write some zeros (observed format)
-    file.write(struct.pack("<QQQQ", 0, 0, 0, 0))
+    # The reader skips exactly 10 bytes after this marker before reading the
+    # visible/hidden column counts.
+    file.write(struct.pack("<QH", 0, 0))
 
     # Write visible and hidden column counts
     # For now, all columns are visible
@@ -178,45 +193,15 @@ def write_column_metadata(file: BinaryIO, df: pd.DataFrame) -> list[int]:
     for _ in range(7):
         file.write(struct.pack("<I", 0))
 
-    # Mark beginning of column data section
-    column_section_pos = file.tell()
-
-    # Write the number of columns again as a check
-    file.write(struct.pack("<i", len(df.columns)))
-
-    # Reserve space for column offsets
-    offset_pos = file.tell()
-    for _ in range(len(df.columns)):
-        file.write(struct.pack("<q", 0))  # Placeholder for column offsets
-
-    # Calculate the actual column offsets
-    # Start position for first column's data
-    data_start_pos = file.tell() + 1000  # Arbitrary buffer
-
-    # Align data start to 8-byte boundary for better performance
-    data_start_pos = (data_start_pos + 7) & ~7
-
-    # Seek to position to store column data
-    file.seek(data_start_pos)
-
-    # Calculate offsets for each column
-    column_offsets = []
-    for i, column_name in enumerate(df.columns):
-        column_offsets.append(file.tell())
-
-        # Skip ahead a reasonable amount to make room for column headers
-        # We'll come back and fill this in properly
-        file.write(bytearray([0] * 100))  # Arbitrary space for column header
-
-    # Go back and write the actual offsets
-    file.seek(offset_pos)
-    for offset in column_offsets:
-        file.write(struct.pack("<q", offset))
-
-    # Return to last position
-    file.seek(column_offsets[-1] + 100)
-
-    return column_offsets
+    # Write the number of columns again as a check
+    file.write(struct.pack("<i", len(df.columns)))
+
+    # Reserve space for column offsets
+    offset_pos = file.tell()
+    for _ in range(len(df.columns)):
+        file.write(struct.pack("<q", 0))  # Placeholder for column offsets
+
+    return offset_pos
 
 
 def write_column_data(
@@ -242,15 +227,13 @@ def write_column_data(
     compress : bool, default=True
         Whether to compress the data
     """
-    # Save the current position so we can return to it
-    current_pos = file.tell()
-
-    # Seek to the column's offset
-    file.seek(offset)
-
-    # Write column name
-    file.write(struct.pack("<h", len(column_name)))
-    file.write(column_name.encode("utf-8"))
+    # Seek to the column's offset
+    file.seek(offset)
+
+    # Write column name
+    encoded_name = str(column_name).encode("utf-8")
+    file.write(struct.pack("<h", len(encoded_name)))
+    file.write(encoded_name)
 
     # Determine data type and write appropriate type markers
     data_type = get_column_data_type(column)
@@ -275,11 +258,8 @@ def write_column_data(
         # Default to writing as string
         write_string_column(file, column, compress)
 
-    # Return to the previous position
-    file.seek(current_pos)
-
-
-def get_column_data_type(column: pd.Series) -> str:
+
+def get_column_data_type(column: pd.Series) -> str:
     """
     Determine the JMP data type for a pandas column
 
@@ -297,8 +277,11 @@ def get_column_data_type(column: pd.Series) -> str:
     dtype = column.dtype
 
     # Check for pandas extension types
-    if hasattr(dtype, "name"):
-        dtype_name = dtype.name
+    if hasattr(dtype, "name"):
+        dtype_name = dtype.name
+
+        if dtype_name == "string" or dtype_name.startswith("string"):
+            return "string"
 
         # Check for pandas nullable integer types
         if dtype_name in ["Int8", "Int16", "Int32", "Int64"]:
@@ -315,13 +298,14 @@ def get_column_data_type(column: pd.Series) -> str:
                 return "datetime"
 
     # Check numpy/pandas basic types
-    if np.issubdtype(dtype, np.integer):
-        return "int"
-    elif np.issubdtype(dtype, np.floating):
-        return "float"
-    elif np.issubdtype(dtype, np.datetime64):
-        # Try to distinguish date from datetime
-        try:
+    try:
+        np_dtype = np.dtype(dtype)
+    except TypeError:
+        return "string"
+
+    if np.issubdtype(np_dtype, np.datetime64):
+        # Try to distinguish date from datetime
+        try:
             # Check if all values have time component equal to midnight
             has_time = False
             for val in pd.to_datetime(column.dropna()):
@@ -334,10 +318,14 @@ def get_column_data_type(column: pd.Series) -> str:
                 return "datetime"
             else:
                 return "date"
-        except (AttributeError, TypeError):
-            return "datetime"
-    elif np.issubdtype(dtype, np.timedelta64):
-        return "duration"
+        except (AttributeError, TypeError):
+            return "datetime"
+    elif np.issubdtype(np_dtype, np.timedelta64):
+        return "duration"
+    elif np.issubdtype(np_dtype, np.integer):
+        return "int"
+    elif np.issubdtype(np_dtype, np.floating):
+        return "float"
     elif dtype == "object":
         # Check first non-null value type
         non_null = column.dropna()
@@ -377,7 +365,7 @@ def write_float_column(file: BinaryIO, column: pd.Series, compress: bool) -> Non
         Whether to compress the data
     """
     # Type markers for float64
-    dt1 = 0x09 if compress else 0x01  # 0x09 for compressed data
+    dt1 = 0x0A if compress else 0x01  # 0x0A for compressed numeric data
     dt2, dt3, dt4, dt5, dt6 = 0x01, 0x00, 0x00, 0x00, 0x08
     file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
@@ -452,7 +440,7 @@ def write_int_column(file: BinaryIO, column: pd.Series, compress: bool) -> None:
             dt6 = 0x04
 
     # Type markers for integer
-    dt1 = 0x09 if compress else 0x01  # 0x09 for compressed data
+    dt1 = 0x0A if compress else 0x01  # 0x0A for compressed numeric data
     dt2, dt3, dt4, dt5 = 0x01, 0x00, 0x00, 0x00
     file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
@@ -500,29 +488,29 @@ def write_string_column(file: BinaryIO, column: pd.Series, compress: bool) -> No
     column = column.fillna("")
 
     # Get string lengths
-    string_lengths = column.str.len()
-    max_length = string_lengths.max()
-    min_length = string_lengths.min()
-
-    # Determine if we should use fixed width or variable width
-    use_fixed_width = max_length == min_length and max_length > 0
+    encoded_strings = [str(s).encode("utf-8") for s in column]
+    string_lengths = [len(s) for s in encoded_strings]
+    max_length = max(string_lengths, default=0)
+    min_length = min(string_lengths, default=0)
+
+    # Determine if we should use fixed width or variable width
+    use_fixed_width = max_length == min_length and 0 < max_length <= 255
 
     if use_fixed_width:
         # For fixed width strings
         dt1 = 0x09 if compress else 0x02  # 0x09 for compressed data
         dt2, dt3, dt4 = 0x01, 0x00, 0x00
-        dt5 = min(max_length, 65535)  # Max width is UInt16 max
+        dt5 = max_length
         dt6 = 0x00
 
         file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
         # Create a byte array of fixed width strings
         string_data = bytearray()
-        for s in column:
-            # Encode the string as UTF-8 and pad/truncate to fixed width
-            encoded = s.encode("utf-8")
-            padded = encoded[:dt5].ljust(dt5, b"\0")
-            string_data.extend(padded)
+        for encoded in encoded_strings:
+            # Encode the string as UTF-8 and pad/truncate to fixed width
+            padded = encoded[:dt5].ljust(dt5, b"\0")
+            string_data.extend(padded)
 
         if compress:
             # Write some header for compressed data
@@ -546,26 +534,25 @@ def write_string_column(file: BinaryIO, column: pd.Series, compress: bool) -> No
     else:
         # For variable width strings
         dt1 = 0x09  # Always use compression for variable width
-        dt2, dt3, dt4, dt5, dt6 = 0x01, 0x00, 0x00, 0x00, 0x00
+        dt2, dt3, dt4, dt5, dt6 = 0x02, 0x00, 0x00, 0x00, 0x00
 
         file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
         # Prepare variable width string data
 
         # Determine width needed for length values
-        use_int16 = max_length >= 128
+        use_int16 = max_length >= 128
 
         # Prepare header
         header = bytearray([0] * 13)
-        header[9] = 2 if use_int16 else 1  # Width bytes
+        header[8] = 2 if use_int16 else 1  # Width bytes
 
         # Prepare lengths and string data
         lengths = bytearray()
         string_data = bytearray()
 
-        for s in column:
-            encoded = s.encode("utf-8")
-            string_data.extend(encoded)
+        for encoded in encoded_strings:
+            string_data.extend(encoded)
 
             if use_int16:
                 lengths.extend(struct.pack("<h", len(encoded)))
@@ -603,7 +590,7 @@ def write_datetime_column(file: BinaryIO, column: pd.Series, compress: bool) ->
         Whether to compress the data
     """
     # Type markers for datetime
-    dt1 = 0x09 if compress else 0x01  # 0x09 for compressed data
+    dt1 = 0x0A if compress else 0x01  # 0x0A for compressed numeric data
     dt2, dt3, dt4, dt5, dt6 = 0x01, 0x00, 0x69, 0x69, 0x08
     file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
@@ -657,7 +644,7 @@ def write_date_column(file: BinaryIO, column: pd.Series, compress: bool) -> None
         Whether to compress the data
     """
     # Type markers for date
-    dt1 = 0x09 if compress else 0x01  # 0x09 for compressed data
+    dt1 = 0x0A if compress else 0x01  # 0x0A for compressed numeric data
     dt2, dt3, dt4, dt5, dt6 = 0x01, 0x00, 0x65, 0x65, 0x08
     file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
@@ -713,7 +700,7 @@ def write_time_column(file: BinaryIO, column: pd.Series, compress: bool) -> None
         Whether to compress the data
     """
     # Type markers for time
-    dt1 = 0x09 if compress else 0x01  # 0x09 for compressed data
+    dt1 = 0x0A if compress else 0x01  # 0x0A for compressed numeric data
     dt2, dt3, dt4, dt5, dt6 = 0x01, 0x00, 0x82, 0x82, 0x08
     file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
@@ -767,7 +754,7 @@ def write_duration_column(file: BinaryIO, column: pd.Series, compress: bool) ->
         Whether to compress the data
     """
     # Type markers for duration
-    dt1 = 0x09 if compress else 0x01  # 0x09 for compressed data
+    dt1 = 0x0A if compress else 0x01  # 0x0A for compressed numeric data
     dt2, dt3, dt4, dt5, dt6 = 0x01, 0x00, 0x6C, 0x6C, 0x08
     file.write(struct.pack("<BBBBBB", dt1, dt2, dt3, dt4, dt5, dt6))
 
diff --git a/tests/test_data/bugMWE4.jmp b/tests/test_data/bugMWE4.jmp
new file mode 100644
index 0000000..4a90a34
Binary files /dev/null and b/tests/test_data/bugMWE4.jmp differ
diff --git a/tests/test_data/compact_UInt16.jmp b/tests/test_data/compact_UInt16.jmp
new file mode 100644
index 0000000..867afdc
Binary files /dev/null and b/tests/test_data/compact_UInt16.jmp differ
diff --git a/tests/test_data/compact_UInt32.jmp b/tests/test_data/compact_UInt32.jmp
new file mode 100644
index 0000000..2bd78e1
Binary files /dev/null and b/tests/test_data/compact_UInt32.jmp differ
diff --git a/tests/test_data/compact_UInt8.jmp b/tests/test_data/compact_UInt8.jmp
new file mode 100644
index 0000000..5500478
Binary files /dev/null and b/tests/test_data/compact_UInt8.jmp differ
diff --git a/tests/test_data/minusfour.jmp b/tests/test_data/minusfour.jmp
new file mode 100644
index 0000000..0c690a8
Binary files /dev/null and b/tests/test_data/minusfour.jmp differ
diff --git a/tests/test_reader.py b/tests/test_reader.py
index 1ad4ff3..14433dc 100644
--- a/tests/test_reader.py
+++ b/tests/test_reader.py
@@ -301,7 +301,7 @@ def test_row_states():
     assert color is not None and all(abs(c - 0.753) < 0.01 for c in color)
 
 
-def test_compact_subtype_file():
+def test_compact_subtype_file():
     """Test reading compact.jmp if available"""
     file_path = os.path.join(TEST_DATA_DIR, "compact.jmp")
 
@@ -317,7 +317,38 @@ def test_compact_subtype_file():
     assert df["longcompact"].iloc[2] == ""
     z = "z" * 256
     assert df["longcompact"].iloc[3] == z
-    assert df["longcompact"].iloc[4] == z
+    assert df["longcompact"].iloc[4] == z
+
+    df = read_jmp(os.path.join(TEST_DATA_DIR, "compact_UInt8.jmp"))
+    assert df.shape == (130, 1)
+    assert df["A"].iloc[:3].tolist() == ["a1", "a2", "a3"]
+    assert df["A"].iloc[-1] == "a130"
+
+    df = read_jmp(os.path.join(TEST_DATA_DIR, "compact_UInt16.jmp"))
+    assert df.shape == (32770, 1)
+    assert df["A"].iloc[-1] == "a32770"
+
+    df = read_jmp(os.path.join(TEST_DATA_DIR, "compact_UInt32.jmp"))
+    assert df.shape == (65537, 1)
+    assert df["A"].iloc[-1] == "a65537"
+
+
+def test_minusfour_column_info_marker():
+    """Test column metadata sections with a 0xfc 0xff marker."""
+    df = read_jmp(os.path.join(TEST_DATA_DIR, "minusfour.jmp"))
+
+    assert df.shape == (3, 1)
+    assert df["Column 1"].tolist() == ["a", "b", "c"]
+
+
+def test_bug_mwe4_truncates_fixed_strings_at_first_null():
+    """Test fixed-width strings containing internal null padding."""
+    df = read_jmp(os.path.join(TEST_DATA_DIR, "bugMWE4.jmp"))
+
+    assert df["c"].iloc[:3].tolist() == ["cat", "cat", "dolor sit amet"]
+    assert df["d"].iloc[:3].tolist() == ["bat", "bat", "consectetur adipiscing elit"]
+    assert df["e"].iloc[:3].tolist() == ["bird", "bird", "sed do eiusmod"]
+    assert df["f"].iloc[15:18].tolist() == ["foo", "bar", "hello world"]
 
 
 def test_column_filtering():
diff --git a/tests/test_writer.py b/tests/test_writer.py
index d931188..1f20f4b 100644
--- a/tests/test_writer.py
+++ b/tests/test_writer.py
@@ -6,21 +6,37 @@
 import tempfile
 from datetime import date, datetime, timedelta
 
-import pandas as pd
-import pytest
-
-from jmpio import read_jmp, write_jmp
+import pandas as pd
+import pytest
+
+from jmpio import read_jmp, write_jmp
+from jmpio.metadata import read_metadata
 
 # Directory with test data (set up by conftest.py)
 TEST_DATA_DIR = os.path.join(os.path.dirname(__file__), "test_data")
 
 
-def test_write_jmp_existence():
-    """Test that the write_jmp function exists"""
-    assert callable(write_jmp)
-
-
-def test_round_trip_basic():
+def test_write_jmp_existence():
+    """Test that the write_jmp function exists"""
+    assert callable(write_jmp)
+
+
+def test_write_jmp_rejects_unsupported_version():
+    """Test that unsupported JMP write versions fail explicitly."""
+    df = pd.DataFrame({"x": [1, 2, 3]})
+
+    with tempfile.NamedTemporaryFile(suffix=".jmp", delete=False) as temp:
+        temp_path = temp.name
+
+    try:
+        with pytest.raises(ValueError, match="only '17.2.0' is currently supported"):
+            write_jmp(df, temp_path, version="16.0")
+    finally:
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+
+
+def test_round_trip_basic():
     """Test writing a simple DataFrame to a JMP file and reading it back"""
     # Create a simple DataFrame
     df = pd.DataFrame(
@@ -43,16 +59,16 @@ def test_round_trip_basic():
         df_read = read_jmp(temp_path)
 
         # Check that the data is the same
-        pd.testing.assert_series_equal(df["integers"], df_read["integers"])
-        pd.testing.assert_series_equal(df["floats"], df_read["floats"])
-        pd.testing.assert_series_equal(df["strings"], df_read["strings"])
+        pd.testing.assert_series_equal(df["integers"], df_read["integers"], check_dtype=False)
+        pd.testing.assert_series_equal(df["floats"], df_read["floats"], check_dtype=False)
+        pd.testing.assert_series_equal(df["strings"], df_read["strings"], check_dtype=False)
     finally:
         # Clean up
         if os.path.exists(temp_path):
             os.unlink(temp_path)
 
 
-def test_round_trip_missing_values():
+def test_round_trip_missing_values():
     """Test writing a DataFrame with missing values to a JMP file and reading it back"""
     # Create a DataFrame with missing values
     df = pd.DataFrame(
@@ -91,8 +107,42 @@ def test_round_trip_missing_values():
         assert df["strings"].iloc[3] == df_read["strings"].iloc[3]
     finally:
         # Clean up
-        if os.path.exists(temp_path):
-            os.unlink(temp_path)
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+
+
+def test_write_jmp17_metadata_and_string_dtype():
+    """Test that writer output has readable JMP 17 metadata and pandas string columns."""
+    df = pd.DataFrame(
+        {
+            "integers": [1, 2, 3],
+            "floats": [1.25, None, 3.5],
+            "strings": pd.Series(["x", "yy", "zzz"], dtype="string"),
+        }
+    )
+
+    with tempfile.NamedTemporaryFile(suffix=".jmp", delete=False) as temp:
+        temp_path = temp.name
+
+    try:
+        write_jmp(df, temp_path)
+
+        with open(temp_path, "rb") as file:
+            info = read_metadata(file)
+
+        assert info.version == "17.2.0"
+        assert info.nrows == 3
+        assert info.ncols == 3
+        assert info.column.names == ["integers", "floats", "strings"]
+
+        df_read = read_jmp(temp_path)
+        assert df_read["integers"].tolist() == [1, 2, 3]
+        assert df_read["floats"].iloc[[0, 2]].tolist() == [1.25, 3.5]
+        assert pd.isna(df_read["floats"].iloc[1])
+        assert df_read["strings"].tolist() == ["x", "yy", "zzz"]
+    finally:
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
 
 
 def test_round_trip_datetime():