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

package/dist/rasterizer/web/session.js

@@ -0,0 +1,413 @@
+/**
+ * The worker's own logic, with `self` factored out.
+ *
+ * `./worker.ts` is nothing but the four lines that bind this to a real
+ * `DedicatedWorkerGlobalScope`; everything a bug could live in — the queue, the
+ * cancellation window, the fetch, the error mapping, the open-before-render
+ * ordering — is here, takes its dependencies as arguments, and runs in vitest
+ * under plain node against the REAL PDFium module.
+ *
+ * ------------------------------------------------------------------------
+ * THE YIELD IS THE CANCELLATION MECHANISM
+ * ------------------------------------------------------------------------
+ *
+ * A worker processes messages one at a time and `FPDF_RenderPageBitmap` is
+ * synchronous, so nothing can interrupt a render that has started. What CAN be
+ * stopped is a render that has not started — and only if the `cancel` message
+ * gets read first. Handling each `render` message by rendering inside the
+ * handler would make that impossible: messages are FIFO, so three queued renders
+ * would all complete before a `cancel` posted after them was ever looked at.
+ *
+ * So renders are QUEUED here and drained one per macrotask, with a yield between
+ * them. That yield is the only window in which a `cancel` can land, and it is
+ * exactly what `RasterizerCapabilities.interruptibleRender: false` means in
+ * practice: cancellation happens between requests, never inside one.
+ *
+ * See `macrotaskYield` below for what that yield is actually made of, and why it
+ * is not the `setTimeout(0)` it used to be.
+ */
+import { openPdfiumDocument } from './engine.js';
+import { PdfError } from '../../types.js';
+/**
+ * One macrotask turn, the plain way. THE FALLBACK, and half of the default.
+ *
+ * Correct, and slow the moment it repeats: Chrome clamps a timer whose NESTING
+ * LEVEL exceeds 5 to a 4 ms floor, and a chain of these only ever nests deeper,
+ * because each one is scheduled from inside the task the previous one's timer
+ * started. Measured in real headless Chrome inside a real `{type: 'module'}`
+ * worker (harness `/c/tmp/mc/web`, 24 consecutive yields): the first six are
+ * free (0.10 0.00 0.00 0.00 0.00 0.00 ms) and every one after costs 4.0-6.2 ms
+ * — 90.0 ms total, mean 3.75 ms. `drain` yields once per tile, so a 4-10 tile
+ * detail epoch burnt ~0-20 ms of pure worker idle and a 32-piece base grid
+ * ~130 ms.
+ */
+const timerYield = () => new Promise(resolve => {
+    setTimeout(resolve, 0);
+});
+/**
+ * ONE channel for the whole module, built on first use and never torn down.
+ *
+ * `undefined` = not tried yet; `null` = this runtime has no usable
+ * `MessageChannel`, so `macrotaskYield` is timer-only. A fresh channel per yield
+ * would allocate two ports per tile, which is a cost of exactly the kind this
+ * change exists to remove, so it is built once.
+ */
+let sharedChannel;
+function openYieldChannel() {
+    const Ctor = globalThis.MessageChannel;
+    // ABSENT ONLY IN OLD OR EXOTIC RUNTIMES. `MessageChannel` is a global in every
+    // browser, in `DedicatedWorkerGlobalScope`, and in Node >= 15 (re-exported
+    // from `worker_threads`) — measured `typeof MessageChannel === 'function'` on
+    // node v24.14.0, which is what vitest runs here. It is NOT in React Native's
+    // Hermes global scope, but nothing on the native path reaches this file:
+    // `session.ts` is web-only, behind the `browser`/`default` export condition.
+    // So the fallback is for a runtime nobody has named, not for a platform we
+    // ship to — and it is a fallback rather than a throw because a missing yield
+    // would break rendering, not just slow it down.
+    if (typeof Ctor !== 'function')
+        return null;
+    try {
+        const { port1, port2 } = new Ctor();
+        const waiters = [];
+        port1.onmessage = () => {
+            // FIFO, and `wake` posts exactly one message per waiter, so message N
+            // wakes waiter N. Concurrent yields therefore cannot cross-resolve: they
+            // are matched by POSITION, not by identity. (`drain` is single-flight per
+            // session, so the case that makes this reachable at all is two sessions in
+            // one worker — the channel is per MODULE, not per session.) Even a
+            // mismatch would still be a correct yield, since every waiter is asking
+            // for the same thing and nothing is carried across, but matching by
+            // position means the question never has to be argued.
+            waiters.shift()?.();
+            // NODE ONLY, AND LOAD-BEARING. A `MessagePort` with a live `onmessage`
+            // refs the libuv loop, so an always-armed module-scope channel keeps the
+            // process alive forever — measured: `node` with nothing open but an armed
+            // port never exits (killed by a timeout at exit 124). Unref-ing
+            // permanently is the opposite failure: the loop then drains and exits with
+            // a yield still outstanding, stranding `drain` — also measured, the
+            // posted message is simply never delivered. So the port is ref'd exactly
+            // while a yield is in flight and unref'd the moment none is.
+            if (waiters.length === 0)
+                port1.unref?.();
+        };
+        port1.unref?.();
+        return {
+            waiters,
+            wake: () => {
+                port1.ref?.();
+                port2.postMessage(0);
+            },
+        };
+    }
+    catch {
+        // A runtime that has the constructor but refuses to build one. Nothing is
+        // known to do this; falling back still beats throwing out of a render.
+        return null;
+    }
+}
+/**
+ * THE CANCEL WINDOW: a port hop, and then a timer turn.
+ *
+ * WHY A PORT HOP. It is a macrotask that no clamp applies to. Same Chrome
+ * worker, same 24 consecutive yields as `timerYield`'s 90.0 ms: 0.2 ms total,
+ * mean 0.008 ms.
+ *
+ * WHY A TIMER TURN AS WELL. Because a port hop ALONE does not drain the timer
+ * queue, and the timer queue is where the `cancel` is. Measured on node v24.14.0
+ * with K `setTimeout(0)` callbacks already pending when the yield starts, 20
+ * trials at each K in {1, 2, 4, 8, 16, 32}: a timer yield runs ALL K of them
+ * before it resolves, in every trial; a bare port hop runs ZERO of them, in
+ * every trial. A port-only yield would have narrowed the very window this file
+ * exists to keep open, and would have done it quietly — the abort test in
+ * `web-rasterizer.test.ts` delivers its cancels over a `setTimeout`-backed
+ * channel, so a bare hop turns that test flaky rather than loudly wrong.
+ *
+ * AND THE TIMER TURN IS FREE, which is the whole reason this shape works: the
+ * hop RESETS the nesting level Chrome clamps on, because the timer is always
+ * scheduled from a port-message task and never from another timer task.
+ * Measured in the same worker over the same 24 yields: 0.1-0.3 ms total, mean
+ * 0.004-0.013 ms — indistinguishable from the bare hop, and ~280x cheaper than
+ * the bare timer it replaces.
+ *
+ * So this is STRICTLY STRONGER than what it replaces — a hop AND a full timer
+ * turn, where there was only a timer turn — at 1/280th the cost, and its worst
+ * case (a runtime that clamps the following timer anyway) is exactly the
+ * behaviour that shipped before it.
+ *
+ * Exported for `web-rasterizer.test.ts`, which asserts the drained-timer
+ * property above directly. Still not public: nothing in the package's `exports`
+ * map reaches `session.ts` except `./worker`, which re-exports nothing.
+ */
+export const macrotaskYield = async () => {
+    if (sharedChannel === undefined)
+        sharedChannel = openYieldChannel();
+    const channel = sharedChannel;
+    if (channel !== null) {
+        await new Promise(resolve => {
+            channel.waiters.push(resolve);
+            channel.wake();
+        });
+    }
+    await timerYield();
+};
+const resolveFetch = (injected) => {
+    if (injected !== undefined)
+        return injected;
+    const found = globalThis.fetch;
+    if (typeof found !== 'function') {
+        throw new PdfError('unsupported', 'This runtime has no global `fetch`, so a document given as a `uri` ' +
+            'cannot be loaded. Pass the document as `{data}` instead.');
+    }
+    return found;
+};
+/**
+ * Anything thrown, as the two fields the wire carries.
+ *
+ * A `PdfError` keeps its code — that is the whole point of the union being
+ * frozen and shared. Anything else is a bug or a WASM abort, and becomes
+ * `backend-failure` with its message preserved, because a swallowed message here
+ * is a support ticket that says only "rendering failed".
+ */
+function describe(error) {
+    if (error instanceof PdfError) {
+        return { code: error.code, message: error.message };
+    }
+    const message = error?.message ?? String(error);
+    return { code: 'backend-failure', message: String(message) };
+}
+export function createWorkerSession(deps) {
+    const yieldToEventLoop = deps.yieldToEventLoop ?? macrotaskYield;
+    let opening = null;
+    let document = null;
+    let disposed = false;
+    const queue = [];
+    /**
+     * Ids the main thread has given up on.
+     *
+     * A SET AND NOT A FLAG ON THE JOB, because a `cancel` can arrive before its
+     * `render` does — the main thread aborts on its own clock and both messages
+     * are just messages. An entry is consumed when the matching job is dequeued;
+     * one that never matches is dropped when the session is disposed.
+     */
+    const cancelled = new Set();
+    /**
+     * The job `drain` is currently awaiting, or null.
+     *
+     * Exists so `cancel` can tell a job that is STILL CANCELLABLE (queued, or in
+     * flight across the `requireDocument` await) from one that has already been
+     * answered. Without it every cancel for an already-finished render left a
+     * permanent entry in `cancelled`: the deletes all live on the dequeue path,
+     * so an id that never gets dequeued again is never removed, and a long-lived
+     * document's set grows with every abort a gesture produces.
+     */
+    let inFlight = null;
+    let draining = false;
+    const postError = (id, error) => {
+        const { code, message } = describe(error);
+        deps.post({ kind: 'error', id, code, message });
+    };
+    async function readSource(request) {
+        if ('bytes' in request.source) {
+            return new Uint8Array(request.source.bytes);
+        }
+        const url = request.source.url;
+        let response;
+        try {
+            response = await resolveFetch(deps.fetch)(url);
+        }
+        catch (error) {
+            // A network failure, a CORS refusal or a bad scheme. All indistinguishable
+            // from JS by design, so the message carries the URL and nothing pretends
+            // to know which it was.
+            throw new PdfError('backend-failure', `Could not fetch the document from ${url}: ` +
+                `${error?.message ?? String(error)}.`, { cause: error });
+        }
+        if (!response.ok) {
+            throw new PdfError(
+            // 404 and 410 are the two that mean the document is not there. An
+            // expired Firebase download token is a 403, which is a real failure but
+            // not a missing document, so it stays `backend-failure` and says so.
+            response.status === 404 || response.status === 410
+                ? 'not-found'
+                : 'backend-failure', `Fetching the document from ${url} returned ` +
+                `${response.status} ${response.statusText}.`);
+        }
+        return new Uint8Array(await response.arrayBuffer());
+    }
+    async function open(request) {
+        // Both awaits before any PDFium call, and in this order for a reason worth
+        // keeping: the wasm compile and the document fetch are independent, so they
+        // run concurrently rather than one after the other.
+        const [binding, bytes] = await Promise.all([
+            deps.loadPdfium(request.wasm),
+            readSource(request),
+        ]);
+        if (disposed) {
+            throw new PdfError('cancelled', 'The session was closed while opening.');
+        }
+        return openPdfiumDocument(binding, bytes, request.password);
+    }
+    async function requireDocument() {
+        if (opening === null) {
+            throw new PdfError('backend-failure', 'A render arrived before the document was opened.');
+        }
+        return opening;
+    }
+    async function drain() {
+        if (draining)
+            return;
+        draining = true;
+        try {
+            while (queue.length > 0 && !disposed) {
+                const job = queue.shift();
+                if (job === undefined)
+                    break;
+                if (cancelled.delete(job.id))
+                    continue;
+                inFlight = job.id;
+                // `finally`, not a trailing assignment: the body below leaves by
+                // `continue`, by `return` and by throwing, and an `inFlight` left
+                // pointing at a finished job would let a late cancel be recorded for an
+                // id nothing can consume — the same unbounded growth from the other end.
+                try {
+                    let target;
+                    try {
+                        target = await requireDocument();
+                    }
+                    catch (error) {
+                        postError(job.id, error);
+                        continue;
+                    }
+                    // Re-checked after the await: both of these can become true while the
+                    // open is in flight, and rendering into a disposed session would be a
+                    // use-after-free rather than a wasted tile.
+                    if (disposed)
+                        return;
+                    if (cancelled.delete(job.id))
+                        continue;
+                    try {
+                        const raster = target.render(job.request);
+                        const buffer = raster.bytes.buffer;
+                        deps.post({
+                            kind: 'rendered',
+                            id: job.id,
+                            bytes: buffer,
+                            width: raster.width,
+                            height: raster.height,
+                            rowBytes: raster.rowBytes,
+                            format: raster.format,
+                            alpha: raster.alpha,
+                        }, [buffer]);
+                    }
+                    catch (error) {
+                        postError(job.id, error);
+                    }
+                }
+                finally {
+                    inFlight = null;
+                }
+                // THE CANCEL WINDOW. See the header.
+                //
+                // UNCONDITIONAL, AND `if (queue.length > 0)` IS NOT AN OPTIMISATION HERE
+                // — it is a correctness bug. AN EMPTY QUEUE DOES NOT MEAN NOTHING IS
+                // COMING: messages arrive one per event-loop turn, so the queue is fed
+                // SERIALLY and `drain` sees a queue of exactly ONE almost every time it
+                // looks. Measured in a real Chrome `{type:'module'}` worker
+                // (`/c/tmp/mc/web`): three renders posted back-to-back from the main
+                // thread were RECEIVED at t=0, t=60 and t=120 ms with a 60 ms render
+                // between each — one delivery per turn, never a batch, and identically
+                // so under all three candidate yields.
+                //
+                // Skip the yield when that queue is empty and `drain` returns after
+                // every single tile, `draining` goes false, and the next render is then
+                // rendered synchronously inside its own message handler — with the
+                // `cancel` still sitting untouched behind it. This trailing yield is
+                // what holds `draining` true for one macrotask, so everything that
+                // arrives in that turn is batched and re-checked against `cancelled`
+                // before any of it is rendered.
+                //
+                // MEASURED, not argued: adding that guard turns 'renders only the tile
+                // that was not aborted' red (3 tiles rendered instead of 1) and leaves
+                // the other 348 tests green — the same signature as deleting this line
+                // outright. The turn it "wastes" after the genuinely last tile costs
+                // 0.008 ms now that the yield is not a clamped timer, which is the whole
+                // of what audit item A9 was worth. 'yields after the last job too, so a
+                // serially fed queue can still be cancelled' pins this.
+                await yieldToEventLoop();
+            }
+        }
+        finally {
+            draining = false;
+        }
+    }
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        queue.length = 0;
+        cancelled.clear();
+        document?.close();
+        document = null;
+        // An open still in flight closes itself when it lands — see the `disposed`
+        // check in the resolve handler. Swallow its rejection so a discarded worker
+        // never produces an unhandled rejection.
+        opening?.catch(() => { });
+    }
+    return {
+        handle(request) {
+            if (disposed)
+                return;
+            switch (request.kind) {
+                case 'open': {
+                    if (opening !== null) {
+                        postError(request.id, new PdfError('backend-failure', 'This worker already has a document open. A worker owns ' +
+                            'exactly one document, for the whole of its life.'));
+                        return;
+                    }
+                    opening = open(request);
+                    opening.then(opened => {
+                        document = opened;
+                        if (disposed) {
+                            // Lost the race with a close. Nothing has been posted, so the
+                            // main thread never learns about a document it already
+                            // abandoned — but the heap allocation is real and must go.
+                            opened.close();
+                            return;
+                        }
+                        deps.post({
+                            kind: 'opened',
+                            id: request.id,
+                            pageCount: opened.pageCount,
+                            // A copy, because the array crosses a structured-clone boundary
+                            // and the engine's own is readonly on purpose.
+                            pages: opened.pages.map(page => ({ ...page })),
+                        });
+                    }, error => {
+                        postError(request.id, error);
+                    });
+                    return;
+                }
+                case 'render': {
+                    queue.push(request);
+                    void drain();
+                    return;
+                }
+                case 'cancel': {
+                    // Only if something can still consume it. A cancel that arrives after
+                    // its render was answered has nothing to match, and recording it
+                    // anyway is what made this set grow without bound.
+                    if (inFlight === request.id ||
+                        queue.some(job => job.id === request.id)) {
+                        cancelled.add(request.id);
+                    }
+                    return;
+                }
+                case 'close': {
+                    dispose();
+                    return;
+                }
+            }
+        },
+        dispose,
+    };
+}

package/dist/rasterizer/web/worker.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `@reekon-tools/react-native-pdf-canvas/worker` — the module worker entry.
+ *
+ * THE ONLY MODULE IN THIS PACKAGE THAT NAMES `@embedpdf/pdfium`. It is an
+ * OPTIONAL peer dependency: a consumer who ships native only never resolves this
+ * file, and nothing else in the package imports it — not even for a type (see
+ * `PdfiumWasmModule` in `./pdfium.ts`).
+ *
+ * It is also the file that PROVES the hand-written binding matches the real
+ * module. `bindPdfium` takes a structural type, which is what keeps `./engine.ts`
+ * pure and testable; the risk of a structural type is silent drift, and the
+ * answer to that is right below — this file passes the genuine
+ * `WrappedPdfiumModule` to it and `tsc --noEmit` checks every name, arity and
+ * return type. A renamed export or a changed signature in a `@embedpdf/pdfium`
+ * bump fails the BUILD, not the browser.
+ *
+ * ------------------------------------------------------------------------
+ * HOW A HOST REACHES IT
+ * ------------------------------------------------------------------------
+ *
+ *     import PdfCanvasWorker from
+ *       '@reekon-tools/react-native-pdf-canvas/worker?worker';   // Vite
+ *
+ *     configureWebPdfium({
+ *       createWorker: () => new PdfCanvasWorker(),
+ *       wasm: {url: pdfiumWasmUrl},
+ *     });
+ *
+ * Any other way of producing a MODULE worker is equally fine — the package takes
+ * a factory and never builds a URL of its own. See `./client.ts`.
+ *
+ * ------------------------------------------------------------------------
+ * WHY THERE IS ALMOST NOTHING HERE
+ * ------------------------------------------------------------------------
+ *
+ * Because a worker entry is the one part of this backend that cannot run under
+ * vitest in node — there is no DOM `Worker`, and `node:worker_threads` speaks a
+ * different API. So everything that could hold a bug lives in `./session.ts` and
+ * `./engine.ts`, which take their dependencies as arguments and are driven in
+ * node against the REAL PDFium module by an in-process worker stub. What is left
+ * unexercised is exactly the glue below: two `self` bindings and the wasm
+ * options.
+ */
+export {};

package/dist/rasterizer/web/worker.js

@@ -0,0 +1,76 @@
+/**
+ * `@reekon-tools/react-native-pdf-canvas/worker` — the module worker entry.
+ *
+ * THE ONLY MODULE IN THIS PACKAGE THAT NAMES `@embedpdf/pdfium`. It is an
+ * OPTIONAL peer dependency: a consumer who ships native only never resolves this
+ * file, and nothing else in the package imports it — not even for a type (see
+ * `PdfiumWasmModule` in `./pdfium.ts`).
+ *
+ * It is also the file that PROVES the hand-written binding matches the real
+ * module. `bindPdfium` takes a structural type, which is what keeps `./engine.ts`
+ * pure and testable; the risk of a structural type is silent drift, and the
+ * answer to that is right below — this file passes the genuine
+ * `WrappedPdfiumModule` to it and `tsc --noEmit` checks every name, arity and
+ * return type. A renamed export or a changed signature in a `@embedpdf/pdfium`
+ * bump fails the BUILD, not the browser.
+ *
+ * ------------------------------------------------------------------------
+ * HOW A HOST REACHES IT
+ * ------------------------------------------------------------------------
+ *
+ *     import PdfCanvasWorker from
+ *       '@reekon-tools/react-native-pdf-canvas/worker?worker';   // Vite
+ *
+ *     configureWebPdfium({
+ *       createWorker: () => new PdfCanvasWorker(),
+ *       wasm: {url: pdfiumWasmUrl},
+ *     });
+ *
+ * Any other way of producing a MODULE worker is equally fine — the package takes
+ * a factory and never builds a URL of its own. See `./client.ts`.
+ *
+ * ------------------------------------------------------------------------
+ * WHY THERE IS ALMOST NOTHING HERE
+ * ------------------------------------------------------------------------
+ *
+ * Because a worker entry is the one part of this backend that cannot run under
+ * vitest in node — there is no DOM `Worker`, and `node:worker_threads` speaks a
+ * different API. So everything that could hold a bug lives in `./session.ts` and
+ * `./engine.ts`, which take their dependencies as arguments and are driven in
+ * node against the REAL PDFium module by an in-process worker stub. What is left
+ * unexercised is exactly the glue below: two `self` bindings and the wasm
+ * options.
+ */
+import { init } from '@embedpdf/pdfium';
+import { bindPdfium } from './pdfium.js';
+import { createWorkerSession } from './session.js';
+/**
+ * Compile the wasm and initialise the library.
+ *
+ * `{url}` goes through Emscripten's `locateFile` so it can stream-compile;
+ * `{binary}` skips the fetch entirely and is what the node tests use. Neither
+ * form is guessed at — `DEFAULT_PDFIUM_WASM_URL` in `@embedpdf/pdfium` points at
+ * a jsdelivr copy pinned to ITS version, and silently fetching a different build
+ * than the JS bindings expect is precisely the failure the host-supplied locator
+ * exists to prevent.
+ *
+ * `PDFiumExt_Init()` is `@embedpdf/pdfium`'s initialiser and stands in for
+ * `FPDF_InitLibrary`. Once per module instance, before any other call.
+ */
+async function loadPdfium(wasm) {
+    const module = await init('binary' in wasm ? { wasmBinary: wasm.binary } : { locateFile: () => wasm.url });
+    module.PDFiumExt_Init();
+    return bindPdfium(module);
+}
+const session = createWorkerSession({
+    post: (response, transfer) => {
+        self.postMessage(response, transfer);
+    },
+    loadPdfium,
+});
+self.addEventListener('message', event => {
+    const data = event?.data;
+    if (data === undefined || data === null)
+        return;
+    session.handle(data);
+});

package/dist/react/PdfContentView.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The ONE component.
+ *
+ * It draws whatever `content` says, at the doc-space rects `content` carries, and
+ * it does nothing else. No gestures, no viewport, no shared values, no `<Canvas>`.
+ * It is meant to be mounted inside SOMEBODY ELSE'S `<Group transform={...}>`:
+ *
+ *   <Canvas>
+ *     <Group transform={worldTransform}>
+ *       <PdfContentView content={content} />
+ *       ...the host's own annotation layers...
+ *     </Group>
+ *   </Canvas>
+ *
+ * THE ONE RULE: the transform decides WHEN to rasterize, never WHAT to draw. Every
+ * number this component hands to Skia is a plain JS number read off a frozen
+ * `PdfContent`, so a pan or a zoom re-records the host's scene without this
+ * subtree changing at all.
+ */
+import type { ReactNode } from 'react';
+import type { GroupProps } from '@shopify/react-native-skia';
+import type { PdfContent, Sampling } from '../types.js';
+/**
+ * The blend mode the Skia DOM actually accepts — the uncapitalised string union
+ * (`'srcOver'`, `'multiply'`, …), not the numeric `BlendMode` enum. Derived from
+ * `GroupProps` rather than restated so it cannot drift from the renderer.
+ */
+export type PdfBlendMode = NonNullable<GroupProps['blendMode']>;
+export interface PdfContentViewProps {
+    /**
+     * The frozen snapshot to draw. A new object identity per epoch is the swap
+     * signal; see the `PdfContent` doc in types.ts for why a mutated handle cannot
+     * work.
+     */
+    content: PdfContent;
+    /** Forwarded to the wrapping `<Group>`. */
+    zIndex?: number;
+    /**
+     * How the rasters are resampled when the host transform does not land them at
+     * exactly 1:1.
+     *
+     * MIPMAPS DO NOT WORK HERE AND MUST NOT BE ATTEMPTED. RN Skia's `ImageCmd::draw`
+     * hardcodes `kStrict_SrcRectConstraint`, and Skia's own `SkCanvas.h` says of
+     * that constraint that it "disables mipmaps and anisotropic filtering" — the
+     * sampler is forbidden from reading outside the src rect, which is exactly what
+     * a mip level requires. Passing `MipmapMode.Linear` here does not error; it is
+     * silently ignored, and you get the same aliasing plus the memory of the mip
+     * chain.
+     *
+     * The consequence is structural: MINIFICATION CANNOT BE FIXED BY SAMPLING. It is
+     * fixed by never rastering a layer that will be drawn minified — which is why
+     * the base layer is sized from the fit display scale times `baseQuality` rather
+     * than from a fixed pixel cap. Minification is a scheduling problem here, not a
+     * filtering one.
+     *
+     * @default 'linear'
+     */
+    sampling?: Sampling;
+    /**
+     * Colour of the sheet drawn under each page.
+     *
+     * Defaults to `null`, meaning NOTHING is drawn under an unrastered page. That
+     * default is deliberate: painting opaque white under a PDF with a transparent
+     * background is a real bug, and the consumer has very often already painted a
+     * surface (a `<Fill>`, a page-shadow layer, a themed canvas) that this rect
+     * would cover.
+     *
+     * @default null
+     */
+    paperColor?: string | null;
+    /**
+     * Forwarded to the wrapping `<Group>`.
+     *
+     * CAVEAT: Skia group opacity is folded into each child's paint, not composited
+     * once. Because the base and detail layers deliberately OVERLAP, a value below 1
+     * lets the base show through the detail and the seams become visible. For a
+     * uniform fade, wrap this component in your own `<Group layer={paint}>` so the
+     * whole stack composites once.
+     */
+    opacity?: number;
+    /** Forwarded to the wrapping `<Group>`. */
+    blendMode?: PdfBlendMode;
+    /**
+     * Paint MODIFIER declarations only — `<ColorFilter>` / `<ImageFilter>` /
+     * `<Shader>` / `<PathEffect>` nodes (e.g. an invert filter for a dark-mode PDF).
+     *
+     * They are emitted FIRST, before any drawing, because RN Skia collects
+     * declarations as they are visited and the first drawing consumes them.
+     *
+     * Do NOT pass a `<Paint>`. A Paint child is a *second* paint, so the node is
+     * drawn TWICE — once with the declared paint and once with the inherited one —
+     * and `paintDeclarations.clear()` runs on that first drawing, so the extra paint
+     * would apply to the base raster and to none of the detail rasters. In `__DEV__`
+     * this is warned about.
+     */
+    children?: ReactNode;
+}
+export declare function PdfContentView({ content, zIndex, sampling, paperColor, opacity, blendMode, children, }: PdfContentViewProps): import("react").JSX.Element;