@laminapdf/viewer 0.0.0-stage → 0.2.0-alpha.3

package/README.md

@@ -1,3 +1,177 @@
-# Temporary Holding Version
+# @laminapdf/viewer
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+`@laminapdf/viewer` shows a PDF in a web page: it scrolls a 1,000-page document smoothly, draws each page sharp, and zooms around the cursor. It has no UI framework inside, so a React toolbar or the desktop app drives it from outside. It has two parts:
+
+- **The view** handles layout, virtualisation, canvases and zoom.
+- **The document Web Worker**, one per open document, opens and renders the file away from the page's main thread.
+
+The package is private and ESM-only.
+
+```ts
+import pdfiumWasm from "@embedpdf/pdfium/pdfium.wasm?url";
+import { createViewer, ViewerClient } from "@laminapdf/viewer";
+
+const client = await ViewerClient.create({ backend: { backend: "pdfium", wasm: pdfiumWasm } });
+const viewer = createViewer({ client });
+viewer.mount(container); // the container gives the viewer its size
+viewer.open(await client.open(file)); // a File, a Blob or bytes
+viewer.subscribe(() => toolbar.update(viewer.getState())); // page, zoom, rotation
+```
+
+## The view
+
+The view keeps only the pages near the viewport in the DOM and paints each in two passes through the document Web Worker. Six parts do that work:
+
+- **Layout.** Every page's size comes from its displayed size in points, the zoom and the view rotation. The pages stack in one column with a gap. The offsets are prefix sums, so finding the page at a scroll position is a binary search, and a zoom change costs one pass over the pages (`PageLayout`).
+- **Virtualisation.** The viewer mounts a shell for each page in view, plus a margin of 2 pages or one viewport each side, whichever is larger. A shell that leaves the margin aborts its renders. If a result still arrives for that page, the viewer drops it and never draws it. Scroll handling reads the DOM first and writes it once per animation frame.
+- **Canvases.** A shell borrows its canvas from a pool of 12, which caps the canvases' total size at 64 million device pixels (`CanvasPool`). Safari fails past an undocumented total canvas area, so the pool shrinks a canvas rather than exceed the cap. Rendered bitmaps stay in a 256 MB cache, which closes the bitmaps farthest from the current page first (`BitmapCache`).
+- **Progressive rendering.** A page first paints a blurry whole-page pass, at most 256 pixels wide, at `visible` priority. Then it paints sharp tiles, 512 CSS px × the device pixel ratio on a side, over the part in view. Pages in the margin get only the blurry pass, at `prefetch` priority. A canvas is resized only when the new pixels are ready, so the page never flashes white.
+- **Zoom.** The modes are fit width, fit page, actual size (96 CSS px per inch) and 10–800 %. Zoom comes from ctrl/cmd+wheel, trackpad pinch (ctrl+wheel, or Safari's gesture events), touch pinch and the `+`, `-` and `0` keys. The document point under the cursor stays where it is: always vertically, and horizontally while the pages are wider than the viewport. Narrower pages are centred, so no horizontal scroll can keep it there. During a gesture the canvases stretch, and the sharp re-render waits until the gesture pauses for 150 ms.
+- **Tall documents.** A document taller than 16 million CSS px at the chosen zoom gets its zoom capped, because browsers stop scrolling near that height.
+
+**API.**
+
+| Member | What it does |
+| --- | --- |
+| `createViewer({ client, margin?, gap?, pool?, cacheBytes?, settleMs?, zoom? })` | Makes a viewer over a `ViewerClient`. |
+| `mount(container)`, `open(document)`, `destroy()` | Puts it on the page, shows a document, takes it down. |
+| `goToPage(index, { anchor })`, `setZoom(zoom, { anchor })`, `rotate(delta)` | Navigation. `zoom` is a mode or a percentage. |
+| `getState()`, `subscribe(listener)` | The view state (`currentPage`, `pageCount`, `zoom`, `percent`, `rotation`, `scrollTop`, `visibleRange`), for `useSyncExternalStore`. |
+| `on("pagechange" \| "zoomchange" \| "renderstats", …)`, `stats()` | Events and counters. `renderstats` counts renders, for measuring performance. |
+| `addLayer({ name, onMount, onUnmount, onZoom })` | Mounts a layer into each page. |
+| `pointAt(x, y)`, `positionOf(point)` | Converts between viewport positions and document points. |
+| `MIN_ZOOM`, `MAX_ZOOM` | The bounds of a percentage zoom, 10 and 800, for a zoom control's range. |
+
+**Layers.** Each page shell stacks a canvas and three slots above it: `div.lamina-layer-text`, `div.lamina-layer-annot` and `div.lamina-layer-highlight`. The coming text layer, find highlights and links will mount there through `addLayer`. A layer with another name gets its own slot on top.
+
+**Tuning.** The margin, pool size, pixel cap, cache budget and settle delay are measured by the perf harness ([Performance](#performance)); the first full run kept them.
+
+## The document Web Worker
+
+The client starts the Web Worker and talks to it; you call `ViewerClient`'s methods and listen to its events.
+
+**Events:**
+
+| Event | Source | Data | Meaning |
+| --- | --- | --- | --- |
+| `warning` | Web Worker | a reader warning | for example, a repaired xref |
+| `render-start` | Web Worker | `{ page, scale }` | a render began, for measuring performance |
+| `render-slow` | page | `{ id, page }` | the soft timeout passed, counted from `render-start`: waiting in the queue isn't slow |
+| `render-stuck` | page | `{ id, page, needsPassword }` | an encrypted document's render passed the hard cap |
+| `crashed` | page | `{ reason }` | the Web Worker crashed |
+| `restarted` | page | `{ reason, reopened }` | a new Web Worker serves again |
+| `password-required` | page | — | the new Web Worker can't reopen without the password |
+| `restart-failed` | page | `{ reason, error }` | a restart failed (for example, the backend wouldn't load again) |
+
+### How it behaves
+
+- **Priorities and coalescing:** the Web Worker runs one call at a time, the highest priority first, FIFO within one.
+  - Before each call it reads every message already sent, so a burst of renders and cancels is ordered and pruned before anything runs.
+  - Renders with an equal normalised `RenderRequest` (`renderKey`: page, scale, clip, rotation, flags, background) run once, and each caller gets its own bitmap.
+- **Cancellation:** `signal` rejects the call at once with a `DOMException` named `AbortError`.
+  - A queued render is dropped.
+  - A running one finishes, because synchronous WebAssembly can't be interrupted. Its late answer's bitmap is closed unpainted (`onDiscard`).
+  - (`@laminapdf/sdk/worker` itself rejects with a `cancelled` LaminaPdfError; the viewer maps it to `AbortError`.)
+- **Timeouts:** the page keeps the timers, because a Web Worker inside a render can't post anything.
+  - Defaults are `soft` 10 s (`render-slow`) and `hard` 120 s.
+  - At the hard cap the client calls `stop("hard-timeout")`. For a document that needed a password, it emits `render-stuck` instead and waits for the user's `stop()`.
+- **Crashes:** a crash is the Web Worker's `error` or `messageerror`, or a WebAssembly trap it reports, never silence.
+  - Pending calls reject with `worker-crashed`.
+  - A new Web Worker reopens the document from the same source, but nothing that was pending is re-sent. The UI offers Retry, so a page that crashes the engine can't loop.
+  - `stop()` takes the same path with `reason: "cancelled"`.
+- **Secrets:** the password crosses to the Web Worker once, when the document opens, and is kept only there. The page keeps the source and the other options.
+  - After a crash of an encrypted document, `password-required` fires and the caller opens again.
+  - Lamina PDF's tests count every message that carries the password, so a change that sends it more often fails them.
+- **Sources:**
+  - A `Blob`/`File` is sent by reference, and the Web Worker reads it in 4 MiB `slice()`s.
+  - Bytes are copied, and kept on the page for a reopen.
+
+## For contributors
+
+The viewer is the web client of [ADR 0009](../../docs/decisions/0009-web-client-architecture.md); it was built in [C3a](../../docs/todos/done/C3a-viewer-worker-rpc.md) (the document worker and its typed RPC) and [C3b](../../docs/todos/done/C3b-viewer-virtualiser-and-zoom.md) (the viewer). [C3c](../../docs/todos/done/C3c-viewer-perf-harness.md) measures the tuning values with `renderstats`. The layers are for [C5a](../../docs/todos/ready/C5a-text-layer-and-selection.md) (text), [C5b](../../docs/todos/ready/C5b-find-in-document.md) (find) and [C6b](../../docs/todos/ready/C6b-links-and-history.md) (links); C4c will read documents by range through `@laminapdf/sdk`'s `RangeSource`. Cancellation follows ADR 0009 §3.5, and warnings are [ADR 0003](../../docs/decisions/0003-reader-tolerance-and-limits.md)'s.
+
+### Architecture
+
+```text
+ main thread                                   document worker (one per open document)
+┌────────────────────────────┐   postMessage   ┌──────────────────────────────────────────┐
+│ ViewerClient                │ ─────────────▶ │ @laminapdf/sdk/worker/server  serve({ … })   │
+│  call(method, params, opts) │  call / cancel │  handshake · priority queue · coalescing  │
+│  render timers (slow/stuck) │                │  cancellation · ADR 0026 errors · traps   │
+│  restart + reopen on crash  │ ◀───────────── │   ├─ viewer methods (src/worker/)         │
+│  AbortError on abort        │ result / event │   │   openDocument → SDK Document +       │
+│ @laminapdf/sdk/worker client   │  (transferred  │   │                  RenderDocument       │
+│  request() · onDiscard      │   ImageBitmap) │   │   render → backend → ImageBitmap      │
+└────────────────────────────┘                 │   └─ the SDK's own methods (open, …)      │
+                                               └──────────────────────────────────────────┘
+```
+
+There is one protocol, not two: the viewer's worker is `@laminapdf/sdk/worker`'s server with the viewer's methods added (`serve({ methods })`), and the client calls them through `WorkerClient.request` (ADR 0009 §3, [L2a](../../docs/todos/done/L2a-worker-client.md)).
+
+### Methods
+
+| Method | Params | Result | Priority |
+| --- | --- | --- | --- |
+| `initBackend` | `{ backend: "pdfium" \| "hayro", wasm? }` | `{ name, version }` | document. Sent by `create()`, before a file is chosen, so the WebAssembly downloads in parallel with file selection. |
+| `openDocument` | `source` (`Blob`, `ArrayBuffer`, `Uint8Array`), `{ password?, limits?, renderLimits? }` | `{ pageCount, pages, needsPassword, backend }` | document |
+| `closeDocument` | — | — | document |
+| `pageInfo` | `index` | `PageInfo` (displayed size in points, rotation, ID, label) | document |
+| `render` | ADR 0004 `RenderRequest` | `{ bitmap: ImageBitmap, width, height }` (transferred) | `visible` > `prefetch` > `background` |
+| `memory` | — | `WorkerMemory`: the bytes of the backend's and Lamina PDF's WebAssembly memories | document. `client.memory()`; the perf harness samples it. |
+
+`client.call(method, params, { priority, signal })` is typed by the `Methods` map: an unknown method or wrong params fails `tsc` (`test/types.test.ts`).
+
+### Tests
+
+The browser suites run in Chromium, Firefox and WebKit over the built package: run `cargo xtask pdf-runtimes chromium|firefox|webkit`, or `pnpm exec vitest run -c vitest.browser.config.ts` after `cargo xtask wasm`.
+
+- `test/browser/viewer.browser.test.ts` scrolls a 1,000-page document that the test builds with `@laminapdf/sdk`'s builder. It covers:
+  - scrolling one viewport per frame from page 1 to 1,000 with at most visible + 2 × margin shells, and no more canvases than the pool holds;
+  - a fast scroll past 200 pages that paints no cancelled render;
+  - every visible page reaching sharp tiles once scrolling stops, including the part of a tall zoomed page scrolled into later;
+  - ctrl+wheel zoom 100 % → 200 % → 50 % holding the point under the cursor within 1 CSS px;
+  - keyboard zoom, rotation and layers.
+- `test/browser/rpc.browser.test.ts` covers the document worker, and counts every `postMessage` that carries the password:
+  - the corpus page counts and sizes against `fixtures/corpus/expected.json`;
+  - hayro;
+  - limits;
+  - 100 renders with 90 aborted, and a render aborted mid-run;
+  - priorities and coalescing;
+  - slow, stuck and stopped renders;
+  - crashes, including an encrypted file;
+  - the password count.
+- Unit tests sit next to their modules (`src/**/*.test.ts`) and run in Node. They cover the layout's cost, counted in steps, and the fit modes for portrait, landscape and rotated pages. They also cover zoom anchoring, tiles, cache eviction and the pool's caps. `test/dependencies.test.ts` checks that `src/` imports no UI framework, and `test/types.test.ts` checks the RPC types.
+- Two demo pages are manual checks: run `pnpm --filter @laminapdf/viewer exec vite examples`. `examples/viewer-demo.html` is the viewer, with zoom buttons; `examples/rpc-demo.html` draws page 1 through the RPC alone. The perf harness has its own page, `perf/page/` ([Performance](#performance)).
+
+### Performance
+
+A harness in `perf/` measures the viewer against the [web plan's targets](../../docs/plans/web-app.md#non-functional-targets-are-recommendations-measured-from-c3-onward) in Chromium, Firefox and WebKit:
+
+```sh
+cargo xtask wasm                                   # once: the package the harness runs
+pnpm --filter @laminapdf/viewer perf               # every browser; -- --browsers chromium --quick for a short run
+cargo xtask viewer-perf [chromium|firefox|webkit]  # the same, plus the job summary and the nightly history
+```
+
+It writes `target/viewer-perf/<browser>.json` and `summary.md`, and never fails on a missed target: no pull request lane asserts a duration ([ADR 0018](../../docs/decisions/0018-test-strategy.md#2-ci-lanes)).
+
+**What it does.** It opens three seeded files, built with `@laminapdf/sdk` and cached in `perf/.fixtures/`: 10 pages of text with an image each (about 1 MB), 1,000 pages of text, and 300 pages of full-page images. A Vite build of `perf/page/` shows them, and `perf/serve.ts` serves that page gzipped, as Cloudflare serves the app. Playwright drives real input, so every run scrolls the same way:
+
+| Scenario | Measures | Target |
+| --- | --- | --- |
+| Open the 10-page file, warm (after a reload) | time to the first page's first paint | ≤ 700 ms |
+| The same, cold, on Chrome DevTools' Fast 4G (Chromium only) | time from navigation to the first page | ≤ 3 s |
+| Scroll the 1,000-page file end to end, twice, with wheel steps every 20 ms; stop at a quarter, a half and three quarters | the longest main-thread task, time to sharp after each stop, peak memory, memory after each pass, cancelled renders that painted | no task > 50 ms; sharp ≤ 300 ms; ≤ 600 MB; second pass ≤ first + 5 %; 0 |
+| Fling across the 300 image pages, then stop | time to sharp | ≤ 300 ms |
+| Three ctrl+wheel bursts in and out on the 10-page file | the longest frame, time to sharp after each burst | reported |
+
+"Time to sharp" runs from the last scroll or zoom event to the moment every visible page turned sharp. Memory is the page's JS heap (Chromium only), the document Web Worker's WebAssembly memories (`client.memory()`), the bitmap cache and the canvases' pixels. Firefox and WebKit have no Long Tasks API, so their longest task is the longest gap between frames, which is an upper bound.
+
+**History.** The nightly lane runs `cargo xtask viewer-perf --history … --record` on `main` and keeps each browser's figures in the benchmark history (`viewer/<browser>/<figure>`: nanoseconds, or bytes for memory). A figure more than 10 % worse than the median of its last five runs on the same runner opens an issue, as a benchmark does; `--dry-run` prints that issue. `--quick` covers 100 pages and is never recorded.
+
+**The reference machine.** The official numbers are the nightly lane's, from the Mac that hosts the self-hosted runners, with nothing else running on it. Each report ends with the machine it ran on (CPU, cores, memory, OS). Numbers from other machines, CI containers included, are relative: compare them with each other, not with the targets.
+
+**First measurements and tuning.** The first full run (Chromium 153 on a 4-core Linux container, 2026-11-05) came in under every scrolling and memory target, a first reading until the reference machine's numbers arrive. It had no long task while scrolling, pages were sharp 0–17 ms after a scroll stopped and 33 ms after a fling, memory peaked at 302 MB, the second pass ended 0.5 % above the first, and no cancelled render painted. So the defaults above stay: a margin of 2 pages or one viewport, a pool of 12 canvases and 64 million pixels, a 256 MB bitmap cache, 512 CSS px tiles and a 150 ms settle. It missed one target and found one slow spot, both for [C7c](../../docs/todos/ready/C7c-performance-gates-and-launch.md):
+
+- **The cold first page took 4.2 s on Fast 4G (target 3 s).** The download alone takes about 3.7 s at Fast 4G's 1 MB/s: PDFium's WebAssembly (2.2 MB gzipped), Lamina PDF's base module (0.4 MB) and the 1 MB file.
+- **Zooming in took about 1.2 s to sharp, with a 317 ms frame.** Zooming out took about 300 ms. The plan sets no zoom target.

package/dist/canvas/cache.d.ts

@@ -0,0 +1,35 @@
+/** One cached bitmap: the page it belongs to and its decoded size in bytes. */
+export interface CachedBitmap {
+    readonly page: number;
+    readonly bitmap: ImageBitmap;
+    readonly bytes: number;
+}
+/** Default budget: 256 MB of decoded pixels. */
+export declare const DEFAULT_CACHE_BYTES: number;
+/** Rendered bitmaps by key, within a byte budget, evicting the farthest from the current page. */
+export declare class BitmapCache {
+    #private;
+    readonly budget: number;
+    constructor(budget?: number);
+    /** The decoded bytes the cached bitmaps hold. */
+    get bytes(): number;
+    /** How many bitmaps are cached. */
+    get size(): number;
+    /** The bitmap under `key`, if cached (it becomes the most recently used). */
+    get(key: string): ImageBitmap | undefined;
+    /**
+     * Stores `bitmap` for `page` under `key` (replacing and closing an older one), then evicts by
+     * distance from `focus` (the current page) until the cache fits its budget again.
+     *
+     * @returns whether the cache kept it. A bitmap larger than the whole budget isn't kept, nor
+     *   closed: it stays the caller's, to draw and close.
+     */
+    set(key: string, page: number, bitmap: ImageBitmap, focus: number): boolean;
+    /** Closes and forgets the bitmap under `key`, if any. */
+    delete(key: string): void;
+    /** Closes every bitmap of `page` whose key `keep` doesn't accept (an old zoom's tiles). */
+    prune(page: number, keep: (key: string) => boolean): void;
+    /** Closes everything. */
+    clear(): void;
+}
+//# sourceMappingURL=cache.d.ts.map

package/dist/canvas/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/canvas/cache.ts"],"names":[],"mappings":"AAIA,+EAA+E;AAC/E,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,gDAAgD;AAChD,eAAO,MAAM,mBAAmB,QAAoB,CAAC;AAErD,kGAAkG;AAClG,qBAAa,WAAW;;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAIxB,YAAY,MAAM,SAAsB,EAEvC;IAED,iDAAiD;IACjD,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,mCAAmC;IACnC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,6EAA6E;IAC7E,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAOxC;IAED;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAQ1E;IAED,yDAAyD;IACzD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAMxB;IAED,2FAA2F;IAC3F,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,CAExD;IAoBD,yBAAyB;IACzB,KAAK,IAAI,IAAI,CAEZ;CACF"}

package/dist/canvas/cache.js

@@ -0,0 +1,89 @@
+// The bitmap cache: rendered ImageBitmaps by page, scale and tile, within a byte budget
+// (width × height × 4 each). Past the budget it evicts the bitmaps farthest from the viewport
+// first, and closes every bitmap it evicts or replaces, so GPU memory is given back at once.
+/** Default budget: 256 MB of decoded pixels. */
+export const DEFAULT_CACHE_BYTES = 256 * 1024 * 1024;
+/** Rendered bitmaps by key, within a byte budget, evicting the farthest from the current page. */
+export class BitmapCache {
+    budget;
+    #entries = new Map();
+    #bytes = 0;
+    constructor(budget = DEFAULT_CACHE_BYTES) {
+        this.budget = budget;
+    }
+    /** The decoded bytes the cached bitmaps hold. */
+    get bytes() {
+        return this.#bytes;
+    }
+    /** How many bitmaps are cached. */
+    get size() {
+        return this.#entries.size;
+    }
+    /** The bitmap under `key`, if cached (it becomes the most recently used). */
+    get(key) {
+        const entry = this.#entries.get(key);
+        if (entry === undefined)
+            return undefined;
+        // Most recently used last (the tie-breaker among pages at the same distance).
+        this.#entries.delete(key);
+        this.#entries.set(key, entry);
+        return entry.bitmap;
+    }
+    /**
+     * Stores `bitmap` for `page` under `key` (replacing and closing an older one), then evicts by
+     * distance from `focus` (the current page) until the cache fits its budget again.
+     *
+     * @returns whether the cache kept it. A bitmap larger than the whole budget isn't kept, nor
+     *   closed: it stays the caller's, to draw and close.
+     */
+    set(key, page, bitmap, focus) {
+        this.delete(key);
+        const bytes = bitmap.width * bitmap.height * 4;
+        if (bytes > this.budget)
+            return false;
+        this.#entries.set(key, { page, bitmap, bytes });
+        this.#bytes += bytes;
+        this.#evict(focus, key);
+        return true;
+    }
+    /** Closes and forgets the bitmap under `key`, if any. */
+    delete(key) {
+        const entry = this.#entries.get(key);
+        if (entry === undefined)
+            return;
+        this.#entries.delete(key);
+        this.#bytes -= entry.bytes;
+        entry.bitmap.close();
+    }
+    /** Closes every bitmap of `page` whose key `keep` doesn't accept (an old zoom's tiles). */
+    prune(page, keep) {
+        for (const [key, entry] of [...this.#entries])
+            if (entry.page === page && !keep(key))
+                this.delete(key);
+    }
+    #evict(focus, protect) {
+        while (this.#bytes > this.budget) {
+            let worst;
+            let distance = -1;
+            // Insertion order is least recently used first, so among equals the oldest goes.
+            for (const [key, entry] of this.#entries) {
+                if (key === protect)
+                    continue;
+                const d = Math.abs(entry.page - focus);
+                if (d > distance) {
+                    distance = d;
+                    worst = key;
+                }
+            }
+            if (worst === undefined)
+                return;
+            this.delete(worst);
+        }
+    }
+    /** Closes everything. */
+    clear() {
+        for (const key of [...this.#entries.keys()])
+            this.delete(key);
+    }
+}
+//# sourceMappingURL=cache.js.map

package/dist/canvas/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/canvas/cache.ts"],"names":[],"mappings":"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"}

package/dist/canvas/pool.d.ts

@@ -0,0 +1,35 @@
+/** The pool's limits, and how it makes canvases. */
+export interface CanvasPoolOptions {
+    /** Most canvases at once (default 12). */
+    readonly max?: number;
+    /** Most device pixels across every acquired canvas (default 64 MP). */
+    readonly maxPixels?: number;
+    /** Makes a canvas (default `document.createElement("canvas")`). */
+    readonly create?: () => HTMLCanvasElement;
+}
+/** A fixed set of canvases lent to mounted pages, within a total pixel cap. */
+export declare class CanvasPool {
+    #private;
+    readonly max: number;
+    readonly maxPixels: number;
+    /** The most canvases ever acquired at once (reported in the viewer's render stats). */
+    peak: number;
+    constructor(options?: CanvasPoolOptions);
+    /** Canvases lent out now. */
+    get inUse(): number;
+    /** Device pixels the acquired canvases hold now. */
+    get pixels(): number;
+    /** A canvas, or undefined when `max` are in use (the page keeps its placeholder until one frees). */
+    acquire(): HTMLCanvasElement | undefined;
+    /**
+     * The size `canvas` may take, `width × height` device pixels scaled down (keeping the aspect)
+     * so that every acquired canvas together stays within `maxPixels`.
+     */
+    fit(canvas: HTMLCanvasElement, width: number, height: number): {
+        width: number;
+        height: number;
+    };
+    /** Returns `canvas`, reset (1×1, no pixels, default context state). */
+    release(canvas: HTMLCanvasElement): void;
+}
+//# sourceMappingURL=pool.d.ts.map

package/dist/canvas/pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.d.ts","sourceRoot":"","sources":["../../src/canvas/pool.ts"],"names":[],"mappings":"AAIA,oDAAoD;AACpD,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,iBAAiB,CAAC;CAC3C;AAKD,+EAA+E;AAC/E,qBAAa,UAAU;;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAI3B,uFAAuF;IACvF,IAAI,SAAK;IAET,YAAY,OAAO,GAAE,iBAAsB,EAI1C;IAED,6BAA6B;IAC7B,IAAI,KAAK,IAAI,MAAM,CAElB;IAED,oDAAoD;IACpD,IAAI,MAAM,IAAI,MAAM,CAInB;IAED,qGAAqG;IACrG,OAAO,IAAI,iBAAiB,GAAG,SAAS,CAMvC;IAED;;;OAGG;IACH,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAO/F;IAED,uEAAuE;IACvE,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAOvC;CACF"}

package/dist/canvas/pool.js

@@ -0,0 +1,65 @@
+// The canvas pool: a fixed number of canvases, reused as pages mount and unmount, with a
+// cap on the device pixels they hold together (browsers, Safari above all, fail or crash past an
+// undocumented total canvas area). A canvas comes back reset: 1×1, so it holds no pixels.
+/** The default limits: 12 canvases, 64 million device pixels in all. */
+const DEFAULT_POOL = Object.freeze({ max: 12, maxPixels: 64 * 1024 * 1024 });
+/** A fixed set of canvases lent to mounted pages, within a total pixel cap. */
+export class CanvasPool {
+    max;
+    maxPixels;
+    #create;
+    #free = [];
+    #used = new Set();
+    /** The most canvases ever acquired at once (reported in the viewer's render stats). */
+    peak = 0;
+    constructor(options = {}) {
+        this.max = options.max ?? DEFAULT_POOL.max;
+        this.maxPixels = options.maxPixels ?? DEFAULT_POOL.maxPixels;
+        this.#create = options.create ?? (() => document.createElement("canvas"));
+    }
+    /** Canvases lent out now. */
+    get inUse() {
+        return this.#used.size;
+    }
+    /** Device pixels the acquired canvases hold now. */
+    get pixels() {
+        let total = 0;
+        for (const c of this.#used)
+            total += c.width * c.height;
+        return total;
+    }
+    /** A canvas, or undefined when `max` are in use (the page keeps its placeholder until one frees). */
+    acquire() {
+        if (this.#used.size >= this.max)
+            return undefined;
+        const canvas = this.#free.pop() ?? this.#create();
+        this.#used.add(canvas);
+        if (this.#used.size > this.peak)
+            this.peak = this.#used.size;
+        return canvas;
+    }
+    /**
+     * The size `canvas` may take, `width × height` device pixels scaled down (keeping the aspect)
+     * so that every acquired canvas together stays within `maxPixels`.
+     */
+    fit(canvas, width, height) {
+        const others = this.pixels - canvas.width * canvas.height;
+        const room = Math.max(0, this.maxPixels - others);
+        const want = width * height;
+        if (want <= room)
+            return { width: Math.max(1, Math.round(width)), height: Math.max(1, Math.round(height)) };
+        const k = Math.sqrt(room / want);
+        return { width: Math.max(1, Math.floor(width * k)), height: Math.max(1, Math.floor(height * k)) };
+    }
+    /** Returns `canvas`, reset (1×1, no pixels, default context state). */
+    release(canvas) {
+        if (!this.#used.delete(canvas))
+            return;
+        // Setting the size clears the pixels and the context's state.
+        canvas.width = 1;
+        canvas.height = 1;
+        canvas.remove();
+        this.#free.push(canvas);
+    }
+}
+//# sourceMappingURL=pool.js.map

package/dist/canvas/pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pool.js","sourceRoot":"","sources":["../../src/canvas/pool.ts"],"names":[],"mappings":"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"}

package/dist/client.d.ts

@@ -0,0 +1,114 @@
+import type { RenderRequest } from "@laminapdf/render";
+import { type WorkerInitOptions, type WorkerWasmSource } from "@laminapdf/sdk/worker";
+import { type BackendInit, type MethodName, type OpenedDocument, type Params, type Priority, type RenderedBitmap, type Result, type SourceInit, type ViewerOpenOptions } from "./protocol.js";
+/** `ViewerClient.create`'s options: the backend, Lamina PDF's WebAssembly, the timeouts, the worker and a signal to stop starting. */
+export interface ViewerOptions {
+    /** The render engine; PDFium needs its `.wasm` URL from your bundler (`pdfium.wasm?url`). */
+    readonly backend: BackendInit;
+    /** Where the worker loads Lamina PDF's own WebAssembly from (`@laminapdf/sdk/worker`'s `init`). */
+    readonly lamina?: WorkerWasmSource | WorkerInitOptions;
+    /** Render timeouts in ms (`soft` emits `render-slow`; `hard` restarts or emits `render-stuck`). */
+    readonly timeouts?: {
+        readonly soft?: number;
+        readonly hard?: number;
+    };
+    /** Makes the worker (CSP, or your own hosting of `dist/worker/entry.js`). */
+    readonly worker?: () => Worker;
+    /** Aborts starting. */
+    readonly signal?: AbortSignal;
+}
+/** Why the worker was restarted. */
+export type RestartReason = "error" | "messageerror" | "trap" | "cancelled" | "hard-timeout";
+/** The client's events: from the worker (`warning`) or raised on the page (the rest). */
+export interface ViewerEvents {
+    /** An ADR 0003 warning about the open document (a repaired xref, …). */
+    warning: {
+        readonly code: string;
+        readonly message: string;
+    };
+    /** The worker started drawing a render (so a performance test can see what the worker is busy with). */
+    "render-start": {
+        readonly page: number;
+        readonly scale: number;
+        readonly key: string;
+    };
+    /** A render passed the soft timeout: offer Stop. */
+    "render-slow": {
+        readonly id: number;
+        readonly page: number;
+    };
+    /** An encrypted document's render passed the hard cap: `stop()` would ask for the password again. */
+    "render-stuck": {
+        readonly id: number;
+        readonly page: number;
+        readonly needsPassword: true;
+    };
+    /** The worker crashed (not on `stop()`). */
+    crashed: {
+        readonly reason: string;
+    };
+    /** A new worker serves again (and has reopened the document, unless it needed a password). */
+    restarted: {
+        readonly reason: RestartReason;
+        readonly reopened: boolean;
+    };
+    /** The restarted worker can't reopen the document without its password: open it again. */
+    "password-required": Record<string, never>;
+    /** A restart failed (the backend couldn't load again, …): the client serves nothing until `stop()` works. */
+    "restart-failed": {
+        readonly reason: RestartReason;
+        readonly error: unknown;
+    };
+}
+/** The names of the client's events. */
+export type ViewerEvent = keyof ViewerEvents;
+/** Per-call options. */
+export interface ViewerCallOptions {
+    readonly signal?: AbortSignal;
+    /** Default `visible` for renders; document calls run above every render. */
+    readonly priority?: Priority;
+}
+/** One document worker and the typed RPC to it. */
+export declare class ViewerClient {
+    #private;
+    private constructor();
+    /**
+     * Starts the document worker and loads the backend at once, so the WebAssembly downloads while
+     * the user picks a file.
+     */
+    static create(options: ViewerOptions): Promise<ViewerClient>;
+    /** Listens for `event`; returns a function that stops listening. */
+    on<E extends ViewerEvent>(event: E, listener: (data: ViewerEvents[E]) => void): () => void;
+    /** A typed call: `method` and `params` are checked against `Methods`. */
+    call<M extends MethodName>(method: M, params: Params<M>, options?: ViewerCallOptions & {
+        key?: string;
+    }): Promise<Result<M>>;
+    /**
+     * Opens `source` in the worker (Lamina PDF and the backend, from the same bytes). The password is
+     * sent once and kept only in the worker; a Blob is sent by reference, bytes are copied (and
+     * kept here, so a restarted worker can reopen them).
+     */
+    open(source: SourceInit, options?: ViewerOpenOptions, call?: ViewerCallOptions): Promise<OpenedDocument>;
+    /** The open document, if any. */
+    get document(): OpenedDocument | undefined;
+    /** Closes the document in the worker (the worker stays, ready for another `open`). */
+    close(): Promise<void>;
+    /** The worker's WebAssembly memory in bytes (see `WorkerMemory`), for measuring. */
+    memory(options?: ViewerCallOptions): Promise<import("./protocol.js").WorkerMemory>;
+    /** Page `index`'s size, rotation, ID and label. */
+    pageInfo(index: number, options?: ViewerCallOptions): Promise<import("@laminapdf/wasm/text").PageInfoJs>;
+    /**
+     * Renders `request` as an ImageBitmap (close it when done). Identical requests in flight are
+     * drawn once. An aborted render rejects with `AbortError` and never paints.
+     */
+    render(request: RenderRequest, options?: ViewerCallOptions): Promise<RenderedBitmap>;
+    /**
+     * Stops whatever the worker is doing by terminating it (the user's Stop, or the hard cap), then
+     * restarts it as after a crash: pending calls reject, the running one isn't re-sent, and an
+     * encrypted document asks for its password again.
+     */
+    stop(reason?: "cancelled" | "hard-timeout"): Promise<void>;
+    /** Ends the worker for good. */
+    terminate(): void;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}