refactor(inspect): dedup formatBytes into shared ByteSize util

formatBytes was copy-pasted four times (VortexInspector, ExportCommand,
ImportCommand, InspectorRender). Extract one public ByteSize.format(long)
in the inspector module (cli already depends on it) and repoint every call
site; add Locale.ROOT so the decimal separator is stable. Covered by a
parameterized ByteSizeTest across the B/KB/MB boundaries (the obsolete
InspectorRender.formatBytes test is removed).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dfa1

cli/src/main/java/io/github/dfa1/vortex/cli/ExportCommand.java

@@ -1,6 +1,7 @@
 package io.github.dfa1.vortex.cli;
 
 import io.github.dfa1.vortex.csv.CsvExporter;
+import io.github.dfa1.vortex.inspect.ByteSize;
 import io.github.dfa1.vortex.csv.ExportOptions;
 
 import java.io.IOException;
@@ -63,17 +64,7 @@ private static void printResult(Path inputPath, Path outputPath) throws IOExcept
         long inputBytes = Files.size(inputPath);
         long outputBytes = Files.size(outputPath);
         System.out.printf("written: %s  (%s → %s)%n",
-                outputPath, formatBytes(inputBytes), formatBytes(outputBytes));
-    }
-
-    private static String formatBytes(long bytes) {
-        if (bytes < 1024L) {
-            return bytes + " B";
-        }
-        if (bytes < 1024L * 1024) {
-            return String.format("%.1f KB", bytes / 1024.0);
-        }
-        return String.format("%.1f MB", bytes / (1024.0 * 1024));
+                outputPath, ByteSize.format(inputBytes), ByteSize.format(outputBytes));
     }
 
     private static void renderProgress(long done, long total) {

cli/src/main/java/io/github/dfa1/vortex/cli/ImportCommand.java

@@ -1,6 +1,7 @@
 package io.github.dfa1.vortex.cli;
 
 import io.github.dfa1.vortex.csv.CsvImporter;
+import io.github.dfa1.vortex.inspect.ByteSize;
 import io.github.dfa1.vortex.csv.ImportOptions;
 import io.github.dfa1.vortex.parquet.ParquetImporter;
 
@@ -109,7 +110,7 @@ private static void printResult(Path inputPath, Path vortexPath, int cascadingDe
                                        ? String.format(", cascading depth %d", cascadingDepth)
                                        : "";
         System.out.printf("written: %s  (%s → %s, %s%s)%n",
-                vortexPath, formatBytes(inputBytes), formatBytes(vortexBytes),
+                vortexPath, ByteSize.format(inputBytes), ByteSize.format(vortexBytes),
                 sizeChange, cascadingInfo);
     }
 
@@ -130,16 +131,6 @@ private static void clearProgress() {
         System.err.flush();
     }
 
-    private static String formatBytes(long bytes) {
-        if (bytes < 1024L) {
-            return bytes + " B";
-        }
-        if (bytes < 1024L * 1024) {
-            return String.format("%.1f KB", bytes / 1024.0);
-        }
-        return String.format("%.1f MB", bytes / (1024.0 * 1024));
-    }
-
     private static Path deriveOutputPath(Path inputPath) {
         String name = inputPath.getFileName().toString();
         if (name.endsWith(".csv")) {

cli/src/main/java/io/github/dfa1/vortex/cli/tui/InspectorRender.java

@@ -174,20 +174,6 @@ static String formatHexRow(byte[] data, int offset) {
         return sb.toString();
     }
 
-    /// Formats a byte count as B / KB / MB.
-    ///
-    /// @param bytes raw byte count
-    /// @return human-readable size string
-    static String formatBytes(long bytes) {
-        if (bytes < 1024) {
-            return bytes + " B";
-        }
-        if (bytes < 1024 * 1024) {
-            return String.format("%.1f KB", bytes / 1024.0);
-        }
-        return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
-    }
-
     /// Pads or truncates `s` to exactly `width` characters.
     ///
     /// @param s     source string

cli/src/main/java/io/github/dfa1/vortex/cli/tui/VortexInspectorTui.java

@@ -7,6 +7,7 @@
 import io.github.dfa1.vortex.cli.tui.term.Ansi;
 import io.github.dfa1.vortex.cli.tui.term.Key;
 import io.github.dfa1.vortex.cli.tui.term.Terminal;
+import io.github.dfa1.vortex.inspect.ByteSize;
 import io.github.dfa1.vortex.inspect.InspectorTree;
 import io.github.dfa1.vortex.inspect.ZonedStatsSchema;
 import io.github.dfa1.vortex.reader.VortexHandle;
@@ -391,10 +392,10 @@ private void drawStatus(StringBuilder buf, int width, int row) {
 
         private void drawHeader(StringBuilder buf, int width) {
             String header = " vortex-inspect — v" + tree.version()
-                    + "  " + InspectorRender.formatBytes(tree.fileSize())
+                    + "  " + ByteSize.format(tree.fileSize())
                     + "  rows=" + tree.totalRowCount()
                     + "  segs=" + tree.segmentCount()
-                    + " (" + InspectorRender.formatBytes(tree.totalSegmentBytes()) + ")";
+                    + " (" + ByteSize.format(tree.totalSegmentBytes()) + ")";
             buf.append(Ansi.moveTo(1, 1));
             buf.append(Ansi.bg(46)).append(Ansi.fg(30));
             buf.append(InspectorRender.pad(header, width));
@@ -479,15 +480,15 @@ private List<String> detailLines(InspectorTree.Node node) {
                     subtotal += tree.segmentSpecs().get(idx).length();
                 }
                 lines.add("Segments:  " + layout.segments().size()
-                        + " (" + InspectorRender.formatBytes(subtotal) + ")");
+                        + " (" + ByteSize.format(subtotal) + ")");
                 long rows = layout.rowCount();
                 for (int idx : layout.segments()) {
                     SegmentSpec spec = tree.segmentSpecs().get(idx);
                     String bits = rows > 0
                             ? "  bits/elem=" + String.format("%.2f", spec.length() * 8.0 / rows)
                             : "";
                     lines.add("  [" + idx + "] off=" + spec.offset()
-                            + "  len=" + InspectorRender.formatBytes(spec.length())
+                            + "  len=" + ByteSize.format(spec.length())
                             + "  compression=" + spec.compression().name()
                             + bits);
                 }
@@ -559,7 +560,7 @@ private List<String> detailLines(InspectorTree.Node node) {
                     int segIdx = layout.segments().getFirst();
                     SegmentSpec spec = tree.segmentSpecs().get(segIdx);
                     lines.add("Hex (first " + preview.length + " B of segment "
-                            + segIdx + ", total " + InspectorRender.formatBytes(spec.length()) + "):");
+                            + segIdx + ", total " + ByteSize.format(spec.length()) + "):");
                     for (int off = 0; off < preview.length; off += 16) {
                         lines.add(InspectorRender.formatHexRow(preview, off));
                     }

cli/src/test/java/io/github/dfa1/vortex/cli/tui/InspectorRenderTest.java

@@ -250,18 +250,6 @@ void padsShortTrailingRowAndDotsNonPrintable() {
         }
     }
 
-    @Nested
-    class FormatBytes {
-
-        @Test
-        void formatsAcrossUnitBoundaries() {
-            // Given / When / Then — B / KB / MB thresholds
-            assertThat(InspectorRender.formatBytes(512)).isEqualTo("512 B");
-            assertThat(InspectorRender.formatBytes(2048)).isEqualTo("2.0 KB");
-            assertThat(InspectorRender.formatBytes(3 * 1024 * 1024)).isEqualTo("3.0 MB");
-        }
-    }
-
     @Nested
     class PadAndTruncate {
 

inspector/src/main/java/io/github/dfa1/vortex/inspect/ByteSize.java

@@ -0,0 +1,29 @@
+package io.github.dfa1.vortex.inspect;
+
+import java.util.Locale;
+
+/// Formats a byte count as a short human-readable string using binary (1024-based) units.
+public final class ByteSize {
+
+    private static final long KIB = 1024L;
+    private static final long MIB = KIB * KIB;
+
+    private ByteSize() {
+    }
+
+    /// Formats `bytes` as `B` below 1 KiB, `KB` below 1 MiB, otherwise `MB`, with one decimal
+    /// place for the KB/MB forms. Uses [Locale#ROOT] so the decimal separator is stable regardless
+    /// of the default locale.
+    ///
+    /// @param bytes the byte count
+    /// @return a human-readable size such as `512 B`, `1.5 KB`, or `2.0 MB`
+    public static String format(long bytes) {
+        if (bytes < KIB) {
+            return bytes + " B";
+        }
+        if (bytes < MIB) {
+            return String.format(Locale.ROOT, "%.1f KB", bytes / (double) KIB);
+        }
+        return String.format(Locale.ROOT, "%.1f MB", bytes / (double) MIB);
+    }
+}

inspector/src/main/java/io/github/dfa1/vortex/inspect/VortexInspector.java

@@ -30,7 +30,7 @@ public static String render(InspectorTree tree) {
         var sb = new StringBuilder();
 
         sb.append("Vortex v").append(tree.version())
-                .append("  ").append(formatBytes(tree.fileSize()))
+                .append("  ").append(ByteSize.format(tree.fileSize()))
                 .append("  ").append(tree.totalRowCount()).append(" rows").append('\n');
         sb.append('\n');
 
@@ -45,7 +45,7 @@ public static String render(InspectorTree tree) {
         sb.append('\n');
 
         sb.append("Segments: ").append(tree.segmentCount())
-                .append("  total ").append(formatBytes(tree.totalSegmentBytes())).append('\n');
+                .append("  total ").append(ByteSize.format(tree.totalSegmentBytes())).append('\n');
         appendSegmentTable(sb, tree.segmentSpecs(), "  ");
         sb.append('\n');
 
@@ -60,7 +60,7 @@ private static void appendSegmentTable(StringBuilder sb, List<SegmentSpec> specs
             SegmentSpec spec = specs.get(i);
             sb.append(indent).append('[').append(i).append("] ")
                     .append("off=").append(spec.offset())
-                    .append("  len=").append(formatBytes(spec.length()))
+                    .append("  len=").append(ByteSize.format(spec.length()))
                     .append("  compression=").append(spec.compression().name())
                     .append('\n');
         }
@@ -190,14 +190,4 @@ private static String formatDType(DType dtype) {
             case DType.Variant(var nullable) -> "variant" + (nullable ? "?" : "");
         };
     }
-
-    private static String formatBytes(long bytes) {
-        if (bytes < 1024) {
-            return bytes + " B";
-        }
-        if (bytes < 1024 * 1024) {
-            return String.format("%.1f KB", bytes / 1024.0);
-        }
-        return String.format("%.1f MB", bytes / (1024.0 * 1024.0));
-    }
 }

inspector/src/test/java/io/github/dfa1/vortex/inspect/ByteSizeTest.java

@@ -0,0 +1,32 @@
+package io.github.dfa1.vortex.inspect;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class ByteSizeTest {
+
+    @ParameterizedTest
+    @CsvSource({
+            // bytes,            expected
+            "0,                  0 B",
+            "1,                  1 B",
+            "1023,               1023 B",     // last value below the KB boundary
+            "1024,               1.0 KB",     // first KB
+            "1536,               1.5 KB",     // one-decimal rounding
+            "1048575,            1024.0 KB",  // last value below the MB boundary
+            "1048576,            1.0 MB",     // first MB
+            "1572864,            1.5 MB",
+            "5242880,            5.0 MB",
+    })
+    void format_rendersBinaryUnits(long bytes, String expected) {
+        // Given a byte count
+
+        // When
+        String result = ByteSize.format(bytes);
+
+        // Then it picks B / KB / MB with one decimal for the scaled forms
+        assertThat(result).isEqualTo(expected);
+    }
+}