Performance: Add FastReader.readUntil() for bulk character reading

- Reads characters into buffer until one of two delimiters is found
- Delimiter character is NOT consumed - remains for next read()
- Optimized for scanning strings (stop at quote or backslash)
- Enables bulk string parsing optimization in json-io JsonParser

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

Author: Claude Opus 4.5

changelog.md

@@ -6,6 +6,10 @@
   * Now compares URLs using `toExternalForm()` for reliable, deterministic comparison
 * **MAINTENANCE**: Migrated test files from deprecated `JsonIo.toObjects()` to `JsonIo.toJava().asClass()` API
   * Updated 8 calls in `CompactMapTest` and `ConverterEverythingTest`
+* **PERFORMANCE**: Added `FastReader.readUntil()` for bulk character reading until delimiter
+  * Reads characters into destination buffer until one of two delimiters is found
+  * Delimiter character is left unconsumed for subsequent read
+  * Enables bulk string parsing optimization in json-io's JsonParser
 
 #### 4.89.0 - 2026-01-31
 * **PERFORMANCE**: `FastReader.getLastSnippet()` now returns bounded 200-char context

src/main/java/com/cedarsoftware/util/FastReader.java

@@ -148,6 +148,61 @@ public int read(char[] cbuf, int off, int len) {
         return charsRead;
     }
 
+    /**
+     * Reads characters into the destination array until one of the two delimiter characters is found.
+     * The delimiter character is NOT consumed - it remains available for the next read() call.
+     * This method is optimized for scanning strings where we want to read until we hit a quote or backslash.
+     *
+     * @param dest the destination buffer to read characters into
+     * @param off the offset in the destination buffer to start writing
+     * @param maxLen the maximum number of characters to read
+     * @param delim1 first delimiter character to stop at (typically quote char)
+     * @param delim2 second delimiter character to stop at (typically backslash)
+     * @return the number of characters read (not including delimiter), or -1 if EOF reached before any chars read
+     */
+    public int readUntil(char[] dest, int off, int maxLen, char delim1, char delim2) {
+        if (in == null) {
+            ExceptionUtilities.uncheckedThrow(new IOException("in is null"));
+        }
+
+        int totalRead = 0;
+
+        // First, drain any pushback buffer
+        while (pushbackPosition < pushbackBufferSize && totalRead < maxLen) {
+            char c = pushbackBuffer[pushbackPosition];
+            if (c == delim1 || c == delim2) {
+                // Found delimiter in pushback - don't consume it
+                return totalRead > 0 ? totalRead : 0;
+            }
+            dest[off++] = c;
+            pushbackPosition++;
+            totalRead++;
+        }
+
+        // Now read from main buffer
+        while (totalRead < maxLen) {
+            fill();
+            if (limit == -1) {
+                // EOF reached
+                return totalRead > 0 ? totalRead : -1;
+            }
+
+            // Scan current buffer for delimiters
+            while (position < limit && totalRead < maxLen) {
+                char c = buf[position];
+                if (c == delim1 || c == delim2) {
+                    // Found delimiter - don't consume it
+                    return totalRead;
+                }
+                dest[off++] = c;
+                position++;
+                totalRead++;
+            }
+        }
+
+        return totalRead;
+    }
+
     @Override
     public void close() {
         if (in != null) {