@reekon-tools/react-native-pdf-canvas 0.2.1 → 0.4.0

package/native/core/src/document.cpp

@@ -12,9 +12,11 @@
 
 #include "fpdf_formfill.h"
 #include "fpdf_progressive.h"
+#include "fpdf_text.h"
 #include "fpdfview.h"
 #include "pdfcanvas/library.h"
 #include "pdfcanvas/slots.h"
+#include "pdfcanvas/text_search.h"
 
 namespace pdfcanvas {
 
@@ -33,6 +35,19 @@ constexpr FPDF_DWORD kTransparent = 0x00000000u;
 /// PDFium's ints are 32-bit; a request past this cannot be expressed at all.
 constexpr long long kMaxInt32 = (std::numeric_limits<int>::max)();
 
+/// The device box a search rect is mapped through, in units per PDF point.
+///
+/// `FPDF_PageToDevice` is the display matrix the rasters use — `/Rotate`, the
+/// CropBox origin and the host's `rotate` all folded in by PDFium itself, which
+/// is the whole reason to go through it rather than restate the arithmetic —
+/// but its outputs are `int*`: it ROUNDS TO WHOLE DEVICE UNITS. Handed the page
+/// box in points, a rect would come back quantised to whole points, 4 px off
+/// the glyphs at scale 4. So the box is handed over at this many units per
+/// point and the answer divided back down: 1/1024 pt. The matrix is linear in
+/// the box, so this is exactly the scale-1 mapping with more digits. Mirrors
+/// `SEARCH_UNITS_PER_POINT` in `src/rasterizer/web/engine.ts`.
+constexpr double kSearchUnitsPerPoint = 1024;
+
 /* ------------------------------------------------------------------ *
  * Errors
  * ------------------------------------------------------------------ */
@@ -103,12 +118,16 @@ void preflightPath(const std::string& path) {
   }
 }
 
-void checkCancelled(Cancellation* signal, const char* stage) {
+void checkCancelled(Cancellation* signal, const char* stage, const char* what = "Render") {
   if (signal != nullptr && signal->isCancelled()) {
-    throw PdfError(ErrorCode::Cancelled, std::string("Render cancelled (") + stage + ").");
+    throw PdfError(ErrorCode::Cancelled, std::string(what) + " cancelled (" + stage + ").");
   }
 }
 
+bool isQuarterTurn(int rotation) {
+  return rotation == 0 || rotation == 90 || rotation == 180 || rotation == 270;
+}
+
 /* ------------------------------------------------------------------ *
  * Geometry
  * ------------------------------------------------------------------ */
@@ -192,6 +211,10 @@ struct Document::Impl {
   struct LoadedPage {
     int index = -1;
     FPDF_PAGE page = nullptr;
+    /// The page's TEXT, parsed on its first search and then held for as long
+    /// as the page is: a find box re-searches on every keystroke. Null until
+    /// then — a page that is only ever rendered never pays for it.
+    FPDF_TEXTPAGE text = nullptr;
     uint64_t lastUse = 0;
   };
   std::vector<LoadedPage> cache;
@@ -230,12 +253,40 @@ struct Document::Impl {
       // FORM_OnBeforeClosePage in unloadPage.
       FORM_OnAfterLoadPage(page, form);
     }
-    cache.push_back({index, page, ++useCounter});
+    LoadedPage entry;
+    entry.index = index;
+    entry.page = page;
+    entry.lastUse = ++useCounter;
+    cache.push_back(entry);
     return page;
   }
 
+  /// Requires the library lock. The text page of `index`, loading the page
+  /// (and making it the most recently used) first.
+  FPDF_TEXTPAGE loadTextPage(int index) {
+    loadPage(index);
+    for (auto& entry : cache) {
+      if (entry.index != index) continue;
+      if (entry.text == nullptr) {
+        entry.text = FPDFText_LoadPage(entry.page);
+        if (entry.text == nullptr) {
+          throw PdfError(ErrorCode::Corrupt,
+                         "PDFium could not read the text of page " + std::to_string(index) + ".");
+        }
+      }
+      return entry.text;
+    }
+    // Unreachable: loadPage either put the entry there or threw.
+    throw PdfError(ErrorCode::BackendFailure, "Page " + std::to_string(index) + " left the cache.");
+  }
+
   void unloadPage(LoadedPage& entry) {
     if (entry.page == nullptr) return;
+    // The text page FIRST: PDFium requires it closed before its page.
+    if (entry.text != nullptr) {
+      FPDFText_ClosePage(entry.text);
+      entry.text = nullptr;
+    }
     if (form != nullptr) FORM_OnBeforeClosePage(entry.page, form);
     FPDF_ClosePage(entry.page);
     entry.page = nullptr;
@@ -365,6 +416,13 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
                        " at (" + std::to_string(request.x) + ", " + std::to_string(request.y) + ").");
   }
 
+  if (!isQuarterTurn(request.rotation)) {
+    // Refused rather than folded: `45 / 90` is 0 in integer arithmetic, and a
+    // request that asked for a turn must not quietly come back upright.
+    throw PdfError(ErrorCode::BackendFailure,
+                   "Rotation must be 0, 90, 180 or 270, got " + std::to_string(request.rotation) + ".");
+  }
+
   const int pxW = request.pixelWidth();
   const int pxH = request.pixelHeight();
   const long long pixels = static_cast<long long>(pxW) * pxH;
@@ -377,8 +435,16 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
   // byte-identical to the matrix form on every rect it tried.
   const long long startX = -std::llround(request.x * request.scale);
   const long long startY = -std::llround(request.y * request.scale);
-  const long long pageW = std::llround(geometry.width * request.scale);
-  const long long pageH = std::llround(geometry.height * request.scale);
+  // THE PAGE BOX HANDED TO PDFIUM IS THE DISPLAYED ONE. `size_x` / `size_y`
+  // describe the box the page is drawn INTO after `rotate` is applied —
+  // `CPDF_Page::GetDisplayMatrix` maps the page's HEIGHT onto `size_x` for
+  // rotate 1 and 3 — so a quarter turn swaps the intrinsic extents here. The
+  // request's rect is already in that space (see `RasterRequest::rotation`), so
+  // the start offsets above need nothing: they slide the whole turned page
+  // exactly as they slide an upright one.
+  const bool turned = request.rotation == 90 || request.rotation == 270;
+  const long long pageW = std::llround((turned ? geometry.height : geometry.width) * request.scale);
+  const long long pageH = std::llround((turned ? geometry.width : geometry.height) * request.scale);
   if (pixels > kMaxRasterPixels) {
     throw PdfError(ErrorCode::OutOfMemory,
                    "Refused a " + std::to_string(pxW) + "x" + std::to_string(pxH) + " raster (" +
@@ -451,6 +517,11 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
   const int sy = static_cast<int>(startY);
   const int pw = static_cast<int>(pageW);
   const int ph = static_cast<int>(pageH);
+  // The HOST's rotation in quarter turns clockwise — never the page's own
+  // `/Rotate`, which PDFium has already folded into `geometry` and into the
+  // render. Passed to BOTH passes below, so a form field lands where the turned
+  // content says and not where the upright page had it.
+  const int rotate = request.rotation / 90;
 
   auto abandonWith = [&](PdfError error) -> PdfError {
     FPDFBitmap_Destroy(bitmap);
@@ -466,8 +537,7 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
   // TOBECONTINUED when the pause adapter asked to stop, which it does only
   // once the signal is set; a live render runs to DONE in one call.
   PauseAdapter pause(signal);
-  int status = FPDF_RenderPageBitmap_Start(bitmap, page, sx, sy, pw, ph, /*rotate=*/0, flags,
-                                           &pause.pause);
+  int status = FPDF_RenderPageBitmap_Start(bitmap, page, sx, sy, pw, ph, rotate, flags, &pause.pause);
   while (status == FPDF_RENDER_TOBECONTINUED) {
     if (signal != nullptr && signal->isCancelled()) {
       FPDF_RenderPage_Close(page);
@@ -487,7 +557,7 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
   // state — with the same offsets, so they land exactly where the page put
   // them.
   if (request.annotations && impl_->form != nullptr) {
-    FPDF_FFLDraw(impl_->form, bitmap, page, sx, sy, pw, ph, /*rotate=*/0, flags);
+    FPDF_FFLDraw(impl_->form, bitmap, page, sx, sy, pw, ph, rotate, flags);
   }
 
   FPDFBitmap_Destroy(bitmap);
@@ -513,4 +583,137 @@ RasterPixels Document::render(const RasterRequest& request, Cancellation* signal
   return out;
 }
 
+/* ------------------------------------------------------------------ *
+ * Text search
+ * ------------------------------------------------------------------ */
+
+namespace {
+
+/// `kContextChars` either side of `[charIndex, charIndex + charCount)`, out of
+/// the text page, collapsed. The window is clamped to the page's text, so a
+/// match near an edge carries less on that side rather than padding. Exactly
+/// `readContext` in `src/rasterizer/web/engine.ts`.
+std::u16string readContext(FPDF_TEXTPAGE text, int totalChars, int charIndex, int charCount) {
+  const int start = (std::max)(0, charIndex - kContextChars);
+  const int end = (std::min)(totalChars, charIndex + charCount + kContextChars);
+  const int count = end - start;
+  if (count <= 0) return {};
+  // `count + 1` units: PDFium writes the terminator, and its return value
+  // counts it.
+  std::vector<unsigned short> buffer(static_cast<size_t>(count) + 1, 0);
+  const int written = FPDFText_GetText(text, start, count, buffer.data());
+  std::u16string raw;
+  for (int i = 0; i + 1 < written; i++) raw += static_cast<char16_t>(buffer[static_cast<size_t>(i)]);
+  return collapseWhitespace(raw);
+}
+
+}  // namespace
+
+std::vector<TextMatch> Document::searchText(const TextSearchRequest& request, Cancellation* signal) {
+  checkCancelled(signal, "before start", "Search");
+  if (impl_->closed) {
+    throw PdfError(ErrorCode::BackendFailure, "Document handle is closed.");
+  }
+  const PageGeometry& geometry = this->geometry(request.page);
+  if (!isQuarterTurn(request.rotation)) {
+    // Refused, as a render refuses it: rects for a turn nobody draws would be
+    // rects in no space at all.
+    throw PdfError(ErrorCode::BackendFailure,
+                   "Rotation must be 0, 90, 180 or 270, got " + std::to_string(request.rotation) + ".");
+  }
+  if (request.query.empty()) return {};
+
+  // THE DISPLAYED PAGE'S BOX, as the renderer hands it to PDFium: the
+  // post-/Rotate extents, swapped for a host quarter turn — then scaled up,
+  // because `FPDF_PageToDevice` rounds to whole units.
+  const bool turned = request.rotation == 90 || request.rotation == 270;
+  const double displayedWidth = turned ? geometry.height : geometry.width;
+  const double displayedHeight = turned ? geometry.width : geometry.height;
+  const long long sizeX = std::llround(displayedWidth * kSearchUnitsPerPoint);
+  const long long sizeY = std::llround(displayedHeight * kSearchUnitsPerPoint);
+  if (sizeX <= 0 || sizeY <= 0 || sizeX > kMaxInt32 || sizeY > kMaxInt32) {
+    throw PdfError(ErrorCode::BackendFailure,
+                   "Page " + std::to_string(request.page) + " is too large to map search rects on.");
+  }
+  // Per axis, from the ROUNDED box, so the division undoes exactly the scale
+  // PDFium applied rather than the one that was asked for.
+  const double pointsPerUnitX = displayedWidth / static_cast<double>(sizeX);
+  const double pointsPerUnitY = displayedHeight / static_cast<double>(sizeY);
+  const int rotate = request.rotation / 90;
+  const unsigned long flags = (request.matchCase ? FPDF_MATCHCASE : 0u) |
+                              (request.wholeWord ? FPDF_MATCHWHOLEWORD : 0u);
+
+  std::lock_guard<std::mutex> lock(Library::mutex());
+  checkCancelled(signal, "after lock", "Search");
+  if (impl_->closed) {
+    throw PdfError(ErrorCode::BackendFailure, "Document handle is closed.");
+  }
+
+  // The text page first: it loads (or re-uses) the page it belongs to, and a
+  // page loaded afterwards could evict it.
+  FPDF_TEXTPAGE text = impl_->loadTextPage(request.page);
+  FPDF_PAGE page = impl_->loadPage(request.page);
+  const int totalChars = FPDFText_CountChars(text);
+
+  // `c_str()` is terminated, which is what an FPDF_WIDESTRING must be.
+  // `char16_t` and `unsigned short` are the same 16 bits on every target.
+  static_assert(sizeof(char16_t) == sizeof(FPDF_WCHAR), "UTF-16 unit size");
+  FPDF_SCHHANDLE find =
+      FPDFText_FindStart(text, reinterpret_cast<FPDF_WIDESTRING>(request.query.c_str()), flags, 0);
+  if (find == nullptr) return {};
+  struct CloseFind {
+    FPDF_SCHHANDLE handle;
+    ~CloseFind() { FPDFText_FindClose(handle); }
+  } closeFind{find};
+
+  const auto toDevice = [&](double pageX, double pageY, int& x, int& y) {
+    if (!FPDF_PageToDevice(page, 0, 0, static_cast<int>(sizeX), static_cast<int>(sizeY), rotate,
+                           pageX, pageY, &x, &y)) {
+      throw PdfError(ErrorCode::BackendFailure,
+                     "PDFium could not map a search rect on page " + std::to_string(request.page) +
+                         " to device space.");
+    }
+  };
+
+  std::vector<TextMatch> matches;
+  while (FPDFText_FindNext(find)) {
+    // Between matches, through `poll()` so the test affordance can land a
+    // cancel INSIDE a search. A superseded "find" on a dense drawing stops
+    // here instead of collecting hundreds of hits nobody will see.
+    if (signal != nullptr && signal->poll()) {
+      throw PdfError(ErrorCode::Cancelled, "Search cancelled (between matches).");
+    }
+    const int charIndex = FPDFText_GetSchResultIndex(find);
+    const int charCount = FPDFText_GetSchCount(find);
+    // Cannot happen for a non-empty query; the guard is against looping
+    // forever if PDFium ever reported one.
+    if (charCount <= 0) break;
+
+    TextMatch match;
+    match.page = request.page;
+    match.charIndex = charIndex;
+    match.charCount = charCount;
+    const int rectCount = FPDFText_CountRects(text, charIndex, charCount);
+    for (int i = 0; i < rectCount; i++) {
+      double left = 0, top = 0, right = 0, bottom = 0;
+      if (!FPDFText_GetRect(text, i, &left, &top, &right, &bottom)) continue;
+      // User space, y up (top > bottom). Both corners through the display
+      // matrix; a quarter turn can swap which one is the top-left, so the
+      // rect is min/max of the two.
+      int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
+      toDevice(left, top, x1, y1);
+      toDevice(right, bottom, x2, y2);
+      DocRect rect;
+      rect.x = (std::min)(x1, x2) * pointsPerUnitX;
+      rect.y = (std::min)(y1, y2) * pointsPerUnitY;
+      rect.width = std::abs(x2 - x1) * pointsPerUnitX;
+      rect.height = std::abs(y2 - y1) * pointsPerUnitY;
+      match.rects.push_back(rect);
+    }
+    match.context = readContext(text, totalChars, charIndex, charCount);
+    matches.push_back(std::move(match));
+  }
+  return matches;
+}
+
 }  // namespace pdfcanvas

package/native/core/src/service.cpp

@@ -3,6 +3,7 @@
 #include <string>
 
 #include "pdfcanvas/slots.h"
+#include "pdfcanvas/text_search.h"
 
 namespace pdfcanvas {
 
@@ -46,52 +47,66 @@ void Service::registerCancellation(int handle, int64_t token) {
   signals_[signalKey(handle, token)] = std::make_shared<Cancellation>();
 }
 
-RasterPixels Service::render(int handle, const RasterRequest& request, int64_t token,
-                             bool useSlot) {
-  const int64_t key = signalKey(handle, token);
+/// Looks up (or plants) the job's signal and its document under the service
+/// mutex, and unregisters the signal on EVERY path out, including a throw —
+/// otherwise a superseded epoch, which produces a stream of cancelled jobs,
+/// grows the map for the life of the module.
+struct Service::Lease {
+  Service& service;
+  int64_t key;
   std::shared_ptr<Cancellation> signal;
   std::shared_ptr<Document> document;
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto found = signals_.find(key);
-    if (found != signals_.end()) {
+
+  Lease(Service& owner, int handle, int64_t token)
+      : service(owner), key(signalKey(handle, token)) {
+    std::lock_guard<std::mutex> lock(service.mutex_);
+    auto found = service.signals_.find(key);
+    if (found != service.signals_.end()) {
       signal = found->second;
     } else {
       // Not registered ahead of time: a caller that dispatched without the
       // register step. It still gets a signal, so a cancel that arrives while
-      // this render runs is honoured.
+      // this job runs is honoured.
       signal = std::make_shared<Cancellation>();
-      signals_.emplace(key, signal);
+      service.signals_.emplace(key, signal);
     }
-    auto doc = documents_.find(handle);
-    document = doc == documents_.end() ? nullptr : doc->second;
-  }
-
-  // Unregistered on EVERY path out, including a throw — otherwise a superseded
-  // epoch, which produces a stream of cancelled renders, grows the map for the
-  // life of the module.
-  struct Unregister {
-    Service* service;
-    int64_t key;
-    ~Unregister() {
-      std::lock_guard<std::mutex> lock(service->mutex_);
-      service->signals_.erase(key);
+    auto doc = service.documents_.find(handle);
+    document = doc == service.documents_.end() ? nullptr : doc->second;
+    if (document == nullptr) {
+      service.signals_.erase(key);
+      throw PdfError(ErrorCode::BackendFailure,
+                     "No open document for handle " + std::to_string(handle) + ".");
     }
-  } unregister{this, key};
+  }
 
-  if (document == nullptr) {
-    throw PdfError(ErrorCode::BackendFailure,
-                   "No open document for handle " + std::to_string(handle) + ".");
+  ~Lease() {
+    std::lock_guard<std::mutex> lock(service.mutex_);
+    service.signals_.erase(key);
   }
 
+  Lease(const Lease&) = delete;
+  Lease& operator=(const Lease&) = delete;
+};
+
+RasterPixels Service::render(int handle, const RasterRequest& request, int64_t token,
+                             bool useSlot) {
+  Lease lease(*this, handle, token);
+
   // Read ONCE per render: whether to reach for a slot. The sink may still
   // refuse, in which case the raster comes back heap-backed and the caller
   // branches on where the pixels ARE, not on what was asked for.
   if (useSlot) {
     SlotSink sink;
-    return document->render(request, signal.get(), &sink);
+    return lease.document->render(request, lease.signal.get(), &sink);
   }
-  return document->render(request, signal.get(), nullptr);
+  return lease.document->render(request, lease.signal.get(), nullptr);
+}
+
+std::string Service::searchJson(int handle, const TextSearchRequest& request, int64_t token) {
+  Lease lease(*this, handle, token);
+  // Serialised HERE rather than in either binding, so the two cannot
+  // disagree about the wire form and the JSON is proven on a laptop.
+  return textMatchesToJson(lease.document->searchText(request, lease.signal.get()));
 }
 
 void Service::cancel(int handle, int64_t token) {

package/native/core/src/text_search.cpp

@@ -0,0 +1,115 @@
+#include "pdfcanvas/text_search.h"
+
+#include <cmath>
+#include <cstdio>
+#include <string>
+
+namespace pdfcanvas {
+
+namespace {
+
+void appendNumber(std::string& out, double value) {
+  if (!std::isfinite(value)) {
+    out += '0';
+    return;
+  }
+  char buffer[40];
+  const int written = std::snprintf(buffer, sizeof(buffer), "%.17g", value);
+  if (written <= 0) {
+    out += '0';
+    return;
+  }
+  for (int i = 0; i < written && buffer[i] != '\0'; i++) {
+    // `%g` emits digits, a sign, an exponent and ONE locale decimal separator.
+    // Anything that is not one of the first three is that separator.
+    const char c = buffer[i];
+    const bool keep = (c >= '0' && c <= '9') || c == '-' || c == '+' || c == 'e' || c == 'E';
+    out += keep ? c : '.';
+  }
+}
+
+void appendString(std::string& out, const std::u16string& text) {
+  static const char kHex[] = "0123456789abcdef";
+  out += '"';
+  for (const char16_t unit : text) {
+    if (unit >= 0x20 && unit < 0x7F && unit != u'"' && unit != u'\\') {
+      out += static_cast<char>(unit);
+    } else {
+      out += "\\u";
+      out += kHex[(unit >> 12) & 0xF];
+      out += kHex[(unit >> 8) & 0xF];
+      out += kHex[(unit >> 4) & 0xF];
+      out += kHex[unit & 0xF];
+    }
+  }
+  out += '"';
+}
+
+}  // namespace
+
+bool isJsWhitespace(char16_t unit) noexcept {
+  // ECMAScript WhiteSpace + LineTerminator: TAB VT FF SP NBSP ZWNBSP, the
+  // Unicode Space_Separator category, LF CR LS PS.
+  switch (unit) {
+    case 0x0009: case 0x000A: case 0x000B: case 0x000C: case 0x000D:
+    case 0x0020: case 0x00A0: case 0x1680:
+    case 0x2028: case 0x2029: case 0x202F: case 0x205F: case 0x3000:
+    case 0xFEFF:
+      return true;
+    default:
+      return unit >= 0x2000 && unit <= 0x200A;
+  }
+}
+
+std::u16string collapseWhitespace(const std::u16string& text) {
+  std::u16string out;
+  out.reserve(text.size());
+  bool pendingSpace = false;
+  for (const char16_t unit : text) {
+    if (isJsWhitespace(unit)) {
+      pendingSpace = !out.empty();  // leading whitespace is dropped
+      continue;
+    }
+    if (pendingSpace) out += u' ';
+    pendingSpace = false;
+    out += unit;
+  }
+  return out;  // trailing whitespace never emitted its space
+}
+
+std::string textMatchesToJson(const std::vector<TextMatch>& matches) {
+  std::string out;
+  out.reserve(64 + matches.size() * 200);
+  out += '[';
+  for (size_t i = 0; i < matches.size(); i++) {
+    const TextMatch& match = matches[i];
+    if (i > 0) out += ',';
+    out += "{\"page\":";
+    out += std::to_string(match.page);
+    out += ",\"charIndex\":";
+    out += std::to_string(match.charIndex);
+    out += ",\"charCount\":";
+    out += std::to_string(match.charCount);
+    out += ",\"rects\":[";
+    for (size_t j = 0; j < match.rects.size(); j++) {
+      const DocRect& rect = match.rects[j];
+      if (j > 0) out += ',';
+      out += "{\"x\":";
+      appendNumber(out, rect.x);
+      out += ",\"y\":";
+      appendNumber(out, rect.y);
+      out += ",\"width\":";
+      appendNumber(out, rect.width);
+      out += ",\"height\":";
+      appendNumber(out, rect.height);
+      out += '}';
+    }
+    out += "],\"context\":";
+    appendString(out, match.context);
+    out += '}';
+  }
+  out += ']';
+  return out;
+}
+
+}  // namespace pdfcanvas

package/native/tests/fixtures.cpp

@@ -204,6 +204,33 @@ Bytes formFieldPage() {
   return w.finish(catalog);
 }
 
+namespace {
+
+Bytes helveticaPage(const std::string& content, int rotate) {
+  Writer w;
+  const int contents = w.add(streamObject(content + "\n"));
+  // Indirect, as the spec prefers for a font resource; written before the page
+  // so /Resources can name the number it actually got.
+  const int font = w.add("<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>");
+  const int pagesNumber = w.count() + 2;
+  std::string dict = "<< /Type /Page /Parent " + std::to_string(pagesNumber) + " 0 R /MediaBox [0 0 " +
+                     std::to_string(kLetterW) + " " + std::to_string(kLetterH) + "]";
+  if (rotate != 0) dict += " /Rotate " + std::to_string(rotate);
+  dict += " /Contents " + std::to_string(contents) + " 0 R /Resources << /Font << /F1 " +
+          std::to_string(font) + " 0 R >> >> >>";
+  const int pageObj = w.add(dict);
+  const int pages = w.add("<< /Type /Pages /Kids [" + std::to_string(pageObj) + " 0 R] /Count 1 >>");
+  const int catalog = w.add("<< /Type /Catalog /Pages " + std::to_string(pages) + " 0 R >>");
+  if (pages != pagesNumber) throw std::logic_error("pages object number drifted");
+  return w.finish(catalog);
+}
+
+}  // namespace
+
+Bytes textPage(int rotate) { return helveticaPage(kTextContent, rotate); }
+
+Bytes twoLineTextPage() { return helveticaPage(kTwoLineTextContent, 0); }
+
 /* ------------------------------------------------------------------ *
  * Multi-page fixtures
  * ------------------------------------------------------------------ */

package/native/tests/fixtures.h

@@ -61,6 +61,21 @@ Bytes annotatedPage();
 /// through the document's AcroForm. Content: white page with a red marker.
 Bytes formFieldPage();
 
+/// ONE LINE OF REAL TEXT: "Hello measured world", 24pt Helvetica, baseline at
+/// user-space (72, 700) on a 612x792 page carrying `/Rotate rotate`. The font is
+/// NOT embedded — Helvetica is one of the standard 14, which PDFium substitutes
+/// from its built-in fonts, so it draws and extracts with no font file. The same
+/// bytes as `textPdf` in `src/__tests__/support/pdfium.ts`, so both engines are
+/// asked the same question.
+constexpr const char* kTextContent = "BT /F1 24 Tf 72 700 Td (Hello measured world) Tj ET";
+Bytes textPage(int rotate = 0);
+/// The same line plus "on a second line" 30pt below it, so PDFium's text page
+/// carries a generated line break a match's context must collapse. The same
+/// bytes as `twoLineTextPdf` in `src/__tests__/support/pdfium.ts`.
+constexpr const char* kTwoLineTextContent =
+    "BT /F1 24 Tf 72 700 Td (Hello measured world) Tj 0 -30 Td (on a second line) Tj ET";
+Bytes twoLineTextPage();
+
 /// A single page with explicit boxes, rotation and content.
 Bytes page(Box mediaBox, const Box* cropBox, int rotate, const std::string& content);