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

package/ios/Tests/PdfCanvasCoreTests/TimingTests.swift

@@ -0,0 +1,179 @@
+import Foundation
+import XCTest
+
+@testable import PdfCanvasCore
+
+/**
+ Numbers, printed rather than asserted.
+
+ THESE ARE NOT PASS/FAIL TESTS AND MUST NOT BECOME ONES. Their counterpart is
+ `PdfCanvasDeviceTimingTest` on Android, whose own lesson is written into
+ `AndroidRasterizerOptions.poolSize`: a synthetic fixture measured two lanes at
+ 1.06x-1.25x while a real drawing measured 0.82x, and the synthetic number would
+ have shipped the wrong default. So what these produce is a SHAPE, on whatever
+ machine ran them, and the numbers that decide anything come from a device with a
+ real document on it — `app/dev-pdf-canvas-probe.tsx` in the consuming app.
+
+ The one thing they do assert is that nothing failed, because a timing loop that
+ silently rendered zero tiles would still print a very fast number.
+ */
+final class TimingTests: XCTestCase {
+
+  private func measure(_ label: String, _ body: () -> Void) -> Double {
+    var best = Double.infinity
+    for _ in 0..<5 {
+      let started = Date()
+      body()
+      best = min(best, Date().timeIntervalSince(started) * 1000)
+    }
+    print("PDFCANVAS-TIMING \(label): \(String(format: "%.2f", best)) ms")
+    return best
+  }
+
+  /**
+   Per-tile cost at the sizes the planner actually asks for.
+
+   `maxPieceDimension` is 1024, so 512² and 1024² are the two that matter, and
+   `minEpochIntervalMs` is defined as the measured p95 of one of them.
+   */
+  func testTileCostBySize() throws {
+    let r = try openFixture(
+      TestPdfs.grid(width: 1728, height: 2592, pitch: 8), name: "timing-tiles.pdf")
+    var rendered = 0
+    for side in [256, 512, 1024] {
+      let scale = 4.0
+      _ = measure("tile \(side)px @4x") {
+        if (try? r.render(
+          request(
+            x: 100, y: 100, width: Double(side) / scale, height: Double(side) / scale,
+            scale: scale),
+          cancellation: nil, sink: nil)) != nil
+        {
+          rendered += 1
+        }
+      }
+    }
+    XCTAssertEqual(rendered, 15, "every measured render must have succeeded")
+    r.close()
+  }
+
+  /**
+   A whole ARCH-D base raster at a plausible fit scale.
+
+   The base layer is `fitZoom * pixelRatio * baseQuality` over the whole sheet, so
+   on a DPR-3 phone an ARCH-D page is roughly 1170x1755 — which is what this
+   approximates. It is the single largest raster the package ever asks a backend
+   for, and therefore the one that sets the worst-case first paint.
+   */
+  func testWholePageBaseRasterCost() throws {
+    let r = try openFixture(
+      TestPdfs.grid(width: 1728, height: 2592, pitch: 8), name: "timing-base.pdf")
+    var rendered = 0
+    _ = measure("ARCH-D base @0.677x (1170x1755)") {
+      if (try? r.render(
+        request(width: 1728, height: 2592, scale: 0.677), cancellation: nil,
+        sink: nil)) != nil
+      {
+        rendered += 1
+      }
+    }
+    XCTAssertEqual(rendered, 5)
+    r.close()
+  }
+
+  /**
+   Lane scaling, over the schedule the controller actually runs: N lanes pulling
+   from one shared cursor of plan items.
+
+   ON THIS MACHINE CoreGraphics parallelises — the probe measured 1.53x at two lanes
+   and 2.28x at four on a dense ARCH-D page, which is the OPPOSITE of Android, where
+   AOSP serialises `PdfRenderer` behind a process-wide PDFium lock that convoys and
+   every lane count above one measures worse. That difference is why
+   `IosRasterizerOptions.poolSize` does not cite any Android evidence.
+   *
+   IT IS STILL NOT A REASON TO RAISE THE DEFAULT. This is a Mac with a lot of cores
+   and a fixture whose tiles cost about a millisecond; a phone under thermal
+   pressure with a real drawing is a different measurement, and it is the one that
+   decides. Printed here so the shape is on record and so a device run has something
+   to be compared against.
+   */
+  func testLaneScaling() throws {
+    let data = TestPdfs.grid(width: 1728, height: 2592, pitch: 4)
+    var items: [(Double, Double)] = []
+    for index in 0..<24 {
+      let column = Double(index % 6) * 256.0
+      let row = Double(index / 6) * 256.0
+      items.append((column, row))
+    }
+    var baseline = 0.0
+    for lanes in [1, 2, 4] {
+      let r = try openFixture(
+        data, name: "timing-lanes-\(lanes).pdf", poolSize: lanes)
+      let lock = NSLock()
+      var completed = 0
+      let ms = measure("\(lanes) lane(s), 24x 1024px tiles @4x") {
+        var cursor = 0
+        DispatchQueue.concurrentPerform(iterations: lanes) { _ in
+          while true {
+            lock.lock()
+            let index = cursor
+            cursor += 1
+            lock.unlock()
+            if index >= items.count { return }
+            let (x, y) = items[index]
+            if (try? r.render(
+              request(x: x, y: y, width: 256, height: 256, scale: 4),
+              cancellation: nil, sink: nil)) != nil
+            {
+              lock.lock()
+              completed += 1
+              lock.unlock()
+            }
+          }
+        }
+      }
+      if lanes == 1 { baseline = ms }
+      print(
+        "PDFCANVAS-TIMING \(lanes) lane(s) relative: "
+          + String(format: "%.2fx", baseline / ms))
+      XCTAssertEqual(
+        completed, items.count * 5, "every tile in every repetition must land")
+      r.close()
+    }
+  }
+
+  /**
+   The two engines' relative cost, which is what makes `annotations: true` a
+   deliberate choice rather than a free one.
+
+   PDFKit has to build and keep a `PDFDocument` alongside the `CGPDFDocumentRef`, so
+   the FIRST annotated render in a lane pays for a second parse. That is why the
+   PDFKit document is lazy — every tile the controller asks for passes
+   `annotations: false` and never triggers it.
+   */
+  func testEngineCostComparison() throws {
+    let r = try openFixture(
+      TestPdfs.grid(width: 1728, height: 2592, pitch: 8), name: "timing-engines.pdf")
+    var rendered = 0
+    // Warm both, so neither measurement includes its parse.
+    _ = try? r.render(
+      request(width: 200, height: 200, scale: 1, annotations: false),
+      cancellation: nil, sink: nil)
+    _ = try? r.render(
+      request(width: 200, height: 200, scale: 1, annotations: true),
+      cancellation: nil, sink: nil)
+
+    for annotations in [false, true] {
+      _ = measure("512px @4x annotations=\(annotations)") {
+        if (try? r.render(
+          request(width: 128, height: 128, scale: 4, annotations: annotations),
+          cancellation: nil, sink: nil)) != nil
+        {
+          rendered += 1
+        }
+      }
+    }
+    XCTAssertEqual(rendered, 10)
+    r.close()
+  }
+}

package/ios/Tests/PdfCanvasCoreTests/TransformTests.swift

@@ -0,0 +1,283 @@
+import CoreGraphics
+import XCTest
+
+@testable import PdfCanvasCore
+
+/**
+ The three affine transforms, checked by mapping corners — no PDF, no bitmap, no
+ CoreGraphics state.
+
+ THIS FILE IS DELIBERATELY FIRST. Every failure mode of a transform produces a
+ plausible-looking image rather than an error: a rotation applied the wrong way
+ round, a crop-box origin left in, a y-flip half a pixel off. Checking them here
+ means a rendering failure further down is a rendering failure, and not this.
+ */
+final class TransformTests: XCTestCase {
+
+  /// A 200x100 box at the origin, so a swap of width and height is visible.
+  private let box = CGRect(x: 0, y: 0, width: 200, height: 100)
+
+  private func mapped(_ point: CGPoint, _ transform: CGAffineTransform) -> CGPoint {
+    point.applying(transform)
+  }
+
+  private func assertPoint(
+    _ actual: CGPoint, _ expected: CGPoint, _ what: String,
+    file: StaticString = #filePath, line: UInt = #line
+  ) {
+    XCTAssertEqual(
+      Double(actual.x), Double(expected.x), accuracy: 1e-9,
+      "\(what): x", file: file, line: line)
+    XCTAssertEqual(
+      Double(actual.y), Double(expected.y), accuracy: 1e-9,
+      "\(what): y", file: file, line: line)
+  }
+
+  // ---------------------------------------------------------------- //
+  // PDF user space -> doc space
+  // ---------------------------------------------------------------- //
+
+  /**
+   Rotation 0 is a pure y-flip through the box's top edge.
+
+   The PDF's bottom-left corner is doc space's bottom-LEFT, and the PDF's top-left
+   is doc (0, 0). An implementation that forgot the flip entirely would map
+   bottom-left to (0, 0), which is the single most likely mistake here.
+   */
+  func testRotationZeroFlipsYAndNothingElse() {
+    let t = PdfCanvasPdfToDocTransform(box, 0)
+    assertPoint(mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 0, y: 0), "PDF top-left")
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 0, y: 100), "PDF bottom-left")
+    assertPoint(
+      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 200, y: 0), "PDF top-right")
+    assertPoint(
+      mapped(CGPoint(x: 200, y: 0), t), CGPoint(x: 200, y: 100), "PDF bottom-right")
+  }
+
+  /**
+   `/Rotate 90` is a CLOCKWISE quarter turn of the displayed page.
+
+   Turning a sheet of paper clockwise sends its bottom-left corner to the top-left
+   and its bottom-right to the bottom-left. Those two are what distinguish 90 from
+   270; a test that only checked the page's SIZE would pass for either.
+   */
+  func testRotation90TurnsClockwise() {
+    let t = PdfCanvasPdfToDocTransform(box, 90)
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 0, y: 0), "PDF bottom-left")
+    assertPoint(
+      mapped(CGPoint(x: 200, y: 0), t), CGPoint(x: 0, y: 200), "PDF bottom-right")
+    assertPoint(
+      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 100, y: 200), "PDF top-right")
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 100, y: 0), "PDF top-left")
+  }
+
+  func testRotation180TurnsHalfway() {
+    let t = PdfCanvasPdfToDocTransform(box, 180)
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 200, y: 0), "PDF bottom-left")
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 200, y: 100), "PDF top-left")
+    assertPoint(
+      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 0, y: 100), "PDF top-right")
+  }
+
+  func testRotation270TurnsCounterClockwise() {
+    let t = PdfCanvasPdfToDocTransform(box, 270)
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 100, y: 200), "PDF bottom-left")
+    assertPoint(
+      mapped(CGPoint(x: 0, y: 100), t), CGPoint(x: 0, y: 200), "PDF top-left")
+    assertPoint(
+      mapped(CGPoint(x: 200, y: 100), t), CGPoint(x: 0, y: 0), "PDF top-right")
+  }
+
+  /**
+   Every rotation is a reflection, not a rotation, in raw coordinates.
+
+   Doc space is y-down and PDF space is y-up, so a determinant of +1 anywhere here
+   would mean the flip had been lost. Cheap, and it catches a whole class of sign
+   errors that the corner checks above could miss if two of them were wrong in
+   compensating ways.
+   */
+  func testEveryRotationHasDeterminantMinusOne() {
+    for rotation in [0, 90, 180, 270] {
+      let t = PdfCanvasPdfToDocTransform(box, rotation)
+      XCTAssertEqual(
+        Double(t.a * t.d - t.b * t.c), -1, accuracy: 1e-9,
+        "rotation \(rotation) should be orientation-reversing")
+    }
+  }
+
+  /**
+   The crop box's own top-left lands at doc (0, 0), whatever its origin is.
+
+   The fixture this mirrors has MediaBox `0 0 400 400` and CropBox
+   `100 150 300 350`. Without the `-minX` / `minY + height` terms the marker at
+   the crop box's top-left would be drawn 100pt right and 50pt down, which on a
+   flat page is invisible.
+   */
+  func testCropBoxOriginIsSubtracted() {
+    let crop = CGRect(x: 100, y: 150, width: 200, height: 200)
+    let t = PdfCanvasPdfToDocTransform(crop, 0)
+    assertPoint(
+      mapped(CGPoint(x: 100, y: 350), t), CGPoint(x: 0, y: 0), "crop top-left")
+    assertPoint(
+      mapped(CGPoint(x: 300, y: 150), t), CGPoint(x: 200, y: 200),
+      "crop bottom-right")
+  }
+
+  /// The same, for a rotated page — where the two corrections interact.
+  func testCropBoxOriginIsSubtractedUnderRotation() {
+    let crop = CGRect(x: 100, y: 150, width: 200, height: 100)
+    // Rotated 90, the page is 100 wide and 200 tall.
+    let t = PdfCanvasPdfToDocTransform(crop, 90)
+    assertPoint(
+      mapped(CGPoint(x: 100, y: 150), t), CGPoint(x: 0, y: 0),
+      "crop bottom-left -> doc top-left")
+    assertPoint(
+      mapped(CGPoint(x: 300, y: 150), t), CGPoint(x: 0, y: 200),
+      "crop bottom-right -> doc bottom-left")
+    assertPoint(
+      mapped(CGPoint(x: 100, y: 250), t), CGPoint(x: 100, y: 0),
+      "crop top-left -> doc top-right")
+  }
+
+  /// A rotation that is not a multiple of 90 is treated as 0 rather than rounded.
+  func testUnusableRotationsFallBackToZero() {
+    let zero = PdfCanvasPdfToDocTransform(box, 0)
+    for rotation in [45, 1, 359, 137] {
+      XCTAssertTrue(
+        PdfCanvasPdfToDocTransform(box, rotation) == zero,
+        "rotation \(rotation) should behave as 0")
+    }
+  }
+
+  /// Negatives and out-of-range multiples normalise rather than falling back.
+  func testRotationsNormalise() {
+    XCTAssertEqual(PdfCanvasNormalizeRotation(-90), 270)
+    XCTAssertEqual(PdfCanvasNormalizeRotation(450), 90)
+    XCTAssertEqual(PdfCanvasNormalizeRotation(-450), 270)
+    XCTAssertEqual(PdfCanvasNormalizeRotation(720), 0)
+    XCTAssertEqual(PdfCanvasNormalizeRotation(45), 0)
+    XCTAssertTrue(
+      PdfCanvasPdfToDocTransform(box, -90) == PdfCanvasPdfToDocTransform(box, 270),
+      "-90 should behave as 270")
+  }
+
+  // ---------------------------------------------------------------- //
+  // Doc space -> raster space
+  // ---------------------------------------------------------------- //
+
+  /**
+   The doc rect's top-left lands at the raster's top-left, and its bottom-right at
+   the bottom-right.
+
+   Stated in CG's own y-up coordinates, because that is what the transform emits:
+   the raster's top-left is (0, H).
+   */
+  func testDocRectMapsOntoTheWholeRaster() {
+    let t = PdfCanvasDocToRasterTransform(37, 23, 4, 164)
+    assertPoint(
+      mapped(CGPoint(x: 37, y: 23), t), CGPoint(x: 0, y: 164), "doc top-left")
+    assertPoint(
+      mapped(CGPoint(x: 37 + 64, y: 23 + 41), t), CGPoint(x: 256, y: 0),
+      "doc bottom-right")
+  }
+
+  /**
+   TWO RASTERS AT THE SAME SCALE AGREE WHERE THEY OVERLAP — the property the cache
+   and the overlapping detail pieces depend on, and the one the rounded
+   `pixelHeight` in the flip looks like it should break.
+   *
+   The two rects below have heights that round in OPPOSITE directions at scale 1
+   (100.4 -> 100, 100.6 -> 101), so a transform that leaked its rounding into
+   content placement would put the same doc point on different rows. The check is
+   in ROWS FROM THE TOP, which is how a raster is indexed and where the `H` term
+   cancels.
+   */
+  func testRastersAtTheSameScaleAgreeWhereTheyOverlap() {
+    let scale = 1.0
+    // Rect A: doc y 0 .. 100.4, 100 rows. Rect B: doc y 50 .. 150.6, 101 rows.
+    let a = PdfCanvasDocToRasterTransform(0, 0, scale, 100)
+    let b = PdfCanvasDocToRasterTransform(0, 50, scale, 101)
+
+    for docY in stride(from: 50.0, through: 100.0, by: 5.0) {
+      let rowFromTopInA = 100 - Double(mapped(CGPoint(x: 0, y: docY), a).y)
+      let rowFromTopInB = 101 - Double(mapped(CGPoint(x: 0, y: docY), b).y)
+      XCTAssertEqual(
+        rowFromTopInA, docY, accuracy: 1e-9,
+        "doc y \(docY) should sit at row \(docY) of A")
+      XCTAssertEqual(
+        rowFromTopInB, docY - 50, accuracy: 1e-9,
+        "doc y \(docY) should sit at row \(docY - 50) of B")
+    }
+  }
+
+  /**
+   Scale is used exactly as requested, never re-derived from the pixel size.
+
+   A doc rect of 512.4 points at scale 4 is 2050 pixels wide (2049.6 rounded), and
+   a re-derived scale would be 2050/512.4 = 4.00078. Over 2050 pixels that is a
+   drift of 1.6 px at the far edge relative to a neighbour drawn at exactly 4 —
+   which is precisely the misregistration the overlap rule cannot absorb.
+   */
+  func testScaleIsNotReDerivedFromThePixelSize() {
+    let scale = 4.0
+    let docWidth = 512.4
+    let r = request(width: docWidth, height: 100, scale: scale)
+    XCTAssertEqual(r.pixelWidth, 2050, "512.4 * 4 = 2049.6, rounds to 2050")
+
+    let t = PdfCanvasDocToRasterTransform(0, 0, scale, r.pixelHeight)
+    // The far edge lands 0.4 px short of the raster's right edge — that is the
+    // half-pixel the comment on `tileMatrix` describes, left showing the fill.
+    XCTAssertEqual(
+      Double(mapped(CGPoint(x: docWidth, y: 0), t).x), 2049.6, accuracy: 1e-9)
+    // A re-derived scale would have landed it at exactly 2050, agreeing with the
+    // raster and disagreeing with every neighbour.
+  }
+
+  // ---------------------------------------------------------------- //
+  // Doc space -> PDFKit's space
+  // ---------------------------------------------------------------- //
+
+  /**
+   PDFKit's transform is a pure flip through the POST-ROTATION page height.
+
+   Nothing else, because PDFKit applies `/Rotate` and the crop-box origin itself —
+   measured, and the asymmetry with `-[PDFPage boundsForBox:]` is the trap this
+   whole function exists to keep out of the rasterizer.
+   */
+  func testPdfKitTransformIsAPureFlip() {
+    let t = PdfCanvasDocToPdfKitTransform(612)
+    assertPoint(mapped(CGPoint(x: 0, y: 0), t), CGPoint(x: 0, y: 612), "doc origin")
+    assertPoint(
+      mapped(CGPoint(x: 792, y: 612), t), CGPoint(x: 792, y: 0),
+      "doc bottom-right")
+    XCTAssertEqual(Double(t.a * t.d - t.b * t.c), -1, accuracy: 1e-9)
+  }
+
+  // ---------------------------------------------------------------- //
+  // Pixel sizing
+  // ---------------------------------------------------------------- //
+
+  /**
+   `round`, at least 1, matching `planner.ts` and `RasterRequest.java`.
+
+   The three have to agree exactly: the planner declares the pixel size in the
+   `RasterPlanItem` the cache is keyed on, so a backend that used `ceil` would
+   return a raster of a different size than the plan promised.
+   */
+  func testPixelExtentsRoundAndFloorAtOne() {
+    XCTAssertEqual(request(width: 100, height: 100, scale: 1).pixelWidth, 100)
+    XCTAssertEqual(request(width: 100.4, height: 1, scale: 1).pixelWidth, 100)
+    XCTAssertEqual(request(width: 100.5, height: 1, scale: 1).pixelWidth, 101)
+    XCTAssertEqual(request(width: 100.6, height: 1, scale: 1).pixelWidth, 101)
+    XCTAssertEqual(request(width: 0.1, height: 0.1, scale: 1).pixelWidth, 1)
+    XCTAssertEqual(request(width: 0.1, height: 0.1, scale: 1).pixelHeight, 1)
+    XCTAssertEqual(request(width: 512.4, height: 1, scale: 4).pixelWidth, 2050)
+    XCTAssertEqual(request(width: 512.5, height: 1, scale: 4).pixelWidth, 2050)
+  }
+}

package/package.json

@@ -0,0 +1,144 @@
+{
+  "name": "@reekon-tools/react-native-pdf-canvas",
+  "version": "0.1.0",
+  "description": "PDF pages as Skia images, drawn at exact doc-space rects inside somebody else's transform. Owns no canvas, no gestures, no viewport state.",
+  "author": "REEKON Tools",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/reekon-tools/software/rock-pro/react-native-pdf-canvas.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "//files-scripts": "`scripts` ships because the peer-floor check runs from a CONSUMER'S postinstall, before/without any build of `dist`.",
+  "//files": "`*.podspec` SHIPS OR iOS IS SILENTLY ABSENT. Autolinking reads the podspec out of the INSTALLED package, so a podspec that is not in this list means `pod install` finds nothing, `PdfCanvas` never appears in Podfile.lock, and `NativeModules.PdfCanvas` is undefined at runtime with no build error anywhere. `ios/Package.swift` and `ios/Tests` ship as part of `ios` and cost a few KB; they are what lets a consumer run the core's host tests against the exact version they installed.",
+  "files": [
+    "dist",
+    "ios",
+    "android",
+    "scripts",
+    "react-native.config.js",
+    "PdfCanvas.podspec",
+    "README.md"
+  ],
+  "bin": {
+    "pdf-canvas-check-skia": "./scripts/check-skia-peer.mjs"
+  },
+  "main": "./dist/index.web.js",
+  "types": "./dist/index.d.ts",
+  "//exports": "`./skia` IS THE ONLY SUBPATH THAT NEEDS A LIVE SKIA RUNTIME, and the root barrel is deliberately free of module-scope Skia so it can be evaluated in Node during rock-desktop's SSR pass — `Skia.web.js` is `export const Skia = JsiSkApi(global.CanvasKit)`, taken ONCE, so reaching it before LoadSkiaWeb resolves breaks it permanently and unrecoverably in-bundle. `src/__tests__/module-ordering.test.ts` bundles the entries below and greps the output, so this is enforced rather than described. `./skia` is platform-split for the same Metro reason `./rasterizer` is (an `exports` condition is matched LITERALLY, with no platform-extension expansion). BOTH of those subpaths put `types` INSIDE each condition branch and carry NO top-level `types` key, and that placement is load-bearing rather than stylistic: TypeScript walks a conditional-exports object IN KEY ORDER and always matches a bare `types`, so a top-level `types` short-circuits the walk and hands EVERY consumer the same declaration file no matter what conditions are configured — a host's `customConditions` cannot rescue it. That is not cosmetic where the two entries genuinely differ: it made `configureWebPdfium` invisible to a browser consumer (TS2305) and dragged React Native's global declarations into a DOM project behind it. `attw` reports 🟢 either way, because it checks that resolution SUCCEEDS and not that it lands on the right platform. The root `.` keeps a single top-level `types` on purpose — its two entries are pure re-exports of the same barrel, so there is only one declaration to point at. `./web-init` is WEB ONLY and has no `react-native` condition on purpose: there is nothing to initialise on native, and a native import should fail loudly rather than resolve to a no-op. `./worker` is the same, and is a bundler ENTRY POINT rather than a module to import for its values — it binds itself to `self` on evaluation, and a host names it once as a worker (`'…/worker?worker'` under Vite, `new Worker(new URL(…), {type: 'module'})` anywhere else). It is the ONLY file in the package that imports `@embedpdf/pdfium`, which is exactly why that peer can be optional: a native-only consumer never resolves this path. NOTE that a `//comment` key may not go INSIDE the exports object — node rejects an exports map whose keys do not all begin with '.'.",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "react-native": "./dist/index.native.js",
+      "browser": "./dist/index.web.js",
+      "default": "./dist/index.web.js"
+    },
+    "./rasterizer": {
+      "react-native": {
+        "types": "./dist/rasterizer/index.native.d.ts",
+        "default": "./dist/rasterizer/index.native.js"
+      },
+      "browser": {
+        "types": "./dist/rasterizer/index.web.d.ts",
+        "default": "./dist/rasterizer/index.web.js"
+      },
+      "default": {
+        "types": "./dist/rasterizer/index.web.d.ts",
+        "default": "./dist/rasterizer/index.web.js"
+      }
+    },
+    "./skia": {
+      "react-native": {
+        "types": "./dist/skia/index.native.d.ts",
+        "default": "./dist/skia/index.native.js"
+      },
+      "browser": {
+        "types": "./dist/skia/index.web.d.ts",
+        "default": "./dist/skia/index.web.js"
+      },
+      "default": {
+        "types": "./dist/skia/index.web.d.ts",
+        "default": "./dist/skia/index.web.js"
+      }
+    },
+    "./web-init": {
+      "types": "./dist/web-init.d.ts",
+      "default": "./dist/web-init.js"
+    },
+    "./worker": {
+      "types": "./dist/rasterizer/web/worker.d.ts",
+      "default": "./dist/rasterizer/web/worker.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "default": "./dist/testing/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "prepare": "tsc",
+    "prepack": "yarn run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "format": "prettier --write .",
+    "check-format": "prettier --check .",
+    "check-exports": "attw --pack . --profile esm-only",
+    "check-peers": "node scripts/check-skia-peer.mjs",
+    "ci": "yarn run check-format && yarn run typecheck && vitest run && yarn run build"
+  },
+  "keywords": [
+    "react-native",
+    "pdf",
+    "skia",
+    "reanimated"
+  ],
+  "//peerDependencies": "THE SKIA RANGE IS THE SINGLE SOURCE OF TRUTH FOR THE FLOOR — scripts/skia-peer-check.mjs and src/peer-check.ts both parse it out of here rather than restating 2.8.0, so a bump is this one line. Keep it a bare '>=x.y.z': the checker refuses to guess at a union or a caret and degrades to a warning. 2.8.0 and not 2.11.0 because 2.8.0 is the exact release carrying the RN Web reconciler dispose fix (verified: Container.web.js goes 1 -> 6 dispose calls and Recorder/FrameScope.js first appears AT 2.8.0, not 2.7.0), and the entire web draw path this package touches — Container.web.js, Reconciler.js, HostConfig.js, FrameScope.js, web JsiSkDataFactory, the MakeImage body of web JsiSkImageFactory, and the ColorType/AlphaType enums — is BYTE-IDENTICAL from 2.8.0 through 2.11.0, with canvaskit-wasm pinned 0.41.0 across the whole range. Nothing after 2.8.0 is required. The floor is a memory-correctness claim, not a compile one: the full suite passes against 2.6.2 and 2.8.0 alike. BOLDR now pins 2.8.0 and satisfies it (it pinned 2.6.2 and did not, until the bump) — see 'Why the skia peer floor is >=2.8.0' in README.md for how the floor is enforced given that yarn 1's link: protocol evaluates neither a linked package's peers nor its lifecycle scripts.",
+  "//embedpdf-peer": "OPTIONAL, AND WEB ONLY. `@embedpdf/pdfium` is imported by exactly one file — `src/rasterizer/web/worker.ts`, reached through the `./worker` subpath — so a consumer who ships native never resolves it and must not be made to install a 4.6 MB wasm package. It is a PEER rather than a dependency for the reason the note above gives: the package must stay dependency-free, and yarn 1 installs none of a `link:` dependency's deps anyway. The range is `>=2.15.0` because that is the version every measurement in `src/rasterizer/web/` was taken against, and because `EPDF_GetPageRotationByIndex` — how `pageGeometry` reads `/Rotate` without loading a page — is an @embedpdf extension rather than stock PDFium. The wasm and the JS bindings must come from the SAME version, which is why the host supplies the locator (see `PdfiumWasmSource`).",
+  "peerDependencies": {
+    "@embedpdf/pdfium": ">=2.15.0",
+    "@shopify/react-native-skia": ">=2.8.0",
+    "react": ">=19.0.0",
+    "react-native": ">=0.78.0",
+    "react-native-reanimated": ">=3.19.1"
+  },
+  "peerDependenciesMeta": {
+    "@embedpdf/pdfium": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    },
+    "react-native-reanimated": {
+      "optional": true
+    }
+  },
+  "//devDependencies": "`vite` is DECLARED even though vitest already brings it: `src/__tests__/module-ordering.test.ts` imports its `build` API directly to bundle each entry point and inspect the module graph, and a test that depends on a transitive dep is one hoisting change away from breaking. The four versions the app ships are EXACT, not carets. A caret is what caused the skew this alignment fixed: '^2.6.2' had drifted to 2.11.0 while BOLDR ran 2.6.2, so 171 tests — every CanvasKit pixel test among them — had been validating a version the app does not ship. A library validated against a floating version is not validated. `semver` is here and NOT in `dependencies` on purpose: the package must stay dependency-free (yarn 1 installs none of a `link:` dependency's deps anyway, so declaring it would buy nothing for BOLDR), so the peer check carries its own comparator and uses semver only when a tree happens to expose one. semver's real job here is to be the REFEREE in peer-check.test.ts, which pins that comparator and the runtime one to its answers.",
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.1",
+    "@embedpdf/pdfium": "2.15.0",
+    "@shopify/react-native-skia": "2.11.0",
+    "@types/emscripten": "^1.41.5",
+    "@types/node": "20.19.43",
+    "@types/react": "19.2.17",
+    "prettier": "^3.5.3",
+    "react": "19.2.3",
+    "react-native": "0.86.2",
+    "react-native-reanimated": "4.5.3",
+    "semver": "^7.7.4",
+    "typescript": "^5.8.3",
+    "vite": "^7.3.6",
+    "vitest": "^3.1.3"
+  },
+  "//engines": "Copied from BOLDR's own engines field rather than invented. @types/node tracks the LOWEST supported major (20.x), not the v24 this machine runs, so tsc rejects a Node 22+/24-only API that the declared floor could not provide.",
+  "engines": {
+    "node": "^20.19.4 || ^22.13.0 || >=24"
+  },
+  "packageManager": "yarn@1.22.22"
+}

package/react-native.config.js

@@ -0,0 +1,40 @@
+/**
+ * Autolinking metadata for the React Native CLI.
+ *
+ * BOTH PLATFORMS NEED AN EXPLICIT ENTRY, for two different reasons.
+ *
+ * ANDROID: `packageImportPath` / `packageInstance` are not optional here, because
+ * of the source-set split. Autolinking discovers a ReactPackage by scanning
+ * `android/src/main/java`, and this package's binding deliberately lives in
+ * `android/src/reactnative/java` so that `src/main` can be built and tested with no
+ * React Native on the classpath at all. Without these two lines the module compiles
+ * into the app and is never registered, and every `open()` fails with "the Android
+ * PdfCanvas native module was not found".
+ *
+ * iOS: `podspecPath` is named explicitly because the podspec is `PdfCanvas.podspec`
+ * rather than a file named after the npm package. Autolinking's default search
+ * takes the first `*.podspec` at the package root, which happens to work today —
+ * there is exactly one — but "happens to work because there is only one candidate"
+ * is the kind of thing that stops being true the moment somebody adds a second, and
+ * the failure is silent: the pod is simply absent from `Podfile.lock` and
+ * `NativeModules.PdfCanvas` is undefined at runtime.
+ *
+ * `ios` was `null` until the CoreGraphics/PDFKit backend landed. If it ever needs
+ * to be null again, the message in `src/rasterizer/index.ts` is what a host sees.
+ */
+const path = require('path');
+
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: 'android',
+        packageImportPath: 'import tools.reekon.pdfcanvas.rn.PdfCanvasPackage;',
+        packageInstance: 'new PdfCanvasPackage()',
+      },
+      ios: {
+        podspecPath: path.join(__dirname, 'PdfCanvas.podspec'),
+      },
+    },
+  },
+};