mef3io 2.2.0__tar.gz → 2.3.0__tar.gz

{mef3io-2.2.0 → mef3io-2.3.0}/.github/workflows/release.yml

@@ -137,9 +137,10 @@ jobs:
   # files from the site.
   coverage:
     # Releases only (not branch dry runs); at -O0 with atomic counters this
-    # takes a while.
+    # takes a while: about 70 minutes at 2.2.0 (it ran out at 88% under a
+    # 60-minute limit), so the limit leaves room to grow.
     if: startsWith(github.ref, 'refs/tags/')
-    timeout-minutes: 60
+    timeout-minutes: 150
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4

{mef3io-2.2.0 → mef3io-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mef3io
-Version: 2.2.0
+Version: 2.3.0
 Summary: Read, write, de-identify, cut and merge MEF 3.0 (Multiscale Electrophysiology Format) recordings: EEG, iEEG, ECG and other regularly sampled signals, from Python, MATLAB and C++
 Keywords: MEF,MEF3,MEF 3.0,Multiscale Electrophysiology Format,EEG,iEEG,SEEG,ECoG,ECG,biosignals,electrophysiology,neuroscience,anonymization,de-identification,merge,meflib,pymef
 Author: Filip Mivalt
@@ -418,7 +418,8 @@ pages such as
   different amplifiers. One call can also trim each recording to its own
   time range, make the result anonymous and use several threads
   (`n_threads=`). Overlapping data is refused before anything is written, and
-  the result is checked against every source. See
+  the result is checked against every source. Different units or conversion
+  factors in one channel are merged with a warning, not refused. See
   [Merging recordings](https://bnelair.github.io/mef3io/merge/).
   To read several recordings as one without writing anything,
   `mef3io.MultiReader([...])` is a drop-in for `Reader` (Python).

{mef3io-2.2.0 → mef3io-2.3.0}/README.md

@@ -167,7 +167,8 @@ pages such as
   different amplifiers. One call can also trim each recording to its own
   time range, make the result anonymous and use several threads
   (`n_threads=`). Overlapping data is refused before anything is written, and
-  the result is checked against every source. See
+  the result is checked against every source. Different units or conversion
+  factors in one channel are merged with a warning, not refused. See
   [Merging recordings](https://bnelair.github.io/mef3io/merge/).
   To read several recordings as one without writing anything,
   `mef3io.MultiReader([...])` is a drop-in for `Reader` (Python).

mef3io-2.3.0/VERSION

@@ -0,0 +1 @@
+2.3.0

{mef3io-2.2.0 → mef3io-2.3.0}/bindings/python/mef3io_ext.cpp

@@ -1207,6 +1207,11 @@ NB_MODULE(_mef3io, m) {
         out["metadata_fields_changed"] = r.metadata_fields_changed;
         out["sources"] = r.sources;
         out["segments_split"] = r.segments_split;
+        {
+          nb::dict um;
+          for (const auto& [ch, us] : r.units_mixed) um[nb::str(ch.c_str())] = us;
+          out["units_mixed"] = um;
+        }
         out["pseudonym"] = r.pseudonym;
         out["shift_us"] = opt_or_none(r.shift_us);
         out["source_recording_time_offset"] = r.source_recording_time_offset;

{mef3io-2.2.0 → mef3io-2.3.0}/core/CMakeLists.txt

@@ -26,6 +26,10 @@ target_link_libraries(mef3io_core PUBLIC Threads::Threads)
 
 if(MSVC)
   target_compile_options(mef3io_core PRIVATE /W4 /permissive-)
+  # Sources are UTF-8. Without /utf-8 MSVC stores a "\u00B5"-style escape in
+  # the ANSI code page (one byte 0xB5), which Python then cannot decode.
+  # PUBLIC, so the bindings and tests that use these headers compile alike.
+  target_compile_options(mef3io_core PUBLIC /utf-8)
 else()
   target_compile_options(mef3io_core PRIVATE -Wall -Wextra)
 endif()

{mef3io-2.2.0 → mef3io-2.3.0}/core/include/mef3io/inspect.hpp

@@ -92,6 +92,11 @@ struct InspectChannel {
   /// (#150; each segment's is in InspectSegment::units_conversion_factor).
   std::optional<sf8> sampling_frequency, units_conversion_factor;
   std::optional<std::string> units_description;
+  /// Every DISTINCT units string the readable segments declare, in order of
+  /// first appearance (as stored; "uV", "\u00B5V" and "\u03BCV" count as one).
+  /// More than one = the channel's segments disagree (validator `units.mixed`).
+  /// C++ only: not in the Python summary.
+  std::vector<std::string> units_all;
   /// Section 2's free-text channel description, as the first segment whose
   /// section 2 is readable states it (segments can differ; the identity
   /// table lists every distinct value). An IDENTITY value, so it is returned

{mef3io-2.2.0 → mef3io-2.3.0}/core/include/mef3io/merge.hpp

@@ -13,6 +13,7 @@
 
 #include <atomic>
 #include <cstddef>
+#include <map>
 #include <optional>
 #include <string>
 #include <utility>
@@ -84,6 +85,10 @@ struct MergeReport : TransformReport {
   si8 source_recording_time_offset = 0;
   si8 record_text_fields_changed = 0;
   si8 record_bodies_cleared = 0;
+  /// Channels whose KEPT segments carry different units strings (free text,
+  /// never a refusal): channel -> the distinct strings as stored, in order.
+  /// Segments keep their own strings; the channel label is the first kept one's.
+  std::map<std::string, std::vector<std::string>> units_mixed;
   /// anonymize only. THE RE-IDENTIFICATION KEY over all sources (earliest
   /// start, latest end, and per kept channel): in memory only, as in
   /// AnonymizeReport.

{mef3io-2.2.0 → mef3io-2.3.0}/core/include/mef3io/metadata.hpp

@@ -62,4 +62,26 @@ TimeSeriesMetadata load_time_series_metadata(std::span<const ui1> tmet_bytes,
 TimeSeriesMetadata load_time_series_metadata_partial(std::span<const ui1> tmet_bytes,
                                                      const std::string& password = "");
 
+/// Units strings are free text. Two of them are the same unit when they are
+/// equal after mapping the micro prefix (U+00B5 MICRO SIGN, U+03BC GREEK SMALL
+/// LETTER MU, as UTF-8) to ASCII "u": "uV", "\u00B5V" and "\u03BCV" agree.
+/// Nothing else is folded. Used only to decide whether units MIX.
+inline std::string units_comparable(const std::string& s) {
+  std::string out;
+  out.reserve(s.size());
+  for (std::size_t i = 0; i < s.size(); ++i) {
+    const unsigned char c = static_cast<unsigned char>(s[i]);
+    if (i + 1 < s.size()) {
+      const unsigned char d = static_cast<unsigned char>(s[i + 1]);
+      if ((c == 0xC2 && d == 0xB5) || (c == 0xCE && d == 0xBC)) {
+        out += 'u';
+        ++i;
+        continue;
+      }
+    }
+    out += s[i];
+  }
+  return out;
+}
+
 }  // namespace mef3io

{mef3io-2.2.0 → mef3io-2.3.0}/core/include/mef3io/source.hpp

@@ -3,6 +3,8 @@
 /// uncompressed .mefd.tar archive (random access into member byte ranges).
 #pragma once
 
+#include <atomic>
+#include <cstddef>
 #include <cstdint>
 #include <filesystem>
 #include <memory>
@@ -82,6 +84,8 @@ class DirectorySource : public SessionSource {
 
  private:
   std::string join(const std::string& rel) const;
+  std::shared_ptr<const std::vector<ui1>> memo_get(const std::string& path, const std::string& rel,
+                                                   bool fill) const;
   std::string root_;
   std::shared_ptr<detail::HandleCache> cache_;  // null = plain reads
 };
@@ -136,6 +140,18 @@ class ReadHandleScope {
 /// opened at most N times in a merge".
 inline void (*source_open_observer)(const std::string& path) = nullptr;
 
+/// TEST HOOK: called with the path of every positional read a DirectorySource
+/// really issues (a request on a network drive; memo hits do not count).
+inline void (*source_read_observer)(const std::string& path) = nullptr;
+
+/// TEST HOOK: total bytes of positional reads a DirectorySource really issued
+/// (memo hits do not count). Tests reset it to 0 and compare.
+inline std::atomic<std::uint64_t> source_read_bytes{0};
+
+/// Budget of the small-file memo (a HandleCache holds at most this many bytes
+/// of .tmet/.tidx/.ridx contents). A variable only so a test can lower it.
+inline std::size_t memo_total_budget = 256u << 20;
+
 /// TEST HOOK: called before each positional read through a cached handle;
 /// a non-zero return is raised as that errno (POSIX) in place of the read.
 inline int (*read_fault_hook)(const std::string& path) = nullptr;

{mef3io-2.2.0 → mef3io-2.3.0}/core/src/inspect.cpp

@@ -478,6 +478,10 @@ SessionSummary detail::inspect_session_through(std::shared_ptr<const SessionSour
                                                  md.section2.units_conversion_factor)) {
           factor_differs = true;  // #150: segments store different factors
         }
+        if (std::none_of(ic.units_all.begin(), ic.units_all.end(), [&](const std::string& u) {
+              return units_comparable(u) == units_comparable(md.section2.units_description);
+            }))
+          ic.units_all.push_back(md.section2.units_description);
         // File-derived: a negative count is nonsense, and the sum must not overflow.
         if (md.section2.number_of_samples < 0)
           n_samples_known = false;

{mef3io-2.2.0 → mef3io-2.3.0}/core/src/session_copy.cpp

@@ -1079,6 +1079,8 @@ si8 longest_block_us(const fmt::TimeSeriesMetadataSection2& m) {
   return static_cast<si8>(std::llround(n * 1e6 / m.sampling_frequency)) + 1'000'000;
 }
 
+constexpr std::size_t WHOLE_INDEX_BYTES = 512 * 1024;
+
 /// The index entries [first, last) of a segment a cut [t0, t1) must look at,
 /// found by binary search on the index's start times (O(log n) small reads:
 /// never the whole index, never the data): from two blocks before the first
@@ -1095,7 +1097,15 @@ std::pair<std::size_t, std::size_t> window_entries(const SessionSource& src,
   if (size < fmt::UNIVERSAL_HEADER_BYTES) return {0, 0};
   const std::size_t n =
       static_cast<std::size_t>((size - fmt::UNIVERSAL_HEADER_BYTES) / fmt::TIME_SERIES_INDEX_BYTES);
+  // A small index (<= WHOLE_INDEX_BYTES, ~9k blocks) is read in ONE request
+  // and searched in memory: on a network drive each of the ~15 probes of a
+  // binary search is a round trip, dearer than the few KB they save.
+  std::vector<ui1> whole;
+  if (n * fmt::TIME_SERIES_INDEX_BYTES <= WHOLE_INDEX_BYTES)
+    whole = src.read_range(tidx_rel, fmt::UNIVERSAL_HEADER_BYTES, n * fmt::TIME_SERIES_INDEX_BYTES);
   auto time_at = [&](std::size_t i) {
+    if (!whole.empty())
+      return to_user_time(read<si8>(whole, i * fmt::TIME_SERIES_INDEX_BYTES + 8), rto);
     const auto b = src.read_range(
         tidx_rel, fmt::UNIVERSAL_HEADER_BYTES + i * fmt::TIME_SERIES_INDEX_BYTES + 8, 8);
     return to_user_time(read<si8>(b, 0), rto);
@@ -1115,6 +1125,91 @@ std::pair<std::size_t, std::size_t> window_entries(const SessionSource& src,
   return {a >= 2 ? a - 2 : 0, std::min(n, b + 1)};
 }
 
+/// The span of ALL of a segment's index entries, read once (one range read of
+/// the entries, served by the per-copy handle cache), by the reader's own
+/// rule (Session::learn_span, core/src/session.cpp:131-160): every entry's
+/// [start, start + llround(n * 1e6 / fs)); an entry with no usable count
+/// (0 = damaged, NO_ENTRY) or an unusable rate leaves the span open (the
+/// reader's span_open: such a segment is never skipped).
+struct IndexSpan {
+  bool have = false;  // at least one entry was read
+  bool open = false;
+  si8 lo = 0, hi = 0;
+  si8 first_start = 0;  // the first entry's start, and the last entry's end
+  si8 last_end = 0;     // (start + n / fs; the start when fs is unusable)
+};
+
+IndexSpan index_span(const SessionSource& src, const std::string& tidx_rel, si8 rto, sf8 fs) {
+  IndexSpan sp;
+  const std::uint64_t isize = src.file_size(tidx_rel);
+  if (isize < fmt::UNIVERSAL_HEADER_BYTES + fmt::TIME_SERIES_INDEX_BYTES) return sp;
+  const std::size_t cnt = static_cast<std::size_t>((isize - fmt::UNIVERSAL_HEADER_BYTES) /
+                                                   fmt::TIME_SERIES_INDEX_BYTES);
+  const auto es = src.read_range(tidx_rel, fmt::UNIVERSAL_HEADER_BYTES,
+                                 cnt * fmt::TIME_SERIES_INDEX_BYTES);
+  sp.have = true;
+  sp.first_start = to_user_time(read<si8>(es, 8), rto);
+  {
+    const std::size_t o = (cnt - 1) * fmt::TIME_SERIES_INDEX_BYTES;
+    const si8 t = to_user_time(read<si8>(es, o + 8), rto);
+    sp.last_end = fs > 0 ? sample_time(t, read<ui4>(es, o + 24), fs) : t;
+  }
+  sp.open = !(fs > 0) || !std::isfinite(fs);
+  sp.lo = std::numeric_limits<si8>::max();
+  sp.hi = std::numeric_limits<si8>::min();
+  for (std::size_t i = 0; i < cnt && !sp.open; ++i) {
+    const ui4 n = read<ui4>(es, i * fmt::TIME_SERIES_INDEX_BYTES + 24);
+    if (n == 0 || n == fmt::UI4_NO_ENTRY) {
+      sp.open = true;
+      break;
+    }
+    const si8 b0 = to_user_time(read<si8>(es, i * fmt::TIME_SERIES_INDEX_BYTES + 8), rto);
+    sp.lo = std::min(sp.lo, b0);
+    sp.hi = std::max(sp.hi, b0 + static_cast<si8>(std::llround(static_cast<sf8>(n) * 1e6 / fs)));
+  }
+  return sp;
+}
+
+/// A segment's span in user uUTC, for deciding whether a cut [t0, t1) can
+/// touch it: the header's start/end WIDENED to the span of the index (all its
+/// entries, index_span). NOT padded: the reader skips by exactly this
+/// span, and a pad would keep segments the window has no samples in (the
+/// copy would then hold empty segments). A header time is
+/// stale or late in the field (an interrupted append, a short-ending writer;
+/// #146 lost samples on both, and #184 dropped a merge source's whole window
+/// on a stale end), so it alone never rules a segment out - the blocks do, as
+/// the reader does. An unset header side, or an open index span, is unbounded.
+std::pair<si8, si8> widened_span(const IndexSpan& ix, si8 hdr_start, si8 hdr_end, si8 rto) {
+  constexpr si8 LO = std::numeric_limits<si8>::min(), HI = std::numeric_limits<si8>::max();
+  si8 a = is_sentinel(hdr_start, false) ? LO : to_user_time(hdr_start, rto);
+  si8 b = is_sentinel(hdr_end, false) ? HI : to_user_time(hdr_end, rto);
+  if (ix.have) {
+    if (ix.open) return {LO, HI};
+    a = std::min(a, ix.lo);
+    b = std::max(b, ix.hi);
+  }
+  return {a, b};
+}
+
+std::pair<si8, si8> segment_span(const SessionSource& src, const std::string& tidx_rel, si8 rto,
+                                 sf8 fs, si8 hdr_start, si8 hdr_end) {
+  return widened_span(index_span(src, tidx_rel, rto, fs), hdr_start, hdr_end, rto);
+}
+
+/// Whether the span [a, b) lies wholly outside [t0 - margin, t1 + margin).
+bool span_outside(const std::pair<si8, si8>& span, si8 hdr_start, si8 hdr_end, si8 t0, si8 t1,
+                  si8 margin = 0) {
+  if (is_sentinel(hdr_start, false) || is_sentinel(hdr_end, false)) return false;
+  return !(span.first < saturating_add(t1, margin) && span.second > saturating_add(t0, -margin));
+}
+
+bool segment_outside(const SessionSource& src, const std::string& tidx_rel, si8 rto, sf8 fs,
+                     si8 hdr_start, si8 hdr_end, si8 t0, si8 t1, si8 margin = 0) {
+  if (is_sentinel(hdr_start, false) || is_sentinel(hdr_end, false)) return false;
+  return span_outside(segment_span(src, tidx_rel, rto, fs, hdr_start, hdr_end),
+                      hdr_start, hdr_end, t0, t1, margin);
+}
+
 /// A cut's user time stored the way `like` was stored (meflib's negated
 /// form, or absolute); an unset `like` gets the negated form.
 si8 stored_like(si8 like, si8 user, si8 rto) {
@@ -1410,9 +1505,9 @@ class Copier {
     }
     if (window_) {
       // A segment outside the window is not read at all.
-      const si8 a = read<si8>(t.bytes, UH_START), b = read<si8>(t.bytes, UH_END);
-      if (!is_sentinel(a, false) && !is_sentinel(b, false) &&
-          !(to_user_time(a, t.rto) < window_->second && to_user_time(b, t.rto) > window_->first))
+      // (judged by the blocks too, not the header alone: #184)
+      if (segment_outside(src_, seg.tidx, t.rto, seg_fs_, read<si8>(t.bytes, UH_START),
+                          read<si8>(t.bytes, UH_END), window_->first, window_->second))
         return false;
     }
     if (reshape) {
@@ -3346,10 +3441,11 @@ VerifyReport verify_impl(const std::string& src_path, const SessionSource& src,
     std::vector<std::pair<si8, si8>> spans;  // source segments, user uUTC
     if (cut)
       for (const auto& x : sc.segments) {
-        const auto uh = src.read_range(x.tmet, 0, UH);
-        const si8 rto = segment_rto(load_time_series_metadata(src.read_all(x.tmet), o.password));
-        spans.push_back({to_user_time(read<si8>(uh, UH_START), rto),
-                         to_user_time(read<si8>(uh, UH_END), rto)});
+        const TmetImage t = open_tmet(src, x.tmet, o.password);
+        const auto m = fmt::TimeSeriesMetadataSection2::parse(
+            std::span<const ui1>(t.bytes).subspan(S2, S2_BYTES));
+        spans.push_back(segment_span(src, x.tidx, t.rto, m.sampling_frequency,
+                                     read<si8>(t.bytes, UH_START), read<si8>(t.bytes, UH_END)));
       }
     std::size_t next = 0;
     int expected_number = 0;  // a cut numbers each channel's segments from 0
@@ -3738,26 +3834,29 @@ Preflight preflight(const std::string& src_path, const std::string& dst_path, co
       for (const auto& c : plan.layout.channels) {
         if (!pf.kept.count(c.name)) continue;
         bool has = false;
-        for (const auto& seg : c.segments) {
-          if (has) break;
+        // Two passes, same answer as one over the day margin, far fewer
+        // requests: first the segments whose header span reaches the window
+        // (the usual place its samples are); only a channel still without any
+        // looks at the rest of the margin. The margin exists because a header
+        // time can be stale (an appended segment's END, a late START: #146),
+        // so a segment just outside the window by its header may still hold
+        // samples of it; it matters only for a channel nothing else answers.
+        struct Head {
+          bool exact = true;   // the header span overlaps the window (or has no times)
+          bool margin = true;  // ... or is within a day of it
+          bool done = false;
+        };
+        std::vector<Head> heads(c.segments.size());
+        auto examine = [&](const auto& seg) {
           ctl.check();
           try {
-            const auto uh = src.read_range(seg.tmet, 0, UH);
-            const si8 a = read<si8>(uh, UH_START), b = read<si8>(uh, UH_END);
-            // A first look with the segment's own offset (a day's margin;
-            // the session's may differ from it when segments disagree).
-            const si8 r = segment_rto_of(plan, seg.tmet);
-            if (!is_sentinel(a, false) && !is_sentinel(b, false) &&
-                !(to_user_time(a, r) < saturating_add(t1, DAY_US) &&
-                  to_user_time(b, r) > saturating_add(t0, -DAY_US)))
-              continue;
             const TmetImage t = open_tmet(src, seg.tmet, o.password);
             const auto m = fmt::TimeSeriesMetadataSection2::parse(
                 std::span<const ui1>(t.bytes).subspan(S2, S2_BYTES));
             const sf8 fs = m.sampling_frequency;
-            if (!(fs > 0)) continue;
+            if (!(fs > 0)) return;
             const auto [f, l] = window_entries(src, seg.tidx, t.rto, t0, t1, longest_block_us(m));
-            if (f >= l) continue;
+            if (f >= l) return;
             const auto es = src.read_range(seg.tidx, UH + f * ENTRY, (l - f) * ENTRY);
             for (std::size_t i = 0; i < l - f && !has; ++i) {
               const auto [i0, i1] =
@@ -3769,7 +3868,40 @@ Preflight preflight(const std::string& src_path, const std::string& dst_path, co
             add_exception(std::current_exception(), "source-damaged", "source-crc",
                           "source-unreadable", c.name);
           }
+        };
+        for (std::size_t k = 0; k < c.segments.size() && !has; ++k) {
+          const auto& seg = c.segments[k];
+          ctl.check();
+          try {
+            // The span is the header's WIDENED to the segment's index
+            // (segment_span, as the reader's learn_span; #184), never the
+            // header alone: a stale end or late start still reaches the
+            // window by its blocks. The segment's own offset (the session's
+            // may differ from it when segments disagree).
+            const TmetImage t = open_tmet(src, seg.tmet, o.password);
+            const sf8 sfs = fmt::TimeSeriesMetadataSection2::parse(
+                                std::span<const ui1>(t.bytes).subspan(S2, S2_BYTES))
+                                .sampling_frequency;
+            const si8 a = read<si8>(t.bytes, UH_START), b = read<si8>(t.bytes, UH_END);
+            if (!is_sentinel(a, false) && !is_sentinel(b, false)) {
+              const auto sp = segment_span(src, seg.tidx, segment_rto_of(plan, seg.tmet), sfs, a, b);
+              heads[k].exact = sp.first < t1 && sp.second > t0;
+              heads[k].margin = sp.first < saturating_add(t1, DAY_US) &&
+                                sp.second > saturating_add(t0, -DAY_US);
+            }
+          } catch (...) {
+            add_exception(std::current_exception(), "source-damaged", "source-crc",
+                          "source-unreadable", c.name);
+            heads[k].exact = heads[k].margin = false;
+            continue;
+          }
+          if (heads[k].exact) {
+            heads[k].done = true;
+            examine(seg);
+          }
         }
+        for (std::size_t k = 0; k < c.segments.size() && !has; ++k)
+          if (!heads[k].done && heads[k].margin) examine(c.segments[k]);
         if (has) any = true;
         else pf.without_samples.push_back(c.name);
       }
@@ -4542,6 +4674,7 @@ struct MergePiece {
   si8 start = 0;   ///< its first block's time (index, user uUTC)
   si8 lo = 0, hi = 0;  ///< the record times its segment-level annotations take
   Uuid level{};    ///< the result segment's level UUID (all its files)
+  std::string units;  ///< its source segment's units string, as stored
 };
 
 struct MergeSourcePlan {
@@ -4561,6 +4694,9 @@ struct MergePlan {
   /// Kept channels left out because no source has a sample of them in its
   /// range (also in `excluded`).
   std::vector<std::string> without_samples;
+  /// Channels whose kept segments carry different units strings (free text,
+  /// never a refusal): the validator's `units.mixed` on them is expected.
+  std::map<std::string, std::vector<std::string>> units_mixed;
   bool anonymize = false;
   std::optional<si8> shift;   // anonymize: the shift (unset = times kept)
   std::string pseudonym;      // anonymize
@@ -4989,6 +5125,7 @@ MergePlan preflight_merge(const std::vector<std::string>& sources, const std::st
       bool read = false;
     };
     std::vector<Seg> segs;
+    std::map<const detail::LayoutSegment*, std::string> seg_units;
     for (std::size_t k = 0; k < m.sources.size(); ++k) {
       const auto& sp = *m.sources[k];
       if (!sp.used || !sp.pf.kept.count(ch)) continue;
@@ -5008,28 +5145,26 @@ MergePlan preflight_merge(const std::vector<std::string>& sources, const std::st
             // stale, and two segments are compared only where spans meet.
             si8 a = std::numeric_limits<si8>::max(), b = std::numeric_limits<si8>::min();
             const si8 ua = read<si8>(t.bytes, UH_START), ub = read<si8>(t.bytes, UH_END);
-            // A cut copies no segment outside its range, decided from this
-            // header time (the copy's own rule).
-            if (win && !is_sentinel(ua, false) && !is_sentinel(ub, false) &&
-                !(to_user_time(ua, t.rto) < win->second && to_user_time(ub, t.rto) > win->first))
+            // One read of the index (index_span); a cut copies no segment
+            // outside its range, judged by the blocks too, not the header
+            // alone (the copy's own rule, #184).
+            const IndexSpan ix = index_span(src, seg.tidx, t.rto, fs);
+            if (win && span_outside(widened_span(ix, ua, ub, t.rto), ua, ub,
+                                    win->first, win->second))
               continue;
             if (win && !(fs > 0)) continue;  // the source's own pre-flight left it out
             if (!is_sentinel(ua, false)) a = to_user_time(ua, t.rto);
             if (!is_sentinel(ub, false)) b = to_user_time(ub, t.rto);
-            const std::uint64_t isize = src.file_size(seg.tidx);
-            if (isize >= UH + ENTRY) {
-              const std::size_t cnt = static_cast<std::size_t>((isize - UH) / ENTRY);
-              const auto e0 = src.read_range(seg.tidx, UH, ENTRY);
-              const auto el = src.read_range(seg.tidx, UH + (cnt - 1) * ENTRY, ENTRY);
-              a = std::min(a, to_user_time(read<si8>(e0, 8), t.rto));
-              b = std::max(b, sample_time(to_user_time(read<si8>(el, 8), t.rto),
-                                          read<ui4>(el, 24), fs));
+            if (ix.have) {
+              a = std::min(a, ix.first_start);
+              if (fs > 0) b = std::max(b, ix.last_end);
             }
             // (Not clipped to the range: kept blocks extend past its end, by a
             // sample when exact, by a block otherwise. The span only prunes
             // which segments are compared; the comparison itself is on the
             // blocks the copy keeps, index_blocks.)
             segs.push_back({k, &seg, t.rto, fs, longest_block_us(s2), a, b, {}, false});
+            seg_units[&seg] = s2.units_description;
           } catch (...) {
             // the source's own pre-flight already reported it
           }
@@ -5128,6 +5263,30 @@ MergePlan preflight_merge(const std::vector<std::string>& sources, const std::st
       }
       pc.level = random_uuid();
     }
+    // Units are free text and never block a merge. Decided on the segments the
+    // result actually KEEPS (after the cut): when they carry different strings
+    // (after folding the micro prefix: "uV" = "\u00B5V" = "\u03BCV") the channel is
+    // listed in units_mixed and noted. Segments keep their own strings and
+    // samples are never rescaled; the channel's label is the first kept
+    // segment's.
+    if (!pieces.empty()) {
+      for (auto& pc : pieces) pc.units = seg_units[pc.segment];
+      std::vector<std::string> distinct;
+      for (const auto& pc : pieces)
+        if (std::none_of(distinct.begin(), distinct.end(), [&](const std::string& u) {
+              return units_comparable(u) == units_comparable(pc.units);
+            }))
+          distinct.push_back(pc.units);
+      if (distinct.size() > 1) {
+        std::string listed;
+        for (const auto& u : distinct) listed += (listed.empty() ? "" : ", ") + ("\"" + u + "\"");
+        m.units_mixed[ch] = distinct;
+        m.notes.push_back("channel " + ch + " has different units in the data the result keeps (" +
+                          listed + "); every segment keeps its own units string, samples are not "
+                          "rescaled, and the channel's label shows the first kept segment's (\"" +
+                          distinct.front() + "\") (validator units.mixed)");
+      }
+    }
     m.pieces[ch] = std::move(pieces);
   }
 
@@ -5587,7 +5746,8 @@ VerifyReport verify_merge_impl(MergePlan& m, const std::string& dst_path, const
     const Report dr = handles ? detail::validate_session_through(handles->open(dst_path), dst_path, vo, inner)
                               : validate_session(dst_path, vo, inner);
     for (const auto& f : dr.findings)
-      if (f.severity != Severity::Info)
+      if (f.severity != Severity::Info &&
+          !(f.check_id == "units.mixed" && m.units_mixed.count(f.channel)))
         problem(f.path, f.check_id, "the validator reports on the result: " + f.message);
     for (const auto& sk : dr.skipped)
       problem(sk.path, "validator", "could not check a segment of the result: " + sk.reason);
@@ -5614,6 +5774,7 @@ void run_merge(const std::vector<std::string>& sources, const std::string& dst_p
   rep.channels_without_samples = m.without_samples;
   rep.output_encrypted = out.encrypt;
   rep.notes = m.notes;
+  rep.units_mixed = m.units_mixed;
   rep.segments_split = m.segments_split;
   const SourcePlan* plan0 = m.first_plan();
   std::optional<Redactor> red;