@murumets-ee/pdf 0.38.0

package/LICENSE

@@ -0,0 +1,94 @@
+Elastic License 2.0 (ELv2)
+
+URL: https://www.elastic.co/licensing/elastic-license
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set
+of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If your company
+makes such a claim, your patent license ends immediately for work on behalf
+of your company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license
+no later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your
+licenses to terminate automatically and permanently.
+
+## No Liability
+
+As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is
+the software the licensor makes available under these terms, including any
+portion of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+**control** means ownership of substantially all the assets of an entity, or
+the power to direct the management and policies of an entity (for example, by
+voting right, contract, or otherwise). Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your
+licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,104 @@
+# @murumets-ee/pdf
+
+A React element tree in, PDF bytes plus a SHA-256 digest out. Domain-free and server-only in
+intent: it knows nothing about contracts, invoices, entities, storage buckets or blocks.
+
+Engine rationale, flip conditions and the determinism policy are locked in
+[`plan/rent/decisions/D028-pdf-package-and-engine.md`](../../plan/rent/decisions/D028-pdf-package-and-engine.md);
+the legal background is [R06](../../plan/rent/research/R06-contract-legal-and-pdf.md).
+
+## Usage
+
+```tsx
+import { createReactPdfRenderer, DEFAULT_FONT_FAMILY } from '@murumets-ee/pdf'
+import { Document, Page, StyleSheet, Text, View } from '@murumets-ee/pdf/primitives'
+
+const styles = StyleSheet.create({
+  page: { fontFamily: DEFAULT_FONT_FAMILY, padding: 40, fontSize: 11 },
+  heading: { fontFamily: DEFAULT_FONT_FAMILY, fontWeight: 700, fontSize: 16 },
+})
+
+const renderer = createReactPdfRenderer()
+
+const { bytes, sha256, byteLength } = await renderer.render(
+  <Document>
+    <Page size="A4" style={styles.page}>
+      <View>
+        <Text style={styles.heading}>Üürileping</Text>
+        <Text>Договор аренды</Text>
+      </View>
+    </Page>
+  </Document>,
+  { creationDate: signedAt, producer: 'Lumi CMS', creator: 'Lumi CMS' },
+)
+```
+
+Build documents out of `@murumets-ee/pdf/primitives` — `Document`, `Page`, `View`, `Text`,
+`Image`, `StyleSheet`, `Font`, plus the `Style` / `Styles` types. Consumers should never add a
+direct `@react-pdf/renderer` dependency; the engine seam is this package.
+
+`creationDate` is **required**. There is no wall-clock default: an implicit `new Date()` is the
+single biggest source of gratuitous non-determinism, and a caller that wants "now" should say so.
+
+## The digest is not a reproducibility claim
+
+`sha256` identifies **the bytes it was returned with**. Re-rendering the same tree with the same
+options is *not* expected to reproduce it, so **re-render-and-compare is not a valid integrity
+check** — it will report a false mismatch on a document nobody touched.
+
+Two independent reasons, both inside the engine:
+
+1. `@react-pdf/renderer` vendors a pdfkit fork whose six-letter font-subset tag (`ABCDEF+NotoSans`)
+   comes from `Math.random()`. Upstream pdfkit derives it from the font's object id; the fork has
+   not picked that up. We deliberately do **not** patch or seed the global RNG — it is
+   process-wide and would corrupt any concurrent render in the same worker.
+2. pdfkit compresses each stream through an **async** `zlib.createDeflate()` and writes each object
+   when *its* deflate finishes, so two streams of different sizes can complete in either order.
+   The `FontFile2` and `ToUnicode` objects are observed swapping places between runs.
+
+What *is* pinned, and covered by tests: the Info dictionary (`/CreationDate`, `/ModificationDate`,
+`/Producer`, `/Creator`), the file `/ID` that pdfkit derives from `md5(info)`, the total byte
+length, and every indirect object's content.
+
+The policy, per [R06](../../plan/rent/research/R06-contract-legal-and-pdf.md) §2: **hash on write,
+persist the exact bytes, never re-render for comparison.** ISO 32000-1 §14.4 says outright that
+*"the calculation of the file identifier need not be reproducible"*, and no e-signature vendor
+re-renders from source to verify — they all hash the stored bytes.
+
+## Fonts
+
+**Noto Sans**, regular + bold, shipped inside the package. A render never fetches a font over the
+network.
+
+One file covers Latin, Latin Extended (Estonian `õäöüšž`), Greek and Cyrillic — these are the
+[`notofonts/latin-greek-cyrillic`](https://github.com/notofonts/latin-greek-cyrillic) static
+builds, and `src/fonts.test.ts` asserts glyph coverage per script rather than assuming it. That
+single-file property is load-bearing: `@react-pdf/renderer` has no `unicode-range` mechanism, so a
+per-script split would need a fallback chain it cannot express, and a missing glyph renders as
+`.notdef` **silently**.
+
+`loadDefaultFonts()` reads both weights off disk *before* the render rather than letting react-pdf
+load them lazily mid-layout — the lazy path changes pdfkit's object emission order, so the first
+render in a process would otherwise differ structurally from every later one.
+
+The fonts are licensed under the **SIL Open Font License 1.1**; the licence text ships with them at
+[`fonts/OFL.txt`](./fonts/OFL.txt). Copyright 2022 The Noto Project Authors. Install weight: ~1.2 MB
+of font files, plus `@react-pdf/renderer` (~33 MB, 67 transitive packages, no native build, no
+postinstall, no browser download).
+
+## Not `server-only`-tagged — deliberately
+
+The package is server-only in intent, but the entry does **not** `import 'server-only'`.
+
+Its consumers reach it from an admin route, which is reachable from a plugin's static entry — the
+exact chain `pnpm verify:plugin-loads` loads under plain Node, where `server-only` throws
+unconditionally. `@murumets-ee/rent`'s `plugin.ts` already dynamic-imports its server-only runtime
+deps to stay jiti-safe; tagging this package would force the same escape hatch on every consumer
+for no security gain, since nothing here reads a request, a session or the database.
+
+`@murumets-ee/storage` carries the tag on `./` precisely because it keeps a *separate*, clean
+`./plugin` entry for the CLI path. This package has no such split — the renderer is the whole
+surface.
+
+Keep it out of any `*-ui/src/pages/**` static-import path (or add it to that package's tsdown
+`neverBundle`) so it is never inlined into a server-pages bundle.

package/dist/index.d.mts

@@ -0,0 +1,143 @@
+import { ReactElement } from "react";
+
+//#region src/digest.d.ts
+/**
+ * Lowercase hex SHA-256 of exactly the bytes in `bytes`.
+ *
+ * Respects `byteOffset` / `byteLength`, so a `Buffer` that is a window into a
+ * larger pooled `ArrayBuffer` hashes its own contents and nothing else.
+ *
+ * See {@link PdfRenderResult.sha256} for what this digest does and does not
+ * attest to — it identifies a specific byte sequence, not a rendering input.
+ */
+declare function sha256Hex(bytes: Uint8Array): string;
+//#endregion
+//#region src/fonts.d.ts
+/**
+ * The one font family this package registers.
+ *
+ * **Noto Sans** (SIL Open Font License 1.1). A single file covers Latin,
+ * Latin Extended (Estonian `õäöüšž`), Greek and Cyrillic — these are the
+ * `notofonts/latin-greek-cyrillic` static builds, verified glyph-by-glyph in
+ * `fonts.test.ts`. That matters because `@react-pdf/renderer` has no
+ * `unicode-range` mechanism: a per-script split would need a fallback chain it
+ * cannot express, and missing glyphs render as `.notdef` **silently**.
+ */
+declare const DEFAULT_FONT_FAMILY = "Noto Sans";
+/**
+ * Absolute paths to the bundled font files. They ship **inside the package**;
+ * a render never fetches a font over the network.
+ */
+declare const NOTO_SANS_FILES: {
+  readonly regular: string;
+  readonly bold: string;
+};
+/** The SIL Open Font License 1.1 text that covers {@link NOTO_SANS_FILES}. */
+declare const NOTO_SANS_LICENSE_FILE: string;
+/**
+ * Register {@link DEFAULT_FONT_FAMILY} on react-pdf's font store.
+ *
+ * Idempotent: react-pdf's store is a module singleton, and `register` appends
+ * to a family's source list rather than replacing it, so a naive repeat call
+ * would stack duplicates. The guard reads the store instead of tracking local
+ * state, so it stays correct across a caller's `Font.reset()`.
+ */
+declare function registerDefaultFonts(): void;
+/**
+ * Register the default family AND read both weights off disk before returning.
+ *
+ * This is a determinism fix, not a performance one. react-pdf loads a font
+ * lazily, mid-layout, the first time a glyph needs it — and that extra `await`
+ * changes the order in which pdfkit emits objects, so the FIRST render in a
+ * process produces a different object numbering (and different xref offsets)
+ * than every render after it. Measured: renders 2/3/4 were byte-identical once
+ * the subset tag is normalised away, render 1 was not. Pre-loading collapses
+ * that difference.
+ *
+ * Bounded by construction: exactly the two weights this package registers, no
+ * fan-out over a caller-supplied list. A consumer that registers additional
+ * families is responsible for warming them the same way.
+ */
+declare function loadDefaultFonts(): Promise<void>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Document-level metadata pinned onto every render.
+ *
+ * Everything here exists to remove *gratuitous* non-determinism from the
+ * output. It is deliberately small: this package renders a React tree, it does
+ * not model documents.
+ */
+interface PdfRenderOptions {
+  /**
+   * Pinned document timestamps. REQUIRED — callers must pass a deliberate value.
+   * There is no wall-clock default: an implicit `new Date()` is the single biggest
+   * source of gratuitous non-determinism, and a caller that wants "now" should say so.
+   */
+  readonly creationDate: Date;
+  readonly modificationDate?: Date;
+  readonly producer?: string;
+  readonly creator?: string;
+}
+interface PdfRenderResult {
+  readonly bytes: Uint8Array;
+  /**
+   * Lowercase hex SHA-256 of `bytes`, computed over exactly what is returned.
+   *
+   * ## This digest identifies THESE BYTES — it is not a reproducibility claim
+   *
+   * Re-rendering the same React tree with the same {@link PdfRenderOptions} is
+   * **not** expected to reproduce this digest, and **re-render-and-compare is
+   * therefore not a valid integrity check**. Doing so will report a false
+   * mismatch on a document that was never touched.
+   *
+   * The concrete reason: `@react-pdf/renderer` vendors a fork of pdfkit whose
+   * font-subset tag (the six-letter `ABCDEF+` prefix on `/BaseFont`) comes from
+   * `Math.random()`. Upstream pdfkit derives that tag from the font's object id;
+   * the fork has not picked the change up. We deliberately do **not** patch or
+   * seed the global RNG to work around it — see
+   * `plan/rent/decisions/D028-pdf-package-and-engine.md`.
+   *
+   * The policy, per `plan/rent/research/R06-contract-legal-and-pdf.md` §2:
+   * **hash on write, persist the exact bytes, never re-render for comparison.**
+   * That is also the legally correct model and matches universal industry
+   * practice — ISO 32000-1 §14.4 states outright that *"the calculation of the
+   * file identifier need not be reproducible"*, and no e-signature vendor
+   * re-renders from source to verify; they all hash the stored bytes.
+   *
+   * To verify a stored document: hash the stored bytes and compare against the
+   * digest recorded at write time. Never regenerate the document.
+   */
+  readonly sha256: string;
+  readonly byteLength: number;
+}
+/**
+ * The engine seam. One implementation ships today
+ * (`createReactPdfRenderer`); the interface exists so a swap costs one
+ * package rather than every consumer.
+ */
+interface PdfRenderer {
+  render(document: ReactElement, options: PdfRenderOptions): Promise<PdfRenderResult>;
+}
+//#endregion
+//#region src/react-pdf-renderer.d.ts
+/**
+ * The `@react-pdf/renderer` implementation of {@link PdfRenderer}.
+ *
+ * Stateless and cheap to construct — react-pdf's font store is a module
+ * singleton, so several renderers share one registration. Renders happen
+ * entirely in-process: no browser, no sidecar, no network (the fonts ship
+ * inside this package), and the document never executes script.
+ *
+ * @example
+ * ```ts
+ * const renderer = createReactPdfRenderer()
+ * const { bytes, sha256 } = await renderer.render(<Document>…</Document>, {
+ *   creationDate: signedAt, // a deliberate instant, never `new Date()` by default
+ * })
+ * ```
+ */
+declare function createReactPdfRenderer(): PdfRenderer;
+//#endregion
+export { DEFAULT_FONT_FAMILY, NOTO_SANS_FILES, NOTO_SANS_LICENSE_FILE, type PdfRenderOptions, type PdfRenderResult, type PdfRenderer, createReactPdfRenderer, loadDefaultFonts, registerDefaultFonts, sha256Hex };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/digest.ts","../src/fonts.ts","../src/types.ts","../src/react-pdf-renderer.ts"],"mappings":";;;;;;AAWA;;;;AAA2C;;iBAA3B,SAAA,CAAU,KAAiB,EAAV,UAAU;;;;;;AAA3C;;;;AAA2C;;;cCG9B,mBAAA;AAAb;;;;AAAA,cAiBa,eAAA;EAAA,SAGH,OAAA;EAAA,SAAA,IAAA;AAAA;;cAGG,sBAAA;AAAb;;;;AAA+D;AAU/D;;;AAVA,iBAUgB,oBAAA,CAAA;AAAoB;AA2BpC;;;;AAAiD;;;;ACjEjD;;;;;;ADsCoC,iBA2Bd,gBAAA,CAAA,GAAoB,OAAO;;;;;AD/DjD;;;;AAA2C;UEF1B,gBAAA;;;ADKjB;;;WCCW,YAAA,EAAc,IAAA;EAAA,SACd,gBAAA,GAAmB,IAAI;EAAA,SACvB,QAAA;EAAA,SACA,OAAA;AAAA;AAAA,UAGM,eAAA;EAAA,SACN,KAAA,EAAO,UAAU;EDef;;;;AAAkD;AAU/D;;;;AAAoC;AA2BpC;;;;AAAiD;;;;ACjEjD;;;;;;;;;ED4Ba,SCaF,MAAA;EAAA,SACA,UAAA;AAAA;AA9BX;;;;;AAAA,UAsCiB,WAAA;EACf,MAAA,CAAO,QAAA,EAAU,YAAA,EAAc,OAAA,EAAS,gBAAA,GAAmB,OAAA,CAAQ,eAAA;AAAA;;;;;AFjDrE;;;;AAA2C;;;;ACG3C;;;;AAAgC;AAiBhC;iBEyBgB,sBAAA,CAAA,GAA0B,WAAW"}

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{createHash as e}from"node:crypto";import{dirname as t,join as n}from"node:path";import{fileURLToPath as r}from"node:url";import{Document as i,Font as a,renderToBuffer as o}from"@react-pdf/renderer";import{cloneElement as s,isValidElement as c}from"react";function l(t){return e(`sha256`).update(t).digest(`hex`)}const u=`Noto Sans`,d=n(t(r(import.meta.url)),`..`,`fonts`),f={regular:n(d,`NotoSans-Regular.ttf`),bold:n(d,`NotoSans-Bold.ttf`)},p=n(d,`OFL.txt`);function m(){a.getRegisteredFontFamilies().includes(`Noto Sans`)||a.register({family:u,fonts:[{src:f.regular,fontWeight:400},{src:f.bold,fontWeight:700}]})}async function h(){m(),await Promise.all([a.load({fontFamily:u,fontWeight:400}),a.load({fontFamily:u,fontWeight:700})])}function g(e,t){if(!c(e)||e.type!==i)throw TypeError(`The root element passed to PdfRenderer.render must be a <Document> from @murumets-ee/pdf/primitives. Cloning any other element would attach the pinned creationDate/producer/creator to props that nothing reads, silently producing a document stamped with the wall-clock time instead.`);return s(e,{creationDate:t.creationDate,...t.modificationDate!==void 0&&{modificationDate:t.modificationDate},...t.producer!==void 0&&{producer:t.producer},...t.creator!==void 0&&{creator:t.creator}})}function _(){return{async render(e,t){await h();let n=await o(g(e,t));return{bytes:n,sha256:l(n),byteLength:n.byteLength}}}}export{u as DEFAULT_FONT_FAMILY,f as NOTO_SANS_FILES,p as NOTO_SANS_LICENSE_FILE,_ as createReactPdfRenderer,h as loadDefaultFonts,m as registerDefaultFonts,l as sha256Hex};
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/digest.ts","../src/fonts.ts","../src/react-pdf-renderer.ts"],"sourcesContent":["import { createHash } from 'node:crypto'\n\n/**\n * Lowercase hex SHA-256 of exactly the bytes in `bytes`.\n *\n * Respects `byteOffset` / `byteLength`, so a `Buffer` that is a window into a\n * larger pooled `ArrayBuffer` hashes its own contents and nothing else.\n *\n * See {@link PdfRenderResult.sha256} for what this digest does and does not\n * attest to — it identifies a specific byte sequence, not a rendering input.\n */\nexport function sha256Hex(bytes: Uint8Array): string {\n  return createHash('sha256').update(bytes).digest('hex')\n}\n","import { dirname, join } from 'node:path'\nimport { fileURLToPath } from 'node:url'\nimport { Font } from '@react-pdf/renderer'\n\n/**\n * The one font family this package registers.\n *\n * **Noto Sans** (SIL Open Font License 1.1). A single file covers Latin,\n * Latin Extended (Estonian `õäöüšž`), Greek and Cyrillic — these are the\n * `notofonts/latin-greek-cyrillic` static builds, verified glyph-by-glyph in\n * `fonts.test.ts`. That matters because `@react-pdf/renderer` has no\n * `unicode-range` mechanism: a per-script split would need a fallback chain it\n * cannot express, and missing glyphs render as `.notdef` **silently**.\n */\nexport const DEFAULT_FONT_FAMILY = 'Noto Sans'\n\n/**\n * Package-relative, resolved from this module's own URL rather than `cwd`.\n *\n * `src/fonts.ts` and the bundled `dist/*.mjs` sit at the same depth, so\n * `../fonts` is correct under both vitest (source) and a published install\n * (dist). Built with `fileURLToPath` + `join` on purpose — a bundler rewrites\n * `new URL('...', import.meta.url)` into an asset reference, which would break\n * the published path.\n */\nconst FONT_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', 'fonts')\n\n/**\n * Absolute paths to the bundled font files. They ship **inside the package**;\n * a render never fetches a font over the network.\n */\nexport const NOTO_SANS_FILES = {\n  regular: join(FONT_DIR, 'NotoSans-Regular.ttf'),\n  bold: join(FONT_DIR, 'NotoSans-Bold.ttf'),\n} as const\n\n/** The SIL Open Font License 1.1 text that covers {@link NOTO_SANS_FILES}. */\nexport const NOTO_SANS_LICENSE_FILE = join(FONT_DIR, 'OFL.txt')\n\n/**\n * Register {@link DEFAULT_FONT_FAMILY} on react-pdf's font store.\n *\n * Idempotent: react-pdf's store is a module singleton, and `register` appends\n * to a family's source list rather than replacing it, so a naive repeat call\n * would stack duplicates. The guard reads the store instead of tracking local\n * state, so it stays correct across a caller's `Font.reset()`.\n */\nexport function registerDefaultFonts(): void {\n  if (Font.getRegisteredFontFamilies().includes(DEFAULT_FONT_FAMILY)) return\n\n  Font.register({\n    family: DEFAULT_FONT_FAMILY,\n    fonts: [\n      { src: NOTO_SANS_FILES.regular, fontWeight: 400 },\n      { src: NOTO_SANS_FILES.bold, fontWeight: 700 },\n    ],\n  })\n}\n\n/**\n * Register the default family AND read both weights off disk before returning.\n *\n * This is a determinism fix, not a performance one. react-pdf loads a font\n * lazily, mid-layout, the first time a glyph needs it — and that extra `await`\n * changes the order in which pdfkit emits objects, so the FIRST render in a\n * process produces a different object numbering (and different xref offsets)\n * than every render after it. Measured: renders 2/3/4 were byte-identical once\n * the subset tag is normalised away, render 1 was not. Pre-loading collapses\n * that difference.\n *\n * Bounded by construction: exactly the two weights this package registers, no\n * fan-out over a caller-supplied list. A consumer that registers additional\n * families is responsible for warming them the same way.\n */\nexport async function loadDefaultFonts(): Promise<void> {\n  registerDefaultFonts()\n\n  await Promise.all([\n    Font.load({ fontFamily: DEFAULT_FONT_FAMILY, fontWeight: 400 }),\n    Font.load({ fontFamily: DEFAULT_FONT_FAMILY, fontWeight: 700 }),\n  ])\n}\n","import { Document, type DocumentProps, renderToBuffer } from '@react-pdf/renderer'\nimport { type ReactElement, cloneElement, isValidElement } from 'react'\nimport { sha256Hex } from './digest.js'\nimport { loadDefaultFonts } from './fonts.js'\nimport type { PdfRenderOptions, PdfRenderResult, PdfRenderer } from './types.js'\n\n/**\n * Attach the caller's pinned metadata to the root `<Document>`.\n *\n * Everything downstream follows from these four props: pdfkit derives `/ID`\n * from `md5(info)` (not from a random source) and the XMP `xmp:CreateDate`\n * from `info.CreationDate`, so pinning the dates pins those too. Left\n * unpinned, react-pdf substitutes `new Date()` plus `producer`/`creator` of\n * `'react-pdf'` — the gratuitous non-determinism this package exists to\n * remove.\n *\n * Fields the caller omitted are omitted here as well, so react-pdf's own\n * defaults apply rather than a value this package invented.\n */\nfunction pinDocumentMetadata(\n  document: ReactElement,\n  options: PdfRenderOptions,\n): ReactElement<DocumentProps> {\n  if (!isValidElement(document) || document.type !== Document) {\n    throw new TypeError(\n      'The root element passed to PdfRenderer.render must be a <Document> from ' +\n        '@murumets-ee/pdf/primitives. Cloning any other element would attach the pinned ' +\n        'creationDate/producer/creator to props that nothing reads, silently producing a ' +\n        'document stamped with the wall-clock time instead.',\n    )\n  }\n\n  return cloneElement(document as ReactElement<DocumentProps>, {\n    creationDate: options.creationDate,\n    ...(options.modificationDate !== undefined && { modificationDate: options.modificationDate }),\n    ...(options.producer !== undefined && { producer: options.producer }),\n    ...(options.creator !== undefined && { creator: options.creator }),\n  })\n}\n\n/**\n * The `@react-pdf/renderer` implementation of {@link PdfRenderer}.\n *\n * Stateless and cheap to construct — react-pdf's font store is a module\n * singleton, so several renderers share one registration. Renders happen\n * entirely in-process: no browser, no sidecar, no network (the fonts ship\n * inside this package), and the document never executes script.\n *\n * @example\n * ```ts\n * const renderer = createReactPdfRenderer()\n * const { bytes, sha256 } = await renderer.render(<Document>…</Document>, {\n *   creationDate: signedAt, // a deliberate instant, never `new Date()` by default\n * })\n * ```\n */\nexport function createReactPdfRenderer(): PdfRenderer {\n  return {\n    async render(document: ReactElement, options: PdfRenderOptions): Promise<PdfRenderResult> {\n      // Awaited BEFORE the render, not during it — see `loadDefaultFonts`.\n      await loadDefaultFonts()\n\n      const buffer = await renderToBuffer(pinDocumentMetadata(document, options))\n      // `Buffer` IS a `Uint8Array`; no copy, and the digest below covers this\n      // exact view (offset + length), not the whole backing ArrayBuffer.\n      const bytes: Uint8Array = buffer\n\n      return {\n        bytes,\n        sha256: sha256Hex(bytes),\n        byteLength: bytes.byteLength,\n      }\n    },\n  }\n}\n"],"mappings":"sQAWA,SAAgB,EAAU,EAA2B,CACnD,OAAO,EAAW,QAAQ,CAAC,CAAC,OAAO,CAAK,CAAC,CAAC,OAAO,KAAK,CACxD,CCCA,MAAa,EAAsB,YAW7B,EAAW,EAAK,EAAQ,EAAc,OAAO,KAAK,GAAG,CAAC,EAAG,KAAM,OAAO,EAM/D,EAAkB,CAC7B,QAAS,EAAK,EAAU,sBAAsB,EAC9C,KAAM,EAAK,EAAU,mBAAmB,CAC1C,EAGa,EAAyB,EAAK,EAAU,SAAS,EAU9D,SAAgB,GAA6B,CACvC,EAAK,0BAA0B,CAAC,CAAC,SAAA,WAA4B,GAEjE,EAAK,SAAS,CACZ,OAAQ,EACR,MAAO,CACL,CAAE,IAAK,EAAgB,QAAS,WAAY,GAAI,EAChD,CAAE,IAAK,EAAgB,KAAM,WAAY,GAAI,CAC/C,CACF,CAAC,CACH,CAiBA,eAAsB,GAAkC,CACtD,EAAqB,EAErB,MAAM,QAAQ,IAAI,CAChB,EAAK,KAAK,CAAE,WAAY,EAAqB,WAAY,GAAI,CAAC,EAC9D,EAAK,KAAK,CAAE,WAAY,EAAqB,WAAY,GAAI,CAAC,CAChE,CAAC,CACH,CC9DA,SAAS,EACP,EACA,EAC6B,CAC7B,GAAI,CAAC,EAAe,CAAQ,GAAK,EAAS,OAAS,EACjD,MAAU,UACR,2RAIF,EAGF,OAAO,EAAa,EAAyC,CAC3D,aAAc,EAAQ,aACtB,GAAI,EAAQ,mBAAqB,IAAA,IAAa,CAAE,iBAAkB,EAAQ,gBAAiB,EAC3F,GAAI,EAAQ,WAAa,IAAA,IAAa,CAAE,SAAU,EAAQ,QAAS,EACnE,GAAI,EAAQ,UAAY,IAAA,IAAa,CAAE,QAAS,EAAQ,OAAQ,CAClE,CAAC,CACH,CAkBA,SAAgB,GAAsC,CACpD,MAAO,CACL,MAAM,OAAO,EAAwB,EAAqD,CAExF,MAAM,EAAiB,EAKvB,IAAM,EAAoB,MAHL,EAAe,EAAoB,EAAU,CAAO,CAAC,EAK1E,MAAO,CACL,QACA,OAAQ,EAAU,CAAK,EACvB,WAAY,EAAM,UACpB,CACF,CACF,CACF"}

package/dist/primitives.d.mts

@@ -0,0 +1,10 @@
+import { Document, Font, Image, Page, StyleSheet, StyleSheet as StyleSheet$1, Text, View } from "@react-pdf/renderer";
+
+//#region src/primitives.d.ts
+/** The map shape accepted by `StyleSheet.create`. */
+type Styles = Parameters<typeof StyleSheet$1.create>[0];
+/** A single style object — what a `style` prop takes. */
+type Style = Styles[string];
+//#endregion
+export { Document, Font, Image, Page, Style, StyleSheet, Styles, Text, View };
+//# sourceMappingURL=primitives.d.mts.map

package/dist/primitives.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitives.d.mts","names":[],"sources":["../src/primitives.ts"],"mappings":";;;AAkBA;AAAA,KAHY,MAAA,GAAS,UAAU,QAAQ,YAAA,CAAe,MAAA;;KAG1C,KAAA,GAAQ,MAAM"}

package/dist/primitives.mjs

@@ -0,0 +1 @@
+import{Document as e,Font as t,Image as n,Page as r,StyleSheet as i,Text as a,View as o}from"@react-pdf/renderer";export{e as Document,t as Font,n as Image,r as Page,i as StyleSheet,a as Text,o as View};

package/fonts/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@murumets-ee/pdf",
+  "version": "0.38.0",
+  "license": "Elastic-2.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./primitives": {
+      "types": "./dist/primitives.d.mts",
+      "import": "./dist/primitives.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "fonts"
+  ],
+  "dependencies": {
+    "@react-pdf/renderer": "^4.5.1"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0"
+  },
+  "devDependencies": {
+    "@types/fontkit": "^2.0.9",
+    "@types/node": "^20.19.42",
+    "@types/react": "^19.2.17",
+    "fontkit": "^2.0.4",
+    "react": "19.2.7",
+    "tsdown": "^0.22.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  },
+  "typeCoverage": {
+    "atLeast": 100
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}