@reekon-tools/react-native-pdf-canvas 0.1.0

package/android/src/androidTest/java/tools/reekon/pdfcanvas/PoisonsTheProcess.java

@@ -0,0 +1,20 @@
+package tools.reekon.pdfcanvas;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a test that deliberately triggers the API 24 PDFium poisoning and can
+ * therefore only be the LAST thing its process does.
+ *
+ * `android/build.gradle` passes `notAnnotation` for this type, so
+ * `connectedDebugAndroidTest` never runs it by accident. It is run on its own —
+ * the command is in {@code PdfCanvasPoisonGuardTest}'s javadoc — which is the
+ * only way to observe the guard doing its job, because observing it requires the
+ * platform to actually be broken.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface PoisonsTheProcess {}

package/android/src/androidTest/java/tools/reekon/pdfcanvas/TestPdfs.java

@@ -0,0 +1,558 @@
+package tools.reekon.pdfcanvas;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.pdf.PdfDocument;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * PDFs built ON DEVICE, so a test has no asset to ship and the content is known
+ * exactly rather than eyeballed.
+ *
+ * Three kinds, because three different things need proving:
+ *
+ *   pattern()   — via android.graphics.pdf.PdfDocument. Detail at every spatial
+ *                 frequency, so a scale error, a translation error and an x/y
+ *                 transposition each move a large share of the pixels. A flat or
+ *                 symmetric page would let all three through, which is the whole
+ *                 reason the spike used this pattern and not a gradient.
+ *
+ *   rotated()   — hand-written, because PdfDocument.PageInfo has no way to set
+ *                 /Rotate. Post-rotation geometry cannot be tested without it.
+ *
+ *   encrypted() — hand-written, because nothing in the platform writes an
+ *                 encrypted PDF. Without it "password-protected produces a
+ *                 distinguishable error" is an assertion about code that has
+ *                 never met an encrypted file.
+ */
+final class TestPdfs {
+
+  static final int LETTER_W = 612;
+  static final int LETTER_H = 792;
+  /** ARCH-D, the sheet size this package exists for. */
+  static final int ARCH_D_W = 1728;
+  static final int ARCH_D_H = 2592;
+
+  private static final Charset LATIN1 = Charset.forName("ISO-8859-1");
+
+  private TestPdfs() {}
+
+  /* ---------------------------------------------------------------- *
+   * PdfDocument-authored pages
+   * ---------------------------------------------------------------- */
+
+  /**
+   * Detail at every frequency: an 8pt grid catches a scale error, 64pt-pitch
+   * colour blocks catch a translation error, and the two diagonals catch an x/y
+   * transposition.
+   */
+  private static void drawPattern(Canvas canvas, int wPt, int hPt) {
+    canvas.drawColor(Color.WHITE);
+
+    Paint grid = new Paint();
+    grid.setColor(Color.BLACK);
+    grid.setStrokeWidth(0.5f);
+    grid.setAntiAlias(true);
+    for (int x = 0; x <= wPt; x += 8) canvas.drawLine(x, 0, x, hPt, grid);
+    for (int y = 0; y <= hPt; y += 8) canvas.drawLine(0, y, wPt, y, grid);
+
+    Paint block = new Paint();
+    block.setAntiAlias(true);
+    int i = 0;
+    for (int y = 0; y < hPt; y += 64) {
+      for (int x = 0; x < wPt; x += 64) {
+        block.setColor(Color.rgb((x * 7 + i) % 256, (y * 5 + i) % 256, (i * 13) % 256));
+        canvas.drawRect(x + 4, y + 4, x + 40, y + 40, block);
+        i++;
+      }
+    }
+
+    Paint diag = new Paint();
+    diag.setColor(Color.RED);
+    diag.setStrokeWidth(2f);
+    diag.setAntiAlias(true);
+    canvas.drawLine(0, 0, wPt, hPt, diag);
+    canvas.drawLine(wPt, 0, 0, hPt, diag);
+  }
+
+  static File pattern(Context ctx, String name, int wPt, int hPt) throws IOException {
+    return pattern(ctx, name, wPt, hPt, 1);
+  }
+
+  static File pattern(Context ctx, String name, int wPt, int hPt, int pageCount)
+      throws IOException {
+    PdfDocument doc = new PdfDocument();
+    for (int p = 0; p < pageCount; p++) {
+      PdfDocument.PageInfo info =
+          new PdfDocument.PageInfo.Builder(wPt, hPt, p).create();
+      PdfDocument.Page page = doc.startPage(info);
+      drawPattern(page.getCanvas(), wPt, hPt);
+      doc.finishPage(page);
+    }
+    File out = new File(ctx.getCacheDir(), name);
+    try (FileOutputStream fos = new FileOutputStream(out)) {
+      doc.writeTo(fos);
+    }
+    doc.close();
+    return out;
+  }
+
+  /**
+   * Pages of DIFFERENT sizes in one document, so a geometry test can catch an
+   * implementation that probes page 0 and reports its size for every page.
+   */
+  static File mixedSizes(Context ctx, String name) throws IOException {
+    int[][] sizes = {{LETTER_W, LETTER_H}, {ARCH_D_W, ARCH_D_H}, {200, 900}};
+    PdfDocument doc = new PdfDocument();
+    for (int p = 0; p < sizes.length; p++) {
+      PdfDocument.PageInfo info =
+          new PdfDocument.PageInfo.Builder(sizes[p][0], sizes[p][1], p).create();
+      PdfDocument.Page page = doc.startPage(info);
+      page.getCanvas().drawColor(Color.WHITE);
+      doc.finishPage(page);
+    }
+    File out = new File(ctx.getCacheDir(), name);
+    try (FileOutputStream fos = new FileOutputStream(out)) {
+      doc.writeTo(fos);
+    }
+    doc.close();
+    return out;
+  }
+
+  static int[] mixedSizeExpectation(int page) {
+    int[][] sizes = {{LETTER_W, LETTER_H}, {ARCH_D_W, ARCH_D_H}, {200, 900}};
+    return sizes[page];
+  }
+
+  /**
+   * One flat colour per page. Catches a backend that ignores
+   * {@code RasterRequest.page} and renders page 0 for every request — which a
+   * single-page fixture cannot catch at all, and a multi-page fixture with
+   * identical pages catches only by luck.
+   */
+  static File coloredPages(Context ctx, String name, int[] colors, int wPt, int hPt)
+      throws IOException {
+    PdfDocument doc = new PdfDocument();
+    for (int p = 0; p < colors.length; p++) {
+      PdfDocument.PageInfo info = new PdfDocument.PageInfo.Builder(wPt, hPt, p).create();
+      PdfDocument.Page page = doc.startPage(info);
+      page.getCanvas().drawColor(colors[p]);
+      doc.finishPage(page);
+    }
+    File out = new File(ctx.getCacheDir(), name);
+    try (FileOutputStream fos = new FileOutputStream(out)) {
+      doc.writeTo(fos);
+    }
+    doc.close();
+    return out;
+  }
+
+  /**
+   * Four saturated quadrants — red, green, blue, black — which is what makes a
+   * channel-order test possible at all. A grey or white page reads the same in
+   * RGBA and BGRA, so the two orderings are indistinguishable on it; pure red
+   * differs in the first byte.
+   *
+   * Quadrants also make a STRIDE error visible: a raster read back with the
+   * wrong row stride walks diagonally across the quadrant boundaries, so the
+   * sampled colours come out wrong rather than merely shifted.
+   */
+  static File quadrants(Context ctx, String name, int wPt, int hPt) throws IOException {
+    PdfDocument doc = new PdfDocument();
+    PdfDocument.PageInfo info = new PdfDocument.PageInfo.Builder(wPt, hPt, 0).create();
+    PdfDocument.Page page = doc.startPage(info);
+    Canvas canvas = page.getCanvas();
+    Paint paint = new Paint();
+    paint.setAntiAlias(false);
+    int halfW = wPt / 2;
+    int halfH = hPt / 2;
+    paint.setColor(Color.RED);
+    canvas.drawRect(0, 0, halfW, halfH, paint);
+    paint.setColor(Color.GREEN);
+    canvas.drawRect(halfW, 0, wPt, halfH, paint);
+    paint.setColor(Color.BLUE);
+    canvas.drawRect(0, halfH, halfW, hPt, paint);
+    paint.setColor(Color.BLACK);
+    canvas.drawRect(halfW, halfH, wPt, hPt, paint);
+    doc.finishPage(page);
+
+    File out = new File(ctx.getCacheDir(), name);
+    try (FileOutputStream fos = new FileOutputStream(out)) {
+      doc.writeTo(fos);
+    }
+    doc.close();
+    return out;
+  }
+
+  /* ---------------------------------------------------------------- *
+   * Hand-written PDFs
+   * ---------------------------------------------------------------- */
+
+  /** Assembles objects and writes a correct xref table, which PDFium prefers. */
+  private static final class Writer {
+    private final ByteArrayOutputStream out = new ByteArrayOutputStream();
+    private final List<Integer> offsets = new ArrayList<>();
+
+    Writer() {
+      write("%PDF-1.4\n");
+      // A binary comment line marks the file as binary, per the spec's advice.
+      out.write(0x25);
+      out.write(0xE2);
+      out.write(0xE3);
+      out.write(0xCF);
+      out.write(0xD3);
+      out.write('\n');
+    }
+
+    void write(String s) {
+      byte[] b = s.getBytes(LATIN1);
+      out.write(b, 0, b.length);
+    }
+
+    void write(byte[] b) {
+      out.write(b, 0, b.length);
+    }
+
+    /** @return the object number, 1-based. */
+    int add(String body) {
+      return add(body.getBytes(LATIN1));
+    }
+
+    int add(byte[] body) {
+      int number = offsets.size() + 1;
+      offsets.add(out.size());
+      write(number + " 0 obj\n");
+      write(body);
+      write("\nendobj\n");
+      return number;
+    }
+
+    /**
+     * Writes at least {@code atLeast} bytes of PDF COMMENT lines.
+     *
+     * A `%` line is legal anywhere between objects and is never drawn, so this
+     * changes the file's LENGTH and nothing else — which is the only lever a
+     * preflight scan-window test needs. Call it after the last {@code add()} and
+     * before {@code finish()}, so the trailer is pushed past the head window
+     * while every recorded xref offset stays correct.
+     */
+    void pad(int atLeast) {
+      StringBuilder sb = new StringBuilder(atLeast + 64);
+      int line = 0;
+      while (sb.length() < atLeast) {
+        sb.append("% padding line ").append(line++)
+            .append(" - legal PDF comment, never drawn\n");
+      }
+      write(sb.toString());
+    }
+
+    byte[] finish(int rootObject, String extraTrailerEntries) {
+      int xref = out.size();
+      int size = offsets.size() + 1;
+      write("xref\n0 " + size + "\n");
+      write("0000000000 65535 f \n");
+      for (int offset : offsets) {
+        write(String.format("%010d 00000 n \n", offset));
+      }
+      write("trailer\n<< /Size " + size + " /Root " + rootObject + " 0 R "
+          + extraTrailerEntries + " >>\nstartxref\n" + xref + "\n%%EOF\n");
+      return out.toByteArray();
+    }
+  }
+
+  /**
+   * A 612x792 page carrying {@code /Rotate 90}, with a red marker filling the
+   * top-left 112x100 points of the UNROTATED page.
+   *
+   * /Rotate is "degrees the page shall be rotated CLOCKWISE when displayed", so
+   * a correct renderer reports the page as 792x612 and puts that marker in the
+   * displayed TOP-RIGHT. Both halves matter: swapped dimensions alone would also
+   * be produced by an implementation that swapped width and height and drew the
+   * content unrotated.
+   *
+   * PDF user space is y-UP from the bottom-left, so the top-left 112x100 of the
+   * page is the rect (0, 692) to (112, 792).
+   */
+  static File rotated90(Context ctx, String name) throws IOException {
+    String content =
+        "1 1 1 rg 0 0 " + LETTER_W + " " + LETTER_H + " re f\n"
+            + "1 0 0 rg 0 692 112 100 re f\n"
+            // A blue marker at the unrotated BOTTOM-left, so an implementation
+            // that rotated the wrong way round is caught too: 180 degrees out
+            // would put red where blue is expected.
+            + "0 0 1 rg 0 0 112 100 re f\n";
+    byte[] stream = content.getBytes(LATIN1);
+
+    Writer w = new Writer();
+    int contents = w.add("<< /Length " + stream.length + " >>\nstream\n"
+        + content + "endstream");
+    int page = w.add("<< /Type /Page /Parent 3 0 R /MediaBox [0 0 " + LETTER_W + " "
+        + LETTER_H + "] /Rotate 90 /Contents " + contents + " 0 R "
+        + "/Resources << >> >>");
+    int pages = w.add("<< /Type /Pages /Kids [" + page + " 0 R] /Count 1 >>");
+    int catalog = w.add("<< /Type /Catalog /Pages " + pages + " 0 R >>");
+    // /Parent was written as "3 0 R" above, which is the number `pages` gets;
+    // assert rather than hope, because a silent mismatch makes PDFium rebuild
+    // the tree and the test would still pass for the wrong reason.
+    if (pages != 3) {
+      throw new IllegalStateException("Pages object is " + pages + ", not 3");
+    }
+    return writeFile(ctx, name, w.finish(catalog, ""));
+  }
+
+  /**
+   * A perfectly ordinary PDF whose content stream contains the literal text
+   * {@code /Encrypt}.
+   *
+   * The decoy for {@link PdfPreflight}: a naive substring scan for the name
+   * would refuse this document with "needs a password", which is the most
+   * confusing thing a preflight can say. The name appears WITHOUT a following
+   * indirect reference, which is exactly the shape the real check requires — so
+   * this passes only if the check looks at the whole reference.
+   */
+  static File withLiteralEncryptInContent(Context ctx, String name) throws IOException {
+    // A comment inside a content stream is legal and is never drawn, so the
+    // bytes are present in the file without changing what the page looks like.
+    String content = "% /Encrypt and /Encrypt again, as decoys\n1 0 0 rg 0 0 200 200 re f\n";
+
+    Writer w = new Writer();
+    int contents = w.add("<< /Length " + content.length() + " >>\nstream\n"
+        + content + "endstream");
+    int page = w.add("<< /Type /Page /Parent 3 0 R /MediaBox [0 0 200 200] /Contents "
+        + contents + " 0 R /Resources << >> >>");
+    int pages = w.add("<< /Type /Pages /Kids [" + page + " 0 R] /Count 1 >>");
+    int catalog = w.add("<< /Type /Catalog /Pages " + pages + " 0 R >>");
+    if (pages != 3) {
+      throw new IllegalStateException("Pages object is " + pages + ", not 3");
+    }
+    return writeFile(ctx, name, w.finish(catalog, ""));
+  }
+
+  /**
+   * A file with a valid {@code %PDF-} header and nothing else that parses.
+   *
+   * Preflight cannot reject it — it claims to be a PDF and is not encrypted — so
+   * it is the shape that still reaches {@code new PdfRenderer(...)} and, on API
+   * 24, still poisons the process. Used only by the excluded poison-guard test.
+   */
+  static File headerOnlyGarbage(Context ctx, String name) throws IOException {
+    StringBuilder sb = new StringBuilder("%PDF-1.7\n");
+    for (int i = 0; i < 200; i++) {
+      sb.append("garbage line ").append(i).append('\n');
+    }
+    return writeFile(ctx, name, sb.toString().getBytes(LATIN1));
+  }
+
+  /* ---------------------------------------------------------------- *
+   * Encryption (standard security handler, R=2, V=1, RC4-40)
+   * ---------------------------------------------------------------- */
+
+  private static final byte[] PAD = {
+    (byte) 0x28, (byte) 0xBF, (byte) 0x4E, (byte) 0x5E, (byte) 0x4E, (byte) 0x75,
+    (byte) 0x8A, (byte) 0x41, (byte) 0x64, (byte) 0x00, (byte) 0x4E, (byte) 0x56,
+    (byte) 0xFF, (byte) 0xFA, (byte) 0x01, (byte) 0x08, (byte) 0x2E, (byte) 0x2E,
+    (byte) 0x00, (byte) 0xB6, (byte) 0xD0, (byte) 0x68, (byte) 0x3E, (byte) 0x80,
+    (byte) 0x2F, (byte) 0x0C, (byte) 0xA9, (byte) 0xFE, (byte) 0x64, (byte) 0x53,
+    (byte) 0x69, (byte) 0x7A
+  };
+
+  static final String USER_PASSWORD = "secret";
+
+  private static byte[] pad(String password) {
+    byte[] pw = password.getBytes(LATIN1);
+    byte[] out = new byte[32];
+    int n = Math.min(pw.length, 32);
+    System.arraycopy(pw, 0, out, 0, n);
+    System.arraycopy(PAD, 0, out, n, 32 - n);
+    return out;
+  }
+
+  private static byte[] md5(byte[]... parts) {
+    try {
+      MessageDigest md = MessageDigest.getInstance("MD5");
+      for (byte[] part : parts) {
+        md.update(part);
+      }
+      return md.digest();
+    } catch (Exception e) {
+      throw new IllegalStateException("MD5 is mandatory on every JRE", e);
+    }
+  }
+
+  /** RC4, 25 lines, because javax.crypto's ARCFOUR is not guaranteed present. */
+  private static byte[] rc4(byte[] key, byte[] data) {
+    int[] s = new int[256];
+    for (int i = 0; i < 256; i++) {
+      s[i] = i;
+    }
+    for (int i = 0, j = 0; i < 256; i++) {
+      j = (j + s[i] + (key[i % key.length] & 0xff)) & 0xff;
+      int t = s[i];
+      s[i] = s[j];
+      s[j] = t;
+    }
+    byte[] out = new byte[data.length];
+    for (int n = 0, i = 0, j = 0; n < data.length; n++) {
+      i = (i + 1) & 0xff;
+      j = (j + s[i]) & 0xff;
+      int t = s[i];
+      s[i] = s[j];
+      s[j] = t;
+      out[n] = (byte) (data[n] ^ s[(s[i] + s[j]) & 0xff]);
+    }
+    return out;
+  }
+
+  private static byte[] leInt(int value) {
+    return new byte[] {
+      (byte) value, (byte) (value >> 8), (byte) (value >> 16), (byte) (value >> 24)
+    };
+  }
+
+  private static String hex(byte[] b) {
+    StringBuilder sb = new StringBuilder(b.length * 2);
+    for (byte x : b) {
+      sb.append(String.format("%02X", x));
+    }
+    return sb.toString();
+  }
+
+  /**
+   * A PDF encrypted with the standard security handler and a NON-EMPTY user
+   * password, so opening it with no password must fail.
+   *
+   * The empty-user-password case would open cleanly on every viewer and prove
+   * nothing. The O and U values are computed properly (Algorithms 2, 3 and 4 of
+   * the spec) rather than filled with plausible-looking bytes, because a viewer
+   * that validates them and one that merely notices /Encrypt would then give
+   * different answers and the test would only be pinning the weaker of the two.
+   */
+  static File encrypted(Context ctx, String name) throws IOException {
+    return encrypted(ctx, name, 0);
+  }
+
+  /**
+   * @param paddingBytes comment bytes inserted between the last object and the
+   *     xref table, so the file — and therefore its TRAILER, which is where
+   *     {@code /Encrypt} lives — can be pushed to any chosen length.
+   *     {@link PdfPreflight} reads a 32 KB head and a 256 KB tail, so a value
+   *     around 60 KB lands the trailer in the band that only the tail scan
+   *     reaches. Nothing else in the document changes.
+   */
+  static File encrypted(Context ctx, String name, int paddingBytes) throws IOException {
+    byte[] id = new byte[16];
+    for (int i = 0; i < id.length; i++) {
+      id[i] = (byte) (i * 17 + 3);
+    }
+    int permissions = -1;
+
+    // Algorithm 3: the owner-password entry.
+    byte[] ownerKey = new byte[5];
+    System.arraycopy(md5(pad("owner")), 0, ownerKey, 0, 5);
+    byte[] o = rc4(ownerKey, pad(USER_PASSWORD));
+
+    // Algorithm 2: the file encryption key.
+    byte[] fileKey = new byte[5];
+    System.arraycopy(md5(pad(USER_PASSWORD), o, leInt(permissions), id), 0, fileKey, 0, 5);
+
+    // Algorithm 4 (R=2): the user-password entry.
+    byte[] u = rc4(fileKey, PAD);
+
+    String content =
+        "1 1 1 rg 0 0 " + LETTER_W + " " + LETTER_H + " re f\n"
+            + "0 0 0 rg 100 100 200 200 re f\n";
+    byte[] plain = content.getBytes(LATIN1);
+
+    Writer w = new Writer();
+
+    // Algorithm 1: per-object key = MD5(fileKey + objNum LE24 + gen LE16)[0..9].
+    int contentsNumber = 1;
+    byte[] objKey = new byte[10];
+    System.arraycopy(
+        md5(
+            fileKey,
+            new byte[] {
+              (byte) contentsNumber, (byte) (contentsNumber >> 8),
+              (byte) (contentsNumber >> 16), 0, 0
+            }),
+        0,
+        objKey,
+        0,
+        10);
+    byte[] cipher = rc4(objKey, plain);
+
+    ByteArrayOutputStream body = new ByteArrayOutputStream();
+    byte[] head = ("<< /Length " + cipher.length + " >>\nstream\n").getBytes(LATIN1);
+    body.write(head, 0, head.length);
+    body.write(cipher, 0, cipher.length);
+    byte[] tail = "\nendstream".getBytes(LATIN1);
+    body.write(tail, 0, tail.length);
+    int contents = w.add(body.toByteArray());
+    if (contents != contentsNumber) {
+      throw new IllegalStateException("Contents object is " + contents);
+    }
+
+    int page = w.add("<< /Type /Page /Parent 3 0 R /MediaBox [0 0 " + LETTER_W + " "
+        + LETTER_H + "] /Contents " + contents + " 0 R /Resources << >> >>");
+    int pages = w.add("<< /Type /Pages /Kids [" + page + " 0 R] /Count 1 >>");
+    int catalog = w.add("<< /Type /Catalog /Pages " + pages + " 0 R >>");
+    int encrypt =
+        w.add("<< /Filter /Standard /V 1 /R 2 /Length 40 /P " + permissions
+            + " /O <" + hex(o) + "> /U <" + hex(u) + "> >>");
+    if (pages != 3) {
+      throw new IllegalStateException("Pages object is " + pages + ", not 3");
+    }
+    if (paddingBytes > 0) {
+      w.pad(paddingBytes);
+    }
+
+    String trailer = "/Encrypt " + encrypt + " 0 R /ID [<" + hex(id) + "> <" + hex(id) + ">]";
+    return writeFile(ctx, name, w.finish(catalog, trailer));
+  }
+
+  /* ---------------------------------------------------------------- *
+   * Non-PDFs
+   * ---------------------------------------------------------------- */
+
+  /**
+   * Deliberately has no %PDF header AND no recoverable objects. PDFium rebuilds
+   * a broken xref rather than giving up, so a file that merely has a bad trailer
+   * would open fine and the "corrupt" branch would never be reached.
+   */
+  static File notAPdf(Context ctx, String name) throws IOException {
+    StringBuilder sb = new StringBuilder();
+    for (int i = 0; i < 200; i++) {
+      sb.append("this is not a pdf, line ").append(i).append('\n');
+    }
+    return writeFile(ctx, name, sb.toString().getBytes(LATIN1));
+  }
+
+  static File empty(Context ctx, String name) throws IOException {
+    return writeFile(ctx, name, new byte[0]);
+  }
+
+  static File missing(Context ctx, String name) {
+    File f = new File(ctx.getCacheDir(), name);
+    //noinspection ResultOfMethodCallIgnored
+    f.delete();
+    return f;
+  }
+
+  private static File writeFile(Context ctx, String name, byte[] bytes) throws IOException {
+    File out = new File(ctx.getCacheDir(), name);
+    try (FileOutputStream fos = new FileOutputStream(out)) {
+      fos.write(bytes);
+    }
+    return out;
+  }
+}

package/android/src/jsi/cpp/CMakeLists.txt

@@ -0,0 +1,33 @@
+# The raster transport's native half. See pdfcanvas-jsi.cpp for what it does.
+#
+# PDFCANVAS_WITH_JSI is passed ON only by the autolinked build, where
+# ReactAndroid's prefab publishes jsi/jsi.h and libjsi.so. The standalone build
+# (`cd android && ./gradlew connectedDebugAndroidTest`) passes nothing, has no
+# React Native anywhere on its classpath, and still compiles this library — the
+# slot storage and its JNI surface are React-free, which is what lets the device
+# suite prove the transport's byte fidelity with no app in the picture.
+
+cmake_minimum_required(VERSION 3.13)
+project(pdfcanvasjsi)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+add_library(pdfcanvasjsi SHARED pdfcanvas-jsi.cpp)
+
+# jnigraphics is the NDK's Bitmap accessor (AndroidBitmap_getInfo /
+# AndroidBitmap_lockPixels), which is how the one-copy path reads a raster
+# straight out of the Bitmap's own pixel memory. Part of the platform since
+# API 8 and present on every device this package supports, so it is linked in
+# BOTH configurations — the standalone build needs it too, and that is what lets
+# the instrumented suite prove the fill's byte fidelity with no app in the
+# picture.
+target_link_libraries(pdfcanvasjsi jnigraphics)
+
+if(PDFCANVAS_WITH_JSI)
+  target_compile_definitions(pdfcanvasjsi PRIVATE PDFCANVAS_WITH_JSI=1)
+  # CONFIG mode against the react-android AAR's prefab package. `jsi` is the
+  # only target needed: nothing here touches TurboModules, fbjni or folly.
+  find_package(ReactAndroid REQUIRED CONFIG)
+  target_link_libraries(pdfcanvasjsi ReactAndroid::jsi)
+endif()