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

package/dist/cache.js

@@ -0,0 +1,389 @@
+/**
+ * Refcounted, byte-budgeted raster cache.
+ *
+ * Two things make this different from a plain LRU:
+ *
+ * 1. REFCOUNTS, NOT LIVENESS GUESSES. A raster is drawable exactly while some
+ *    PdfContent slot references it. `acquire`/`release` count those slots, so a
+ *    raster held by both the live detail set and the retiring set has refs 2 and
+ *    survives until both are gone. Nothing referenced is ever evicted.
+ *
+ * 2. THE RETIRE QUEUE. A refcount reaching zero does NOT dispose. The entry goes
+ *    to a queue that the controller flushes at a point that already causes a
+ *    React commit, because freeing an SkImage that is still in a mounted Skia
+ *    node draws a corpse. Retirement must never own a timer or a commit of its
+ *    own — see `flushRetired`.
+ *
+ * 3. THE DISPOSAL FENCE, which is what makes point 2 actually true.
+ *
+ *    MEASURED: releasing and flushing in the SAME turn — which is what the
+ *    controller's commit did — is a delay of zero. The entry left `content` and
+ *    was freed before React had even been notified, let alone re-rendered, so
+ *    every Skia node still holding it was holding a deleted object. In a browser
+ *    that is `BindingError: Cannot pass deleted object as a pointer of type
+ *    Image const*`, thrown out of RN Skia's own `drawImage -> Image.width` while
+ *    it RE-RECORDS the picture from the mounted tree: 16 occurrences over six
+ *    high-zoom pans, 3-4 ms after an epoch commit, every time.
+ *
+ *    So the queue is fenced, and the fence is a CLOCK the cache is told about
+ *    rather than one it assumes:
+ *
+ *      release(key, contentEpoch)  tags the entry with the epoch of the content
+ *                                  object that stopped referencing it.
+ *      flushRetired(contentEpoch)  frees only entries tagged STRICTLY OLDER than
+ *                                  `contentEpoch` — i.e. one whole epoch of
+ *                                  grace, which is the commit clock and is a
+ *                                  heuristic: it assumes the renderer mounted
+ *                                  epoch N before the controller published N+1.
+ *      notePresented(epoch)        the SOUND clock, IF a caller can honestly
+ *                                  supply one: everything tagged `epoch` or older
+ *                                  is treated as provably unreferenced and freed
+ *                                  at once — sooner than the commit clock would.
+ *
+ *    "PRESENTED" MEANS DRAWN, NOT MOUNTED, AND THE DIFFERENCE IS MEASURED. Wiring
+ *    this to React — a `PdfContentView` prop reporting `content.epoch` from a
+ *    PASSIVE effect, which is the latest signal a component can produce —
+ *    REINTRODUCES the corpse it exists to prevent. Controlled A/B in rock-desktop's
+ *    probe, 14 high-zoom pans per arm, twice each:
+ *
+ *      onPresented wired    2, 2  `BindingError: ... Image const*`
+ *      commit clock only    0, 0
+ *
+ *    The reason is that the images are held by the RECORDED PICTURE, not by the
+ *    React tree. RN Skia re-records on its own rAF, so after React has committed
+ *    epoch N there is still a picture in hand that references epoch N-1's images,
+ *    and `play()` -> `drawImage` -> `Image.width` reads one that has just been
+ *    freed. Every stack in that A/B was exactly that. A commit is therefore NOT a
+ *    presentation, and no React-reachable signal on web is late enough to be one.
+ *
+ *    So this is NOT wired, deliberately, and must not be wired from an effect. It
+ *    stays for a caller driving `createPdfController` against a renderer that has
+ *    a genuine post-paint callback. Absent that, the commit clock is the correct
+ *    answer and its only cost is holding one epoch's dropped rasters while the
+ *    viewport is at rest.
+ *
+ *    An UNTAGGED release (no epoch) means "nothing of mine is mounted any more",
+ *    and so does a `flushRetired()` with no epoch: both are the teardown path,
+ *    where immediate disposal is the correct answer and the original behaviour.
+ *
+ * The budget is a SOFT cap. Running out never throws and never blanks a page:
+ * the last resort is to refuse the newcomer and keep drawing the base we already
+ * have. Degrade, never crash.
+ */
+const DEFAULT_BASE_RETENTION_RADIUS = 2;
+export function createRasterCache(options) {
+    const { budgetBytes, dispose } = options;
+    const baseRetentionRadius = options.baseRetentionRadius ?? DEFAULT_BASE_RETENTION_RADIUS;
+    const entries = new Map();
+    const retireQueue = new Set();
+    const evictionListeners = new Set();
+    /**
+     * Disposal guard. Keyed on the raster object rather than on an entry flag so a
+     * raster refused by `put` — which never becomes an entry — is covered too.
+     */
+    const alreadyDisposed = new WeakSet();
+    let liveWindow = new Set();
+    let totalBytes = 0;
+    let tick = 0;
+    /**
+     * The two clocks the fence can run on. `presentedEpoch` is null until a
+     * renderer reports one, and from then on it is the ONLY clock — the commit
+     * clock below is a guess about the renderer, and a guess must not be allowed to
+     * overrule the renderer itself when it says it is behind.
+     */
+    let presentedEpoch = null;
+    /** Highest content epoch any caller has named, on a release or a flush. */
+    let latestEpoch = Number.NEGATIVE_INFINITY;
+    function noteEpoch(epoch) {
+        if (Number.isFinite(epoch) && epoch > latestEpoch)
+            latestEpoch = epoch;
+    }
+    /**
+     * The newest epoch tag that may be freed. An entry tagged ABOVE this may still
+     * be referenced by a mounted Skia node, so it is untouchable — by the flush and
+     * by eviction alike, since a corpse does not care which door freed it.
+     */
+    function disposalFence() {
+        if (presentedEpoch !== null)
+            return presentedEpoch;
+        // The commit clock: one whole epoch of grace. -Infinity - 1 is -Infinity, so
+        // before any epoch is named this frees untagged entries and nothing else.
+        return latestEpoch - 1;
+    }
+    function fenced(entry, fence) {
+        return entry.retired && entry.retiredAt > fence;
+    }
+    function disposeOnce(raster) {
+        if (alreadyDisposed.has(raster))
+            return;
+        alreadyDisposed.add(raster);
+        try {
+            dispose(raster);
+        }
+        catch {
+            // Disposal is best-effort teardown. A backend that throws here must not
+            // abort an eviction loop half-way and leave the byte count lying.
+        }
+    }
+    function notifyEviction(raster, reason) {
+        for (const listener of evictionListeners)
+            listener(raster, reason);
+    }
+    /**
+     * A live page's base is the anti-blank mechanism: it is the only thing
+     * guaranteed to be drawable while a detail raster is in flight. It is never
+     * evicted and never flushed, whatever the budget says.
+     */
+    function isProtected(entry) {
+        return entry.raster.role === 'base' && liveWindow.has(entry.raster.page);
+    }
+    function withinBaseRetention(page) {
+        for (const live of liveWindow) {
+            if (Math.abs(live - page) <= baseRetentionRadius)
+                return true;
+        }
+        return false;
+    }
+    function removeEntry(key, entry) {
+        entries.delete(key);
+        retireQueue.delete(key);
+        totalBytes -= entry.raster.bytes;
+        if (totalBytes < 0)
+            totalBytes = 0;
+    }
+    /**
+     * The documented eviction order. Each category considers only unreferenced,
+     * unprotected entries, and picks the least-recently-used within the category
+     * before moving on:
+     *
+     *   1. detail for pages outside the live window   — off screen, worthless
+     *   2. retired entries the fence has cleared       — nothing can be drawing them
+     *   3. base for pages outside the retention radius
+     *   4. retired entries the fence has NOT cleared   — LAST RESORT, see below
+     *   5. (caller's job) refuse the newcomer
+     *
+     * CATEGORY 4 IS WHY THIS CHANGE IS AN ORDERING CHANGE AND NOT A RETENTION ONE.
+     * A fenced entry may still sit in a mounted Skia node, so freeing it is the
+     * corpse this cache exists to avoid — but making it strictly unevictable would
+     * shrink the evictable set, and on a phone at the default 96 MiB budget that
+     * turns into refused detail pieces on a path proven by 57 instrumented tests
+     * and no device to re-run them on. So the set of entries eviction may take is
+     * EXACTLY what it always was, and all that changes is that a possibly-mounted
+     * raster is now the last thing taken rather than the second. It is reached only
+     * when the budget cannot otherwise be met at all — `evict` is 0 across every
+     * browser run of the harness, at dpr 1 and dpr 2.
+     *
+     * O(n) per eviction over an n in the low tens; a heap here would be more code
+     * than it saves.
+     */
+    function pickVictim() {
+        const fence = disposalFence();
+        const categories = [
+            {
+                reason: 'page-window',
+                match: e => !fenced(e, fence) &&
+                    e.raster.role === 'detail' &&
+                    !liveWindow.has(e.raster.page),
+            },
+            { reason: 'epoch', match: e => e.retired && !fenced(e, fence) },
+            {
+                reason: 'page-window',
+                match: e => !fenced(e, fence) &&
+                    e.raster.role === 'base' &&
+                    !withinBaseRetention(e.raster.page),
+            },
+            { reason: 'epoch', match: e => fenced(e, fence) },
+        ];
+        for (const category of categories) {
+            let bestKey = null;
+            let best = null;
+            for (const [key, entry] of entries) {
+                if (entry.refs > 0 || isProtected(entry))
+                    continue;
+                if (!category.match(entry))
+                    continue;
+                if (best === null || entry.usedAt < best.usedAt) {
+                    best = entry;
+                    bestKey = key;
+                }
+            }
+            if (best !== null && bestKey !== null)
+                return { key: bestKey, entry: best, reason: category.reason };
+        }
+        return null;
+    }
+    function evictUntil(headroom) {
+        while (totalBytes + headroom > budgetBytes) {
+            const victim = pickVictim();
+            if (victim === null)
+                return;
+            removeEntry(victim.key, victim.entry);
+            notifyEviction(victim.entry.raster, victim.reason);
+            disposeOnce(victim.entry.raster);
+        }
+    }
+    function touch(entry) {
+        entry.usedAt = ++tick;
+    }
+    /**
+     * The one place a retired entry is freed. Everything tagged at or below `fence`
+     * goes; everything above it STAYS IN THE QUEUE, which is the whole difference
+     * between a delay of one epoch and a delay of nothing.
+     */
+    function disposeEligible(fence) {
+        // Snapshot: disposal mutates the queue.
+        for (const key of Array.from(retireQueue)) {
+            const entry = entries.get(key);
+            if (entry === undefined) {
+                retireQueue.delete(key);
+                continue;
+            }
+            if (entry.refs > 0) {
+                // Re-acquired between release and flush — a cache hit on the next
+                // epoch's plan. Nothing to do.
+                entry.retired = false;
+                retireQueue.delete(key);
+                continue;
+            }
+            if (isProtected(entry)) {
+                // A live page's base outlives the content object that referenced it.
+                // Keep it cached and unreferenced rather than disposing: re-rastering
+                // it is exactly the blank frame this whole design exists to avoid.
+                entry.retired = false;
+                retireQueue.delete(key);
+                continue;
+            }
+            if (entry.retiredAt > fence)
+                continue; // a renderer may still hold it
+            removeEntry(key, entry); // also drops it from the queue
+            disposeOnce(entry.raster);
+        }
+    }
+    return {
+        get(key) {
+            const entry = entries.get(key);
+            if (entry === undefined)
+                return undefined;
+            touch(entry);
+            return entry.raster;
+        },
+        has(key) {
+            return entries.has(key);
+        },
+        put(raster) {
+            const existing = entries.get(raster.key);
+            if (existing !== undefined) {
+                touch(existing);
+                // Same key, different bytes: the incumbent is already referenced by
+                // mounted content, so it wins and the newcomer is freed. The caller is
+                // documented to read its reference back out of the cache.
+                if (existing.raster !== raster)
+                    disposeOnce(raster);
+                return true;
+            }
+            // Nothing that can never fit is worth emptying the cache for.
+            if (raster.bytes > budgetBytes) {
+                notifyEviction(raster, 'budget');
+                disposeOnce(raster);
+                return false;
+            }
+            evictUntil(raster.bytes);
+            if (totalBytes + raster.bytes > budgetBytes) {
+                // Step 4: refuse. Everything still cached is either referenced or a live
+                // base, and both are worth more than this newcomer.
+                notifyEviction(raster, 'budget');
+                disposeOnce(raster);
+                return false;
+            }
+            entries.set(raster.key, {
+                raster,
+                refs: 0,
+                usedAt: ++tick,
+                retired: false,
+                retiredAt: Number.NEGATIVE_INFINITY,
+            });
+            totalBytes += raster.bytes;
+            return true;
+        },
+        acquire(key) {
+            const entry = entries.get(key);
+            if (entry === undefined)
+                return undefined;
+            entry.refs += 1;
+            entry.retired = false;
+            retireQueue.delete(key);
+            touch(entry);
+            return entry.raster;
+        },
+        release(key, contentEpoch) {
+            const entry = entries.get(key);
+            if (entry === undefined)
+                return;
+            if (entry.refs > 0)
+                entry.refs -= 1;
+            if (entry.refs === 0) {
+                entry.retired = true;
+                // A second release of an already-retired entry re-stamps it with the
+                // newer epoch, which holds it longer. Late is safe; early is the corpse.
+                entry.retiredAt = contentEpoch ?? Number.NEGATIVE_INFINITY;
+                if (contentEpoch !== undefined)
+                    noteEpoch(contentEpoch);
+                retireQueue.add(key);
+            }
+        },
+        refCount(key) {
+            return entries.get(key)?.refs ?? 0;
+        },
+        flushRetired(contentEpoch) {
+            if (contentEpoch !== undefined)
+                noteEpoch(contentEpoch);
+            // No epoch is the teardown call: nothing is mounted, so nothing is fenced.
+            disposeEligible(contentEpoch === undefined ? Number.POSITIVE_INFINITY : disposalFence());
+        },
+        notePresented(epoch) {
+            if (!Number.isFinite(epoch))
+                return;
+            presentedEpoch =
+                presentedEpoch === null ? epoch : Math.max(presentedEpoch, epoch);
+            noteEpoch(epoch);
+            // Freed HERE rather than at the next flush, and that is the point of the
+            // sound clock: at rest there is no next commit to piggyback on, so the
+            // commit clock would hold one epoch's dropped rasters for as long as the
+            // user sits still. This is a call the host makes from a commit it already
+            // has, so retirement still owns no timer and no commit of its own.
+            disposeEligible(disposalFence());
+        },
+        setLiveWindow(pages) {
+            liveWindow = new Set(pages);
+        },
+        clear() {
+            for (const entry of entries.values())
+                disposeOnce(entry.raster);
+            entries.clear();
+            retireQueue.clear();
+            totalBytes = 0;
+            // Back to un-armed: a cleared cache holds no tags, so a stale fence could
+            // only mis-judge whatever is put into it next.
+            presentedEpoch = null;
+            latestEpoch = Number.NEGATIVE_INFINITY;
+        },
+        stats() {
+            let referenced = 0;
+            for (const entry of entries.values())
+                if (entry.refs > 0)
+                    referenced += 1;
+            return {
+                bytes: totalBytes,
+                entries: entries.size,
+                retired: retireQueue.size,
+                referenced,
+            };
+        },
+        subscribeEvictions(listener) {
+            evictionListeners.add(listener);
+            return () => {
+                evictionListeners.delete(listener);
+            };
+        },
+    };
+}

package/dist/clock.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A monotonic, sub-millisecond clock — for MEASURING durations only.
+ *
+ * Deliberately NOT the controller's `now`. That one is injected so a test can
+ * drive the epoch state machine on a fake clock, and its resolution (`Date.now`,
+ * 1 ms) is fine for cadence decisions measured in tens of milliseconds. It is
+ * useless for the phase split this module exists to serve: a `decodeBase64` of a
+ * 5.6 M-char string and a `Skia.Data.fromBytes` of 4 MiB are the two terms being
+ * told apart, and quantising both to 1 ms is how you end up "proving" a number
+ * you had already assumed.
+ *
+ * PURE. `performance` is a global in Hermes, in node and in every browser, but
+ * it is reached through a guard rather than assumed, because the whole point of
+ * this package's core is that it loads with neither `react-native` nor a DOM
+ * present. `Date.now` is the fallback and it is honest — a phase that only ever
+ * reports whole milliseconds is a phase measured on the fallback.
+ */
+type Clock = () => number;
+/** Milliseconds since an arbitrary origin. Differences are the only meaning. */
+export declare const monotonicNow: Clock;
+export {};

package/dist/clock.js

@@ -0,0 +1,31 @@
+/**
+ * A monotonic, sub-millisecond clock — for MEASURING durations only.
+ *
+ * Deliberately NOT the controller's `now`. That one is injected so a test can
+ * drive the epoch state machine on a fake clock, and its resolution (`Date.now`,
+ * 1 ms) is fine for cadence decisions measured in tens of milliseconds. It is
+ * useless for the phase split this module exists to serve: a `decodeBase64` of a
+ * 5.6 M-char string and a `Skia.Data.fromBytes` of 4 MiB are the two terms being
+ * told apart, and quantising both to 1 ms is how you end up "proving" a number
+ * you had already assumed.
+ *
+ * PURE. `performance` is a global in Hermes, in node and in every browser, but
+ * it is reached through a guard rather than assumed, because the whole point of
+ * this package's core is that it loads with neither `react-native` nor a DOM
+ * present. `Date.now` is the fallback and it is honest — a phase that only ever
+ * reports whole milliseconds is a phase measured on the fallback.
+ */
+const resolve = () => {
+    const perf = globalThis
+        ?.performance;
+    if (perf !== undefined && typeof perf.now === 'function') {
+        const now = perf.now.bind(perf);
+        // Trust it only if it actually returns a number. A shimmed `performance`
+        // that returns undefined would silently turn every duration into NaN.
+        if (typeof now() === 'number')
+            return now;
+    }
+    return Date.now;
+};
+/** Milliseconds since an arbitrary origin. Differences are the only meaning. */
+export const monotonicNow = /*#__PURE__*/ resolve();

package/dist/controller.d.ts

@@ -0,0 +1,131 @@
+/**
+ * The cadence engine. Framework-free: no React, no reanimated, no Skia calls.
+ *
+ * THE ONE RULE: the transform decides WHEN to rasterize, never WHAT to draw.
+ * Everything this file emits is a plain-number doc-space rect that is constant
+ * for the life of an epoch. The host's <Group transform> does 100% of the pan
+ * and zoom; nothing here reads a shared value.
+ *
+ * Shape of the machine:
+ *
+ *   hint()   continuous input -> restart a trailing quiet timer (or force an
+ *            evaluation once maxStaleMs has elapsed since the last commit)
+ *   settle() discrete end     -> evaluate now, subject to minEpochIntervalMs
+ *
+ * An evaluation asks `planRasters` WHAT should exist and `shouldReraster`
+ * WHETHER it is worth producing, and either does nothing or dispatches one
+ * raster run. A run renders its items through `maxConcurrentRenders` lanes —
+ * one at a time unless the backend says it can do better — and its result is
+ * committed as a brand new frozen PdfContent — identity change is the swap
+ * signal, because RN Skia's shallowEq is reference equality and a handle
+ * mutated in place would never reach the Skia tree.
+ *
+ * There is one thing the machine does for itself: a run that ends with a piece
+ * missing arms a single re-EVALUATION (see `scheduleRepair`), because every
+ * other entry point is host-driven and a host at rest produces none.
+ *
+ * WHAT A COMMIT IS NOT: THE MOMENT THE OLD PIXELS STOP BEING DRAWN. Publishing
+ * `content` only changes what the NEXT render will say; the renderer catches up
+ * later, and on web it re-records its picture from the currently-mounted tree
+ * many times in between. So every release this file makes carries the epoch it
+ * happened at (`cache.release(key, epoch)`) and the flush is fenced on that same
+ * epoch, and a host that can report presentation (`notePresented`) replaces the
+ * guess with the fact. See the fence section of `./cache.js`.
+ *
+ * THIS FILE OWNS NO GEOMETRY AND NO PLANNING. Every rect operation comes from
+ * `./geometry.js` and every decision about what to render, at what scale, under
+ * which key comes from `./planner.js`. A private copy of either is how the two
+ * silently drift until the tested one is testing nothing that runs.
+ */
+import type { DocRect, PageGeometry, PdfContent, PdfController, PdfDiagnostic, PdfRaster, RasterizerHandle, RasterPixels, RasterPolicy, RasterRole } from './types.js';
+import type { RasterCache } from './cache.js';
+export interface ScheduledHandle {
+    cancel(): void;
+}
+/**
+ * Everything `ingest` needs that is not already in the pixels. It exists because
+ * turning RasterPixels into an SkImage is platform code and cannot live in a
+ * module that must run under plain Node in vitest.
+ */
+export interface RasterIngestMeta {
+    key: string;
+    page: number;
+    role: RasterRole;
+    /** Doc space, LAYOUT coordinates — exactly the rect the bytes cover. */
+    docRect: DocRect;
+    scale: number;
+    epoch: number;
+}
+export interface PdfControllerOptions {
+    handle: RasterizerHandle;
+    /** Where each page sits in doc space. Index in this array IS the page number. */
+    pageRects: DocRect[];
+    /** Parallel to `pageRects`. Every page, in page order. */
+    pages: PageGeometry[];
+    policy: RasterPolicy;
+    ingest: (pixels: RasterPixels, meta: RasterIngestMeta) => PdfRaster;
+    cache: RasterCache;
+    /**
+     * When present, NO page outside this set is ever planned — neither a base nor
+     * a detail piece. This is how the React layer enforces "pages defaults to a
+     * window, never all": a 400-page spec book holds ~10 MiB in a single ARCH-D
+     * base, so "all" is ~4 GiB of standing allocation before one detail raster
+     * exists.
+     *
+     * It restricts RASTERING only. `pageRects` / `pages` must still describe every
+     * page, because `content.pages` is what the host hit-tests and scrolls
+     * against, and a page it cannot locate is a page it cannot scroll to.
+     */
+    allowedPages?: ReadonlySet<number>;
+    /**
+     * How many pieces of one plan may be rendered at once.
+     *
+     * COMES FROM THE BACKEND — `PageRasterizer.capabilities.maxConcurrentRenders`,
+     * which `usePdfLayer` forwards. Defaulting to 1 here is what keeps a backend
+     * that never declared it scheduled exactly as it was: one piece at a time, in
+     * plan order, which is the only behaviour every backend has been proven
+     * against.
+     *
+     * The effective bound is `min(this, plan.items.length)`, so a single-piece
+     * epoch never spawns a lane it has no work for.
+     */
+    maxConcurrentRenders?: number;
+    /** Injected so tests drive a fake clock. Nothing below calls Date.now. */
+    now?: () => number;
+    /** Injected so tests drive a fake clock. Nothing below calls setTimeout. */
+    schedule?: (fn: () => void, ms: number) => ScheduledHandle;
+    onDiagnostic?: (diagnostic: PdfDiagnostic) => void;
+    /** Surfaced in the `raster` diagnostic. RasterizerHandle carries no id. */
+    backendId?: string;
+}
+export interface PdfControllerInstance extends PdfController {
+    getContent(): PdfContent;
+    /** useSyncExternalStore-shaped: bare notification, read with getContent(). */
+    subscribe(listener: () => void): () => void;
+    /**
+     * THE RENDERER'S CLOCK, and the only sound one for disposal.
+     *
+     * Call this once the renderer has MOUNTED content epoch `epoch` — from a layout
+     * effect under the component that draws it, not from a timer. Every raster the
+     * content objects up to that epoch stopped referencing is then provably
+     * unreferenced, and the cache frees it at once.
+     *
+     * WHY IT EXISTS. `commit` cannot know when the renderer catches up, and on web
+     * it is demonstrably not the same instant: RN Skia RE-RECORDS its picture from
+     * whatever Skia tree is currently mounted, and a host whose transform lives in
+     * React state re-records on every pointermove of a pan. Freeing a raster before
+     * React has committed the content that dropped it therefore leaves a deleted
+     * SkImage in a tree that is about to be walked — measured as 34 `BindingError:
+     * Cannot pass deleted object as a pointer of type Image const*` throws over six
+     * high-zoom pans, out of RN Skia's own `drawImage -> Image.width`.
+     *
+     * OPTIONAL. Without it the cache falls back to the commit clock (one whole
+     * epoch of grace, see `RasterCache.flushRetired`), which closes the measured
+     * hole but is a heuristic — it assumes the renderer mounts epoch N before the
+     * controller publishes N+1 — and it holds one epoch's dropped rasters for as
+     * long as the viewport is at rest. Reporting is what makes both exact.
+     */
+    notePresented(epoch: number): void;
+    destroy(): void;
+}
+export declare function createPdfController(options: PdfControllerOptions): PdfControllerInstance;