refactor: FsstEncodingEncoder reuses PTypeIO.set instead of reimplementing it

The private writeUnsigned helper duplicated core.io.PTypeIO.set, the
canonical narrow-ptype write helper (MethodHandle-based, byte-offset
addressed, already used by every other encoder). Its default branch
throwing VortexException was dead: narrowestUnsigned only ever returns
U8/U16/U32, all of which PTypeIO.set handles with identical
little-endian layout and truncation-on-narrowing. Deleted writeUnsigned
and the now-unused VortexException import; the two call sites now pass
idx * ptype.byteSize() as the byte offset, matching the established
PTypeIO.set idiom.

Also close a round-trip coverage gap this refactor's own risk surface
exposed: every stringArrays() case kept uncompLenPType/codesOffPType in
the U8 tier, so the U16 length/offset write path was only checked via
metadata assertions, never a full decode. Add a 301-row u16-tier case
(one 300-byte row plus 300 single-char rows) that goes through
encode_thenDecode_roundtripsAllStrings, so the U16 buffer bytes are read
back and verified per row -- a wrong U16 stride now corrupts many rows
and fails the assertion. A metadata test pins that both ptypes escalate.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: dfa1

writer/src/main/java/io/github/dfa1/vortex/writer/encode/FsstEncodingEncoder.java

@@ -3,7 +3,7 @@
 import io.github.dfa1.vortex.core.model.DType;
 import io.github.dfa1.vortex.core.model.PType;
 import io.github.dfa1.vortex.core.model.EncodingId;
-import io.github.dfa1.vortex.core.error.VortexException;
+import io.github.dfa1.vortex.core.io.PTypeIO;
 import io.github.dfa1.vortex.core.io.VortexFormat;
 import io.github.dfa1.vortex.core.proto.ProtoFSSTMetadata;
 
@@ -121,17 +121,19 @@ public EncodeResult encode(DType dtype, Object data, EncodeContext ctx) {
         PType uncompLenPType = PType.narrowestUnsigned(maxUncompLen);
         PType codesOffPType = PType.narrowestUnsigned(totalCompressed);
 
-        MemorySegment uncompLenBuf = arena.allocate(Math.max((long) n * uncompLenPType.byteSize(), 1));
+        long uncompLenBytes = uncompLenPType.byteSize();
+        MemorySegment uncompLenBuf = arena.allocate(Math.max((long) n * uncompLenBytes, 1));
         for (int i = 0; i < n; i++) {
-            writeUnsigned(uncompLenBuf, uncompLenPType, i, byteArrays[i].length);
+            PTypeIO.set(uncompLenBuf, i * uncompLenBytes, uncompLenPType, byteArrays[i].length);
         }
 
-        MemorySegment codesOffBuf = arena.allocate((long) (n + 1) * codesOffPType.byteSize());
+        long codesOffBytes = codesOffPType.byteSize();
+        MemorySegment codesOffBuf = arena.allocate((long) (n + 1) * codesOffBytes);
         long off = 0;
-        writeUnsigned(codesOffBuf, codesOffPType, 0, 0);
+        PTypeIO.set(codesOffBuf, 0, codesOffPType, 0);
         for (int i = 0; i < n; i++) {
             off += compressed[i].length;
-            writeUnsigned(codesOffBuf, codesOffPType, i + 1, off);
+            PTypeIO.set(codesOffBuf, (i + 1) * codesOffBytes, codesOffPType, off);
         }
 
         byte[] metaBytes = new ProtoFSSTMetadata(
@@ -152,21 +154,6 @@ public EncodeResult encode(DType dtype, Object data, EncodeContext ctx) {
                 null, null);
     }
 
-    /// Writes `value` into `seg` at row `idx`, using `ptype`'s byte width.
-    ///
-    /// @param seg   destination segment
-    /// @param ptype `U8`, `U16`, or `U32` (whatever [PType#narrowestUnsigned(long)] returned)
-    /// @param idx   row index (not a byte offset)
-    /// @param value the value to write
-    private static void writeUnsigned(MemorySegment seg, PType ptype, long idx, long value) {
-        switch (ptype) {
-            case U8 -> seg.set(ValueLayout.JAVA_BYTE, idx, (byte) value);
-            case U16 -> seg.set(VortexFormat.LE_SHORT, idx * 2, (short) value);
-            case U32 -> seg.set(VortexFormat.LE_INT, idx * 4, (int) value);
-            default -> throw new VortexException(EncodingId.VORTEX_FSST, "unexpected ptype: " + ptype);
-        }
-    }
-
     /// Trains a symbol table by iteratively refining candidate symbols against a bounded sample.
     ///
     /// @param byteArrays the raw byte content of every input string

writer/src/test/java/io/github/dfa1/vortex/writer/encode/FsstEncodingEncoderTest.java

@@ -73,10 +73,34 @@ static Stream<Arguments> stringArrays() {
                     // Non-ASCII multi-byte UTF-8, repeated so symbols can span codepoint boundaries.
                     Arguments.of("utf8-repeated", repeat("café ☕ münchen 日本語テスト", 30)),
                     // Exactly-8-byte symbol repeated: confirms the length-8 boundary encodes/decodes.
-                    Arguments.of("exact-8-byte", repeat("ABCDEFGH", 50))
+                    Arguments.of("exact-8-byte", repeat("ABCDEFGH", 50)),
+                    // U16-tier round-trip: forces both uncompLenPType and codesOffPType off the U8
+                    // fast path so the actual U16 buffer bytes are read back and verified end to end,
+                    // not just the metadata ptype. Row 0 is 300 raw bytes (> 255 -> U16 row lengths);
+                    // the six distinct incompressible rows together compress to > 255 bytes
+                    // (> 255 cumulative codes offset -> U16 offsets). Multiple rows mean a wrong
+                    // U16 stride in the length/offset write path shifts more than one value, so the
+                    // per-index round-trip assertion catches an off-by-stride byte-arithmetic bug.
+                    Arguments.of("u16-tier-multi-row", u16TierRows())
             );
         }
 
+        /// One 300-byte row followed by 300 single-character rows. The long first row pushes the
+        /// maximum raw row length past the U8 range (forcing `U16` uncompressed lengths). Each
+        /// single-character row compresses to exactly one code byte regardless of how training
+        /// ranks symbols, so the cumulative codes-offset total is deterministically at least 300 —
+        /// past the U8 range too (forcing `U16` codes offsets). 301 rows mean a wrong U16 stride in
+        /// either buffer write shifts many values, so the per-index round-trip assertion catches an
+        /// off-by-stride byte-arithmetic bug rather than a lone corrupted row that might slip by.
+        private static String[] u16TierRows() {
+            String[] rows = new String[301];
+            rows[0] = "a".repeat(300);
+            for (int i = 1; i < rows.length; i++) {
+                rows[i] = "x";
+            }
+            return rows;
+        }
+
         private static String[] repeatCycle(String[] cycle, int times) {
             String[] arr = new String[cycle.length * times];
             for (int t = 0; t < times; t++) {
@@ -380,5 +404,36 @@ void encode_metadata_codesOffsetsPType_escalates_pastU8Range() throws Exception
             assertThat(meta.uncompressed_lengths_ptype().value()).isEqualTo(PType.U8.ordinal());
             assertThat(meta.codes_offsets_ptype().value()).isEqualTo(PType.U16.ordinal());
         }
+
+        @Test
+        void encode_metadata_bothPTypes_escalate_forU16RoundtripCase() throws Exception {
+            // Given — the same multi-row data the U16-tier round-trip case uses (Encode
+            // .stringArrays "u16-tier-multi-row"). This pins the precondition that the round-trip
+            // actually exercises the U16 write path for both buffers: if a future change made
+            // either buffer stay in the U8 tier, this fails and the round-trip coverage would
+            // silently no longer cover U16.
+            String[] data = u16TierRowsCopy();
+
+            // When
+            EncodeResult result = ENCODER.encode(DTypes.UTF8, data, EncodeTestHelper.testCtx());
+            var metaSeg = result.rootNode().metadata();
+            ProtoFSSTMetadata meta = ProtoFSSTMetadata.decode(metaSeg, 0, metaSeg.byteSize());
+
+            // Then
+            assertThat(meta.uncompressed_lengths_ptype().value()).isEqualTo(PType.U16.ordinal());
+            assertThat(meta.codes_offsets_ptype().value()).isEqualTo(PType.U16.ordinal());
+        }
+
+        // Mirror of Encode.u16TierRows() — the nested classes cannot share a private static helper
+        // without exposing it, and the intent (deterministic U16-on-both data) is small enough to
+        // restate here next to the assertion that depends on it.
+        private static String[] u16TierRowsCopy() {
+            String[] rows = new String[301];
+            rows[0] = "a".repeat(300);
+            for (int i = 1; i < rows.length; i++) {
+                rows[i] = "x";
+            }
+            return rows;
+        }
     }
 }