@@ -45,6 +45,12 @@ jobs:
           enable-cache: true
           python-version: ${{ matrix.python-version }}
 
+      - name: Lockfile is in sync with pyproject
+        # A stale uv.lock means CI tests a different dependency set than a
+        # fresh `uv sync` would install (the lock had recorded the project
+        # itself at 1.0.0 against a 1.1.0 pyproject). Fail early instead.
+        run: uv lock --check
+
       - name: Sync environment (numpy + dev group, editable install)
         run: uv sync
 
@@ -66,6 +72,19 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      - name: Tracked text files are LF in the index
+        # .gitattributes declares LF; this holds the line. `git ls-files
+        # --eol` reports the INDEX encoding, independent of the runner's OS.
+        working-directory: .
+        run: |
+          bad=$(git ls-files --eol | grep -E '^i/(crlf|mixed)' || true)
+          if [ -n "$bad" ]; then
+            echo "::error::tracked files with CRLF/mixed line endings in the index:"
+            echo "$bad"
+            exit 1
+          fi
+          echo "index is LF-clean ($(git ls-files --eol | grep -c '^i/lf') text files)"
+
       - name: Install uv
         uses: astral-sh/setup-uv@v5
         with:
 
@@ -10,6 +10,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 Work on the current development branch. Entries move to a versioned section on
 release.
 
+### Fixed
+- `PersistentReceiver.blocks()` could swap I and Q for the rest of a stream.
+  A pipe may return fewer bytes than `read1()` asked for, so a raw chunk can
+  end mid-pair; `blocks()` handed each chunk straight to `decode_iq`, which
+  drops an odd trailing byte, and from that point every sample's I and Q
+  were exchanged -- power statistics stay healthy while the phase is
+  garbage. `capture()`'s stream path already carried the odd byte forward;
+  `blocks()` now does the same, through the carry buffer `read()` uses, so
+  the two can be mixed on one receiver. Two regression tests feed odd-sized
+  chunks directly and check the decoded ramp byte-for-byte. Anything that
+  streamed through `open_receiver().blocks()` (the `waterfall_persistent` and
+  `persistent_capture` examples, downstream `IQSource` adapters) is affected.
+
 ## [1.1.0] - 2026-09-19
 
 Hardening-and-verification release: process lifecycle, cross-platform
 
@@ -173,17 +173,22 @@ def blocks(self) -> Iterator[np.ndarray]:
         # Yield decoded complex64 blocks as they arrive (raw cadence), until
         # the stream ends or the caller stops iterating. Good for a continuous
         # consumer that doesn't need a fixed sample count per read.
+        # An odd-length chunk splits an I/Q pair across two reads. decode_iq
+        # DROPS an odd trailing byte, and dropping one byte here would swap
+        # I and Q for every sample that follows (capture()'s stream path
+        # carries the byte for exactly this reason). The read1() cap in
+        # _run is even, but a pipe is free to return fewer bytes than
+        # asked, so the odd case is real. Carry the byte in self._carry,
+        # the same buffer read() uses, so blocks() and read() can be mixed.
         gen = self._ensure_open()
-        if self._carry:
-            lead = self._h.decode_iq(self._carry)
-            self._carry = b""
-            if len(lead):
-                self.total_samples += len(lead)
-                yield lead
         for chunk in gen:
-            iq = self._h.decode_iq(chunk)
-            self.total_samples += len(iq)
-            yield iq
+            buf = self._carry + chunk
+            cut = len(buf) - (len(buf) % 2)
+            self._carry = buf[cut:]
+            if cut:
+                iq = self._h.decode_iq(buf[:cut])
+                self.total_samples += len(iq)
+                yield iq
 
     def callback(self, on_block: Callable[[np.ndarray, int], Any], *,
                  max_samples: int | None = None) -> int:
 
@@ -69,6 +69,7 @@ def fixtures_dir():
 IDLE = {idle!r}
 EXIT_CODE = {exit_code!r}
 EMIT_BYTES = {emit_bytes!r}
+EMIT_CHUNK_SIZES = {emit_chunk_sizes!r}
 TAIL_ON_INTERRUPT = {tail_on_interrupt!r}
 IGNORE_INTERRUPT = {ignore_interrupt!r}
 BUSY_FAILS = {busy_fails!r}
@@ -131,8 +132,17 @@ def _on_signal(signum, frame):
     sys.stderr.flush()
 
 if EMIT_BYTES:
-    sys.stdout.buffer.write(bytes(EMIT_BYTES))
-    sys.stdout.buffer.flush()
+    if EMIT_CHUNK_SIZES:
+        # write + flush in the given piece sizes (cycled), so the parent's
+        # read1() can observe a pipe boundary inside an I/Q pair
+        _raw, _pos, _k = bytes(EMIT_BYTES), 0, 0
+        while _pos < len(_raw):
+            _n = EMIT_CHUNK_SIZES[_k % len(EMIT_CHUNK_SIZES)]; _k += 1
+            sys.stdout.buffer.write(_raw[_pos:_pos + _n]); _pos += _n
+            sys.stdout.buffer.flush()
+    else:
+        sys.stdout.buffer.write(bytes(EMIT_BYTES))
+        sys.stdout.buffer.flush()
 
 for line in STDOUT_LINES:
     sys.stdout.write(line + "\\n")
@@ -163,13 +173,15 @@ def _on_signal(signum, frame):
 def _write_stub(tools_dir, name, *, stdout_lines=(), stderr_lines=(),
                 stderr_flood=0, idle=False, exit_code=0, marker=None,
                 emit_bytes=None, tail_on_interrupt=None,
-                ignore_interrupt=False, busy_fails=0, stdout_flood=0):
+                ignore_interrupt=False, busy_fails=0, stdout_flood=0,
+                emit_chunk_sizes=None):
     py_path = os.path.join(tools_dir, name + ".py")
     body = _STUB_TEMPLATE.format(
         marker=marker, stdout_lines=list(stdout_lines),
         stderr_lines=list(stderr_lines), stderr_flood=stderr_flood,
         idle=idle, exit_code=exit_code,
         emit_bytes=list(emit_bytes) if emit_bytes else None,
+        emit_chunk_sizes=list(emit_chunk_sizes) if emit_chunk_sizes else None,
         tail_on_interrupt=tail_on_interrupt,
         ignore_interrupt=ignore_interrupt, busy_fails=busy_fails,
         stdout_flood=stdout_flood)
 
@@ -134,3 +134,94 @@ def test_read_after_close_raises_typed_error(stub_device):
     recv.close()
     with pytest.raises(HackRFDeviceError, match="closed"):
         recv.read(16)
+
+
+# ---------------------------------------------------------------------------
+# Odd-length chunks must not swap I and Q.
+#
+# A pipe is free to return fewer bytes than read1() asked for, so a raw chunk
+# can end in the middle of an I/Q pair. decode_iq drops an odd trailing byte;
+# if blocks() handed it such a chunk directly, that one dropped byte would
+# swap I and Q for every sample afterwards -- a capture whose power stats look
+# healthy while the phase is garbage. capture()'s own stream path carries the
+# odd byte forward; blocks() did not. These pin the carry on blocks(), and that
+# read() and blocks() share one carry so they can be mixed.
+# ---------------------------------------------------------------------------
+
+def _odd_chunk_receiver(stub_device, chunks):
+    """A PersistentReceiver whose raw stream is exactly `chunks`."""
+    h = _streaming_device(stub_device, nbytes=16)
+    rx = h.open_receiver(100e6, 8e6)
+    rx._gen = iter(chunks)            # bypass the child; feed raw bytes directly
+    rx._ensure_open = lambda: rx._gen
+    return rx
+
+
+def test_blocks_carries_odd_byte_instead_of_swapping_iq(stub_device):
+    # ramp: I = 0,2,4,..  Q = 1,3,5,..  so a correct decode has I even, Q odd
+    n = 1000
+    raw = bytes(i % 256 for i in range(2 * n))
+    # split into deliberately odd-sized chunks (7, 13, 1, 3, ...)
+    sizes = [7, 13, 1, 3, 101, 9]
+    chunks, pos = [], 0
+    while pos < len(raw):
+        for s in sizes:
+            chunks.append(raw[pos:pos + s])
+            pos += s
+            if pos >= len(raw):
+                break
+    chunks = [c for c in chunks if c]
+    assert any(len(c) % 2 for c in chunks), "test needs odd chunks"
+
+    rx = _odd_chunk_receiver(stub_device, chunks)
+    got = np.concatenate(list(rx.blocks()))
+    assert len(got) == n
+    # decode_iq divides by 128 -> undo to compare against the raw ramp
+    i = np.rint(got.real * 128).astype(int) % 256
+    q = np.rint(got.imag * 128).astype(int) % 256
+    expect = np.arange(2 * n) % 256
+    # int8 wraps at 128, so compare modulo 256 on the signed values
+    assert np.array_equal(i % 256, expect[0::2])
+    assert np.array_equal(q % 256, expect[1::2])
+    assert rx.total_samples == n
+
+
+def test_blocks_and_read_share_one_carry(stub_device):
+    n = 64
+    raw = bytes(i % 256 for i in range(2 * n))
+    # first chunk odd, so blocks() leaves one byte in the carry; then read()
+    # must pick it up and stay pair-aligned.
+    chunks = [raw[:5], raw[5:40], raw[40:]]
+    rx = _odd_chunk_receiver(stub_device, chunks)
+    gen = rx.blocks()
+    first = next(gen)                  # consumes raw[:5] -> 2 samples, 1 byte carried
+    assert len(first) == 2
+    assert rx._carry == raw[4:5]
+    rest = rx.read(n - 2)
+    got = np.concatenate([first, rest])
+    assert len(got) == n
+    i = np.rint(got.real * 128).astype(int) % 256
+    assert np.array_equal(i, (np.arange(2 * n) % 256)[0::2])
+
+
+def test_blocks_through_a_real_pipe_with_odd_writes(stub_device):
+    """Same contract, but the odd boundaries come from an actual child process
+    writing and flushing odd-sized pieces into the stdout pipe -- the path a
+    downstream IQSource adapter (sdr_dsp's HackRFCapture) streams through.
+    On the pre-fix code this swapped I and Q from the first odd piece on."""
+    n = 200_000
+    raw = bytes(i % 256 for i in range(2 * n))
+    h = stub_device(transfer=dict(emit_bytes=raw, idle=False,
+                                  emit_chunk_sizes=[7, 65537, 3, 131071, 1]))
+    got = []
+    with h.open_receiver(100e6, 8e6) as rx:
+        for blk in rx.blocks():
+            got.append(blk)
+            if sum(len(g) for g in got) >= n:
+                break
+    x = np.concatenate(got)[:n]
+    i = np.rint(x.real * 128).astype(int) % 256
+    q = np.rint(x.imag * 128).astype(int) % 256
+    expect = np.arange(2 * n) % 256
+    assert np.array_equal(i, expect[0::2])
+    assert np.array_equal(q, expect[1::2])