@laminapdf/sdk 0.2.0-alpha.2 → 0.2.0-alpha.3

package/docs/pages/reference/glossary.md

@@ -0,0 +1,108 @@
+---
+title: "Glossary"
+description: "The PDF and Lamina PDF terms the docs use, each in a sentence or two."
+version: "0.2.0-alpha.3"
+url: "https://docs.laminapdf.com/reference/glossary/"
+---
+
+# Glossary
+
+The PDF and Lamina PDF terms the docs use, each in a sentence or two.
+
+The terms the docs use, in plain words. Each page links a term here the first time it uses one.
+
+## How Lamina PDF works
+
+### Overlay
+
+Where Lamina PDF keeps your edits. The bytes you opened never change; the overlay sits on top of them, and saving writes it out. See [how Lamina PDF thinks about a PDF](../../pages/concepts/how-lamina-thinks.md).
+
+### Incremental save
+
+A save that keeps the original bytes as they are and appends a new revision with your edits after them. Signatures over the original stay valid.
+
+### Full rewrite
+
+A save that writes the whole file again. The result is smaller and tidier, but it's no longer the original bytes, so it breaks any signature.
+
+### Façade
+
+The `laminapdf` crate: one API in front of Lamina PDF's core crates, which most Rust code depends on alone.
+
+### Glue
+
+The JavaScript that sits next to each `.wasm` file. It loads the module and converts values between JavaScript and Rust.
+
+### Export condition
+
+A key in a package's `exports` map, such as `node`, `browser`, `deno` or `workerd`, that tells a runtime or bundler which file to load. `@laminapdf/sdk` has one per runtime.
+
+## Inside a PDF file
+
+### COS
+
+PDF's object layer: the dictionaries, arrays, numbers, strings, names, streams and references a file is made of.
+
+### Content stream
+
+A stream of drawing instructions for a page: where to put text, which lines and shapes to draw, which images to place.
+
+### XObject
+
+A reusable piece of content that a content stream draws by name: an image, or a form, which is a group of drawing instructions.
+
+### Cross-reference table
+
+The index at the end of a file that gives the byte offset of every object, so a reader can jump straight to one. Newer files store it as a compressed stream instead.
+
+### Xref
+
+Short for [cross-reference table](#cross-reference-table).
+
+### Object stream
+
+A compressed stream that holds many small objects together, to make the file smaller. Files from PDF 1.5 on can use them.
+
+### Page space
+
+Lamina PDF's coordinates: points from the top-left corner of the page as it's displayed, with y going down. See [pages and coordinates](../../pages/concepts/pages-and-coordinates.md).
+
+### Crop box
+
+The part of a page a viewer shows; anything outside it is cut off. Page space starts at its top-left corner.
+
+### User unit
+
+A page entry that makes each user-space unit bigger than 1/72 of an inch, for very large pages. Lamina PDF applies it, so page-space numbers are always points of 1/72 inch.
+
+### User space
+
+PDF's own coordinates: points from the bottom-left corner of the page, with y going up, before any rotation. Lamina PDF's API uses page space instead; see [pages and coordinates](../../pages/concepts/pages-and-coordinates.md).
+
+## Fonts and text
+
+### Standard 14 fonts
+
+The fourteen fonts every PDF reader supplies: Times, Helvetica and Courier, each in four styles, plus Symbol and ZapfDingbats. A PDF can use them without embedding them.
+
+### Type 0
+
+A font type whose character codes can be more than one byte long, so a font can reach any of its glyphs. Lamina PDF embeds every font except the standard 14 as Type 0.
+
+### CMap
+
+A table that maps a font's character codes to character IDs (CIDs), which pick its glyphs, or, in a ToUnicode CMap, to Unicode text.
+
+### ToUnicode
+
+A CMap a font carries that maps its codes to Unicode, so a reader can copy, search and extract the text.
+
+## Signatures
+
+### DocMDP
+
+The permissions of a certifying signature: which changes the signed document still allows, such as none, filling in forms, or comments. DocMDP stands for document modification detection and prevention.
+
+### UR3
+
+A usage-rights signature, which unlocks features such as saving form data in Adobe Reader. An edit it doesn't allow invalidates it.

package/docs/pages/reference/rust.md

@@ -0,0 +1,36 @@
+---
+title: "Rust API (rustdoc)"
+description: "Where to read the API documentation of the Lamina PDF crates."
+version: "0.2.0-alpha.3"
+url: "https://docs.laminapdf.com/reference/rust/"
+---
+
+# Rust API (rustdoc)
+
+Where to read the API documentation of the Lamina PDF crates.
+
+docs.rs builds the API documentation of every Lamina PDF crate on crates.io. Start with [`laminapdf` on docs.rs](https://docs.rs/laminapdf/0.2.0-alpha.3/laminapdf/), the crate to depend on. It wraps the core crates and holds `Document`, `Builder`, `Error`, `Warning`, jobs and `CancelToken`.
+
+The other crates are documented the same way:
+
+- [`laminapdf-syntax`](https://docs.rs/laminapdf-syntax/0.2.0-alpha.3/laminapdf_syntax/)
+- [`laminapdf-cos`](https://docs.rs/laminapdf-cos/0.2.0-alpha.3/laminapdf_cos/)
+- [`laminapdf-model`](https://docs.rs/laminapdf-model/0.2.0-alpha.3/laminapdf_model/)
+- [`laminapdf-ops`](https://docs.rs/laminapdf-ops/0.2.0-alpha.3/laminapdf_ops/)
+- [`laminapdf-save`](https://docs.rs/laminapdf-save/0.2.0-alpha.3/laminapdf_save/)
+- [`laminapdf-content`](https://docs.rs/laminapdf-content/0.2.0-alpha.3/laminapdf_content/)
+- [`laminapdf-text`](https://docs.rs/laminapdf-text/0.2.0-alpha.3/laminapdf_text/)
+- [`laminapdf-build`](https://docs.rs/laminapdf-build/0.2.0-alpha.3/laminapdf_build/)
+- [`laminapdf-render-pdfium`](https://docs.rs/laminapdf-render-pdfium/0.2.0-alpha.3/laminapdf_render_pdfium/)
+
+docs.rs couldn't build `laminapdf-source` and `laminapdf-render` at 0.2.0-alpha.2, so their docs come with the next release; until then, build them yourself as below. [Install](../../pages/install.md#every-published-package) lists every crate, with its page on crates.io.
+
+## Build the docs yourself
+
+To read the docs of a change before it's released, build them from a checkout of Lamina PDF:
+
+```sh
+cargo doc --workspace --no-deps --all-features --open
+```
+
+The command opens the docs in your browser. Every public item of every crate is documented.

package/docs/pages/reference/stability.md

@@ -0,0 +1,59 @@
+---
+title: "Stability policy"
+description: "What a Lamina PDF version number promises, and what stays the same in every version."
+version: "0.2.0-alpha.3"
+url: "https://docs.laminapdf.com/reference/stability/"
+---
+
+# Stability policy
+
+What a Lamina PDF version number promises, and what stays the same in every version.
+
+Lamina PDF is in alpha, so its API can still change from one release to the next. A few things never change, whatever the version: error and warning codes, the error object's fields, saved edit logs, and identical output from every runtime. This page says what each version number promises, so you know when an upgrade needs a code change.
+
+## One version for every package
+
+Every crate and every npm package shares one version, and they are released together, from `laminapdf` and its crates to `@laminapdf/sdk` and the viewer. So `@laminapdf/sdk` at a version always runs the Rust code of `laminapdf` at the same version. [Install](../../pages/install.md#every-published-package) lists every package.
+
+## What a version number tells you
+
+- **Alphas promise nothing to each other.** Anything can change between `0.2.0-alpha.1` and `0.2.0-alpha.2`. While you try an alpha, pin the exact version: `npm install --save-exact @laminapdf/sdk@0.2.0-alpha.3`, and `laminapdf = "=0.2.0-alpha.3"` in `Cargo.toml`.
+- **The `alpha` tag names the newest alpha.** `npm install @laminapdf/sdk@alpha` gets it. A plain `npm install @laminapdf/sdk` gets a `0.0.0` placeholder that only reserves the name.
+- **After the alphas, `0.x` versions follow SemVer as Cargo reads it.** A breaking change raises the minor version (`0.2` to `0.3`), and features and fixes raise the patch (`0.2.0` to `0.2.1`). So an upgrade within one `0.x` line never needs a code change.
+
+## What counts as a breaking change
+
+A change breaks your code when it does one of these:
+
+- removes or renames a public Rust item or an export of `@laminapdf/sdk`
+- changes one so that code using it stops compiling or behaves differently from its documentation
+- raises the minimum Rust version, the minimum Node version or the Cloudflare Workers `compatibility_date`
+- adds an error kind, since code that matches on the nine kinds has to handle the new one
+- changes the bytes written for the same input and options
+
+Everything else keeps your code working: new functions, types, options and fields; new error and warning codes; documentation; speed; and fixes that make output follow the PDF standard where it didn't. The changelog lists those fixes.
+
+## What never changes
+
+Four promises hold across every version, `0.x` and alphas included:
+
+- **Error and warning codes are never renamed or reused** for another meaning. A retired code stays in the [code reference](../../errors/README.md) with the version that retired it, and keeps its page. New codes can appear in any release, so handle a code you don't know.
+- **The error object only grows.** Each error names its schema, `laminapdf.error/1`. Within one schema, a field can be added, but never removed or given another type.
+- **Saved edit logs keep loading.** A log names its format version (`{ v: 1, ops }`, as [Edit a PDF](../../pages/guides/edit-a-pdf.md#replay-edits-stored-as-json) shows). A new op or optional field keeps the version. A changed or removed one raises it, and every older version still loads.
+- **The same input gives the same bytes everywhere.** With the same input, options and version, Rust and every JavaScript runtime write identical files.
+
+## How the promises are checked
+
+Lamina PDF compares every change with the newest published release: the Rust crates with [cargo-semver-checks](https://github.com/obi1kenobi/cargo-semver-checks), and `@laminapdf/sdk` with a report of its exported types. A change that breaks either one has to raise the minor version, and the changelog lists it first.
+
+Each release also installs itself twice and runs the quick start: once from the packages before they're published, and once from npm and crates.io after. Both runs cover Node 22, 24 and 26, Deno, Bun, Chromium, Cloudflare Workers and a Rust program, and every run has to write the same `hello.pdf`, byte for byte.
+
+## What isn't promised yet
+
+- The low-level file-structure and model types that `laminapdf` re-exports are public, but they can change in any minor release.
+- Package sizes and speed are measured on every change, not promised.
+- The minimum Rust version is two releases behind the newest stable Rust (1.97 today). Raising it is a minor-version change, and the changelog says so.
+
+## Before you upgrade
+
+The [changelog](../../pages/reference/changelog.md) lists every release's changes, breaking ones first. Read the entries between your version and the new one, then move the exact version you pin.

package/docs/pages/start/coding-agents.md

@@ -0,0 +1,45 @@
+---
+title: "Use Lamina PDF with coding agents"
+description: "Point a coding agent at the docs inside the installed package, so its answers match the version you use."
+version: "0.2.0-alpha.3"
+url: "https://docs.laminapdf.com/start/coding-agents/"
+---
+
+# Use Lamina PDF with coding agents
+
+Point a coding agent at the docs inside the installed package, so its answers match the version you use.
+
+A coding agent guesses a new library's names from what it saw in training, which may be an older version or none at all. Each package therefore carries its own copy of these docs as Markdown. The copy sits in `node_modules/@laminapdf/sdk/docs/` for TypeScript and in the `laminapdf` crate's `docs/` folder for Rust, and every file names the version it describes.
+
+## Add the snippet to your agent's instructions
+
+Copy this snippet into your project's `AGENTS.md`, `CLAUDE.md` or the file your agent reads. It sends the agent to the installed docs first, and it lists the rules where Lamina PDF differs from other PDF libraries:
+
+`packages/sdk/examples/AGENTS.md`:
+
+```md
+## Lamina PDF
+
+This project uses Lamina PDF (`@laminapdf/sdk` in TypeScript, the `laminapdf` crate in Rust) to create, read, edit and save PDF files.
+
+- **Read the installed docs first.** They match the installed version: `node_modules/@laminapdf/sdk/docs/llms.txt` lists every page, and `docs/api/` holds the API reference. In Rust they are in the `laminapdf` crate's `docs/` folder. Online: https://docs.laminapdf.com/llms.txt (the latest version).
+- **Call `await init()` once before anything else.** After it every call is synchronous. Fonts and text need `await init({ text: true })`; reading text needs the extract or text module (`await init({ extract: true })` or `{ text: true }`). Rust needs no setup.
+- **Positions are points from the top-left corner** of the page as it is displayed, with y going down. A text position is its baseline. Page numbers in the API start at 0 (`page(0)` is the first page).
+- **Branch on an error's `code`, never its message.** Every error is a `LaminaPdfError` with a stable `code` (such as `wrong-password`) and a `hint`; `docs/errors/<code>.md` explains each one. Warnings, which say what Lamina PDF repaired in a damaged file, use the same codes.
+- **Free what you open.** A `Document` or `Builder` holds WebAssembly memory: declare it with `using`, or call `free()` when you are done.
+- **Check `docs/renames.json`** when a name in older code or an older answer doesn't exist: it says what each renamed item is called now.
+```
+
+## What the package docs hold
+
+The folder starts at `llms.txt`, an index in the [llms.txt](https://llmstxt.org/) format whose links stay inside the folder:
+
+- `pages/`: every page of this site as Markdown, with the examples written out in full.
+- `errors/`: a page per error and warning code, the same text as the [code pages](../../errors/README.md).
+- `api/`: the TypeScript API reference (npm package only; Rust's is on docs.rs).
+- `renames.json`: what each renamed item is called now, so an agent holding an old name finds the new one.
+- `AGENTS.md`: the snippet above.
+
+## The same docs online
+
+This site serves the same Markdown for the latest version. Each page has a twin at its address with `.md` in place of the final slash, such as [`/install.md`](https://docs.laminapdf.com/install.md), and [`/llms.txt`](https://docs.laminapdf.com/llms.txt) lists them all. [`/llms-full.txt`](https://docs.laminapdf.com/llms-full.txt) puts every page in one file for agents that read a whole site at once. Prefer the package copy while you work in a project, because it matches the code the agent calls.

package/docs/pages/start/first-pdf.md

@@ -0,0 +1,77 @@
+---
+title: "Your first PDF"
+description: "Write hello.pdf from Node in five minutes."
+version: "0.2.0-alpha.3"
+url: "https://docs.laminapdf.com/start/first-pdf/"
+---
+
+# Your first PDF
+
+Write hello.pdf from Node in five minutes.
+
+You'll write `hello.pdf`, one A4 page that says "Hello, world!", from a short Node script. It takes about five minutes.
+
+## Make a project
+
+You need Node 24.2 or newer, which runs `.ts` files directly. Create a folder and install `@laminapdf/sdk` from npm:
+
+```sh
+mkdir hello-pdf && cd hello-pdf
+npm init -y && npm pkg set type=module
+npm install @laminapdf/sdk@0.2.0-alpha.3
+```
+
+Lamina PDF is in alpha, so the install names the version these docs describe. `@laminapdf/sdk` brings its WebAssembly modules, `@laminapdf/wasm`, with it. [Install](../../pages/install.md) covers other package managers and Rust.
+
+## Write the page
+
+Save this app as `hello.ts`. It loads Lamina PDF, builds the page and writes it to `hello.pdf`:
+
+`packages/sdk/examples/quick-start/node.ts`:
+
+```ts
+// Builds a one-page PDF that says "Hello, world!" and writes it to hello.pdf, in Node.
+import { writeFile } from "node:fs/promises";
+import { Builder, type BuilderOptions, Font, init } from "@laminapdf/sdk";
+
+/** The space between the page's edge and the text, in points (72 points = 1 inch). */
+const MARGIN = 72;
+/** The text's size in points; its baseline sits this far below the margin. */
+const FONT_SIZE = 24;
+
+/** Builds the page and hands its bytes to `save`, which writes hello.pdf unless you pass another `save` function. */
+export async function hello(
+  save: (pdf: Uint8Array) => void | Promise<void> = (pdf) => writeFile("hello.pdf", pdf),
+  options: BuilderOptions = {},
+): Promise<void> {
+  await init({ text: true });
+  using builder = new Builder(options);
+  const page = builder.page("A4");
+  // Points from the page's top-left corner, y down; the text's baseline sits FONT_SIZE points below the margin.
+  page.surface().text("Hello, world!", {
+    font: Font.standard("Helvetica"),
+    size: FONT_SIZE,
+    at: [MARGIN, MARGIN + FONT_SIZE],
+  });
+  page.finish();
+  using doc = builder.finish();
+  await save(doc.save());
+}
+
+// `node hello.ts` runs it (Node 24.2 or newer); imported, it only exports `hello`.
+if (import.meta.main) await hello();
+```
+
+## Run it
+
+```sh
+node hello.ts
+```
+
+Node runs the TypeScript file as it is. Open `hello.pdf` in any PDF viewer: one page, with "Hello, world!" near its top-left corner.
+
+## What happened
+
+`init({ text: true })` loaded Lamina PDF's text module, the one that draws fonts; after it, every call is synchronous. The builder made an A4 page, drew the text on it and finished into a document, `doc.save()` turned that document into bytes, and `save` wrote them to `hello.pdf`. `using` freed the builder and the document as soon as the function ended.
+
+Next, see [how Lamina PDF thinks about a PDF](../../pages/concepts/how-lamina-thinks.md) and [where things go on a page](../../pages/concepts/pages-and-coordinates.md). To use laminapdf somewhere other than Node, pick [your runtime](../../pages/quick-start/browser.md).

package/docs/pages/troubleshooting.md

@@ -0,0 +1,74 @@
+---
+title: "Troubleshooting"
+description: "The problems people hit with Lamina PDF, from a missing init() to a signed file that won't save, with the cause and the fix of each."
+version: "0.2.0-alpha.3"
+url: "https://docs.laminapdf.com/troubleshooting/"
+---
+
+# Troubleshooting
+
+The problems people hit with Lamina PDF, from a missing init() to a signed file that won't save, with the cause and the fix of each.
+
+Each entry starts from what you see, then gives the cause and the fix. Errors carry a `code`, and every code has a page that says what to do: search the [error and warning codes](../errors/README.md) for one that isn't here.
+
+## Every call throws `not-initialized`
+
+**Cause:** a function of `@laminapdf/sdk` ran before `init()` finished loading the WebAssembly.
+
+**Fix:** `await init()` once, before anything else. After it, every call is synchronous. See [`not-initialized`](../errors/not-initialized.md).
+
+## Drawing text throws `text-module-not-loaded`
+
+**Cause:** the builder lives in the base module, which has no fonts or text. Lamina PDF loads only the modules you ask for, so a page downloads only what it uses.
+
+**Fix:** load the text module before you create the builder: `init({ text: true })`, or `loadText()` after `init()`. See [`text-module-not-loaded`](../errors/text-module-not-loaded.md) and [Text and fonts](../pages/guides/fonts-and-text.md).
+
+## Reading text throws `extract-module-not-loaded`
+
+**Cause:** the document was opened in the base module, which can't extract text.
+
+**Fix:** load the extract module, with `init({ extract: true })` or `loadExtract()`, or the text module, before you open the document. A Cloudflare Worker can't fetch it, so import it and pass it: `import extract from "@laminapdf/wasm/lamina_pdf_extract.wasm"`, then `await loadExtract(extract)`. See [`extract-module-not-loaded`](../errors/extract-module-not-loaded.md).
+
+## The browser blocks the WebAssembly
+
+**Cause:** the page's Content Security Policy doesn't allow compiling WebAssembly.
+
+**Fix:** add `'wasm-unsafe-eval'` to its `script-src`. Lamina PDF needs nothing else from the policy. See [Browser and bundlers](../pages/quick-start/browser.md).
+
+## `init()` fails in a Vite app
+
+**Cause:** Vite pre-bundles dependencies into its own cache, and the `.wasm` files don't move with the JavaScript that loads them.
+
+**Fix:** exclude the package from pre-bundling: `optimizeDeps: { exclude: ["@laminapdf/sdk"] }` in `vite.config.ts`. A Web Worker that uses `@laminapdf/sdk/worker` needs the same setting. See [Browser and bundlers](../pages/quick-start/browser.md).
+
+## `init()` fails in a Cloudflare Worker
+
+**Cause:** Cloudflare Workers can't compile WebAssembly at run time, so `init()` can't build the modules from bytes or a URL.
+
+**Fix:** let Wrangler bundle the package, and call `init()` without a URL or bytes. Wrangler picks the package's entry for Cloudflare Workers, which imports the `.wasm` files as compiled modules. See [Cloudflare Workers](../pages/quick-start/workers.md).
+
+## Opening a file fails with `password-required` or `wrong-password`
+
+**Cause:** the file is encrypted. `password-required` means you passed no password, and `wrong-password` means the one you passed matches neither of the file's passwords.
+
+**Fix:** ask your user for the password and open the file again with it. Nothing else has changed. See [Open password-protected files](../pages/guides/password-protected-files.md).
+
+## A signed file won't save
+
+**Cause:** saving would break a signature, so the save fails with `would-invalidate-signatures`. A signed file saves only incrementally, and only with the edits its signatures allow.
+
+**Fix:** keep the default save mode and make only edits the signatures allow. To save anyway, ask your user first, then pass `invalidateSignatures: true`. See [Save a PDF](../pages/guides/save-a-pdf.md) and [`would-invalidate-signatures`](../errors/would-invalidate-signatures.md).
+
+## Memory keeps growing
+
+**Cause:** documents and builders live in WebAssembly memory, and the garbage collector frees them late: too late for a long-running page or server. WebAssembly memory also never shrinks, so one large file leaves it large.
+
+**Fix:** free each one when you're done: `using doc = …` frees it at the end of the block, and `doc.free()` at once. A call on a freed one throws `disposed`. To give grown memory back, call `reset()` while no document is in use: every module starts afresh, and handles from before throw `instance-reset`. See [You free what you create](../pages/concepts/how-lamina-thinks.md#you-free-what-you-create).
+
+## A call throws `out-of-memory` or `wasm-trap`
+
+**Cause:** the WebAssembly module ran out of memory (it may grow to 2 GiB), or it trapped on a bug in Lamina PDF. Either leaves the module's memory half-written, so Lamina PDF replaces the module's instance before the next call.
+
+**Fix:** open the document again from its bytes: documents, pages and builders from the old instance throw `instance-reset`. For `out-of-memory`, keep fewer documents open at once and lower the open limits for files you don't trust. Report a `wasm-trap` with the file that causes it. See [`out-of-memory`](../errors/out-of-memory.md) and [`wasm-trap`](../errors/wasm-trap.md).
+
+Next: the [error and warning codes](../errors/README.md), with what each one means and what to do.

package/docs/renames.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "./renames.schema.json",
+  "schema": "laminapdf.renames/1",
+  "renames": [
+    {
+      "from": "laminapdf::extract::TextRun",
+      "to": "laminapdf::extract::PageTextRun",
+      "surface": "rust",
+      "kind": "type",
+      "since": "0.2.0",
+      "note": "An extracted run; TextRun now means only drawn text."
+    },
+    {
+      "from": "laminapdf_text::extract::TextRun",
+      "to": "laminapdf_text::PageTextRun",
+      "surface": "rust",
+      "kind": "type",
+      "since": "0.2.0",
+      "note": "laminapdf-text's extract module is private; its items are at the crate root."
+    },
+    {
+      "from": "laminapdf_text::agl::to_unicode",
+      "to": "laminapdf_text::glyph_name_to_unicode",
+      "surface": "rust",
+      "kind": "function",
+      "since": "0.2.0",
+      "note": "laminapdf-text's agl module is private."
+    },
+    {
+      "from": "laminapdf_text::Tag",
+      "to": "laminapdf_text::OpenTypeTag",
+      "surface": "rust",
+      "kind": "type",
+      "since": "0.2.0",
+      "note": "The façade exports it as laminapdf::OpenTypeTag, for Font::instance."
+    },
+    {
+      "from": "laminapdf_build::Font",
+      "to": "laminapdf_build::FontHandle",
+      "surface": "rust",
+      "kind": "type",
+      "since": "0.2.0",
+      "note": "A font registered with a builder; laminapdf::Font is the font program."
+    },
+    {
+      "from": "laminapdf_content::Color",
+      "to": "laminapdf_content::CurrentColor",
+      "surface": "rust",
+      "kind": "type",
+      "since": "0.2.0",
+      "note": "The content reader's current colour: a colour space, its components and a pattern."
+    },
+    {
+      "from": "laminapdf_content::Matrix::multiply",
+      "to": "laminapdf_model::Matrix::then",
+      "surface": "rust",
+      "kind": "method",
+      "since": "0.2.0",
+      "note": "One Matrix for building and reading; then applies the receiver first."
+    },
+    {
+      "from": "laminapdf_content::Matrix::transform_point",
+      "to": "laminapdf_model::Matrix::apply",
+      "surface": "rust",
+      "kind": "method",
+      "since": "0.2.0",
+      "note": ""
+    },
+    {
+      "from": "laminapdf::CosError",
+      "to": "laminapdf::Error::error_code",
+      "surface": "rust",
+      "kind": "type",
+      "since": "0.2.0",
+      "note": "The crates' errors are opaque behind Error::Core: match on error_code() instead."
+    },
+    {
+      "from": "laminapdf_source::pending_ranges",
+      "to": "laminapdf::Error::pending_ranges",
+      "surface": "rust",
+      "kind": "function",
+      "since": "0.2.0",
+      "note": ""
+    }
+  ]
+}