@@ -108,6 +108,10 @@ record rather than by the size of the export. A ten-million-record stream costs
 ten-record one. This holds in both wire formats — the envelope is tokenized incrementally
 rather than buffered.
 
+Time scales the same way. A record that spans many body chunks is assembled once, when its
+line ends, so the cost of a record is linear in its own length: doubling the record size
+doubles the work rather than quadrupling it.
+
 The buffering paths, for contrast:
 
 - `iterate()` holds one page. It buffers each page response in full, deserializes it into a
 
@@ -29,6 +29,40 @@ def decode_record_line(line: str) -> dict[str, Any]:
     return record
 
 
+type _SplitResult = tuple[list[str], list[str]]
+
+
+def _split_chunk(pending: list[str], chunk: str, *, at_body_start: bool) -> _SplitResult:
+    """Split one body chunk into the lines it completes.
+
+    The fragments of the line still being assembled are kept as a list and joined once,
+    when a line feed finally ends that line. Accumulating them into one string instead
+    would copy and re-scan the whole partial record on every chunk, making a record that
+    spans many chunks quadratic in its own length.
+
+    Args:
+        pending: Fragments of the line still being assembled, in arrival order; the list
+            is consumed here, so the caller must go on with the one returned.
+        chunk: Next non-empty decoded chunk of the body.
+        at_body_start: Whether this chunk opens the body, and so may carry the one
+            tolerated byte order mark — `pending` is necessarily empty in that case.
+
+    Returns:
+        The lines this chunk completes, without their line endings, and the fragments
+        buffered for the next chunk.
+    """
+    fragment = chunk.removeprefix(UTF8_BOM) if at_body_start else chunk
+    if "\n" not in fragment:
+        pending.append(fragment)
+        return [], pending
+    lines = fragment.split("\n")
+    pending.append(lines[0])
+    lines[0] = "".join(pending)
+    trailing = lines.pop()
+    completed = [line.removesuffix("\r") for line in lines]
+    return completed, ([trailing] if trailing else [])
+
+
 def iter_jsonl_lines(text_chunks: Iterable[str]) -> Iterator[str]:
     """Iterate the lines of a JSONL body, splitting on newlines alone.
 
@@ -49,22 +83,16 @@ def iter_jsonl_lines(text_chunks: Iterable[str]) -> Iterator[str]:
         of a CRLF ending, so a final unterminated line is yielded as-is; a blank line
         is yielded as an empty string, for the caller to skip.
     """
-    pending = ""
+    pending: list[str] = []
     at_body_start = True
     for chunk in text_chunks:
-        if at_body_start and chunk:
-            # `pending` is necessarily empty before the first non-empty chunk, so the
-            # body's first character — the only place a BOM is tolerated — is its start.
-            pending = chunk.removeprefix(UTF8_BOM)
-            at_body_start = False
-        else:
-            pending += chunk
-        lines = pending.split("\n")
-        pending = lines.pop()
-        for line in lines:
-            yield line.removesuffix("\r")
+        if not chunk:
+            continue
+        completed, pending = _split_chunk(pending, chunk, at_body_start=at_body_start)
+        at_body_start = False
+        yield from completed
     if pending:
-        yield pending
+        yield "".join(pending)
 
 
 async def aiter_jsonl_lines(text_chunks: AsyncIterable[str]) -> AsyncIterator[str]:
@@ -87,19 +115,14 @@ async def aiter_jsonl_lines(text_chunks: AsyncIterable[str]) -> AsyncIterator[st
         of a CRLF ending, so a final unterminated line is yielded as-is; a blank line
         is yielded as an empty string, for the caller to skip.
     """
-    pending = ""
+    pending: list[str] = []
     at_body_start = True
     async for chunk in text_chunks:
-        if at_body_start and chunk:
-            # `pending` is necessarily empty before the first non-empty chunk, so the
-            # body's first character — the only place a BOM is tolerated — is its start.
-            pending = chunk.removeprefix(UTF8_BOM)
-            at_body_start = False
-        else:
-            pending += chunk
-        lines = pending.split("\n")
-        pending = lines.pop()
-        for line in lines:
-            yield line.removesuffix("\r")
+        if not chunk:
+            continue
+        completed, pending = _split_chunk(pending, chunk, at_body_start=at_body_start)
+        at_body_start = False
+        for line in completed:
+            yield line
     if pending:
-        yield pending
+        yield "".join(pending)
@@ -1,7 +1,9 @@
 import asyncio
 import json
 import re
+import time
 from pathlib import Path
+from typing import NamedTuple
 
 import pytest
 
@@ -103,6 +105,67 @@ def test_keeps_a_bom_after_the_body_start():
     assert result == ['{"id": 1}', '\ufeff{"id": 2}']
 
 
+LONG_RECORD_CHUNK_SIZE = 8 * 1024
+LONG_RECORD_SIZE = 16 * 1024 * 1024
+# The linear splitter needs a few milliseconds for a 16MB record, while re-splitting the
+# whole buffer on every chunk needed seconds, so this budget is generous on a slow
+# machine and still fails on a return to quadratic behaviour.
+LONG_RECORD_BUDGET_SECONDS = 2
+
+
+@pytest.fixture(scope="module")
+def long_record():
+    # Built on demand rather than at import, so runs that do not select the tests below
+    # do not pay for the 16MB body during collection.
+    return json.dumps({"note": "a" * LONG_RECORD_SIZE})
+
+
+def chunked(body, size=LONG_RECORD_CHUNK_SIZE):
+    offsets = range(0, len(body), size)
+    return [body[offset : offset + size] for offset in offsets]
+
+
+class TimedLines(NamedTuple):
+    lines: list[str]
+    elapsed: float
+
+
+def timed_lines(chunks):
+    started_at = time.perf_counter()
+    lines = list(iter_jsonl_lines(chunks))
+    return TimedLines(lines, time.perf_counter() - started_at)
+
+
+async def collected_lines(chunks):
+    return [line async for line in aiter_jsonl_lines(chunks)]
+
+
+async def timed_async_lines(chunks):
+    started_at = time.perf_counter()
+    lines = await collected_lines(chunks)
+    return TimedLines(lines, time.perf_counter() - started_at)
+
+
+def test_long_record_across_chunks_is_linear(long_record):
+    chunks = chunked(f"{long_record}\n")
+
+    result = timed_lines(chunks)
+
+    assert result.lines == [long_record]
+    assert result.elapsed < LONG_RECORD_BUDGET_SECONDS
+
+
+def test_unterminated_long_record_is_linear(long_record):
+    # The body confirm_stream_format tolerates without a content type: a single long
+    # line, unterminated, so every chunk stays buffered and nothing is flushed early.
+    chunks = chunked(long_record)
+
+    result = timed_lines(chunks)
+
+    assert result.lines == [long_record]
+    assert result.elapsed < LONG_RECORD_BUDGET_SECONDS
+
+
 def test_decode_record_line_returns_the_object():
     result = decode_record_line('{"id": "ID-1"}')
 
@@ -156,6 +219,15 @@ async def test_async_preserves_standalone_trailing_cr():
     assert result == ['{"id": 1}\r']
 
 
+async def test_async_long_record_is_linear(long_record):
+    chunks = async_chunks(chunked(f"{long_record}\n"))
+
+    result = await timed_async_lines(chunks)
+
+    assert result.lines == [long_record]
+    assert result.elapsed < LONG_RECORD_BUDGET_SECONDS
+
+
 async def test_async_drops_a_bom_opening_the_body():
     chunks = async_chunks(['\ufeff{"id": 1}\n{"id": 2}\n'])
 
@@ -164,6 +236,14 @@ async def test_async_drops_a_bom_opening_the_body():
     assert result == ['{"id": 1}', '{"id": 2}']
 
 
+async def test_async_drops_bom_after_empty_chunk():
+    chunks = async_chunks(["", '\ufeff{"id": 1}\n'])
+
+    result = await collected_lines(chunks)
+
+    assert result == ['{"id": 1}']
+
+
 async def test_async_drops_the_bom_in_its_own_chunk():
     chunks = async_chunks(["\ufeff", '{"id": 1}\n'])