@broadpaper/license 0.1.1

package/LICENSE

@@ -0,0 +1,143 @@
+BroadPaper — Software Licence
+
+Copyright (c) 2026 Codingbadger Creative Limited, trading as BroadPaper.
+Registered in England and Wales, company number 16896863.
+hello@broadpaper.com
+
+This is proprietary software, not open source. It is free to evaluate, with
+every feature enabled and no trial clock, and requires a paid Licence for
+production use. The full agreement is the Terms and Conditions at
+https://www.broadpaper.com/legal/terms/ ; this notice is the part of it you need
+in the package, and where the two differ, those Terms prevail.
+
+Version of 9 September 2026.
+
+
+1. DEFINITIONS
+
+"Software" means the BroadPaper packages published by us — @broadpaper/core,
+@broadpaper/blocks, @broadpaper/renderer, @broadpaper/forme, @broadpaper/pdf,
+@broadpaper/server, @broadpaper/license, @broadpaper/editor, @broadpaper/react,
+@broadpaper/angular and BroadPaper.Client — together with their documentation
+and updates.
+
+"Licence" means a signed licence certificate we have issued to your
+Organisation, and the rights granted with it. A Licence belongs to the
+Organisation, not to an individual.
+
+"Product" means an application your Organisation builds that incorporates the
+Software.
+
+"Internal User" means someone who works for your Organisation: an employee, an
+officer, or a contractor engaged by you and working under your direction.
+"External User" means anyone else, including your customers, their staff, your
+partners and the public.
+
+"Licence Year" means the twelve months from the date a paid Licence is issued
+or renewed.
+
+
+2. EVALUATION
+
+You may install and use the Software free of charge, worldwide and
+non-exclusively, for development, testing and evaluation. Every feature is
+enabled, nothing expires, and there is no limit on how long you take.
+
+Documents generated without a paid Licence carry a visible BroadPaper
+evaluation mark. This grant does not permit production use, whether or not you
+charge for it and whether or not the mark is present in the output. Removing,
+suppressing or circumventing the mark does not make unlicensed production use
+permitted.
+
+
+3. PAID LICENCES
+
+Subject to payment, we grant your Organisation a non-exclusive,
+non-transferable, worldwide licence to install and use the Software in
+Products, in any number of Products and for an unlimited number of users,
+developers, documents and renders. Two types are offered, unlocking identical
+software and differing only in who the resulting Product may be made available
+to:
+
+  Internal    — Products for your Organisation's Internal Users only.
+  SaaS / OEM  — the above, and Products made available to External Users:
+                software you sell, host, embed, ship or otherwise make
+                available outside your Organisation.
+
+Because the Software cannot and does not detect how it is deployed, which type
+you need is determined by the use you actually make of it, not by what the
+software permits.
+
+A Licence runs for the Licence Year. When it ends you may continue to use any
+version of the Software released during a Licence Year you paid for,
+indefinitely and under this notice, but you will receive no further updates or
+support unless you renew, and the Software stops rendering without the
+evaluation mark once the certificate's grace period has passed.
+
+
+4. REDISTRIBUTION
+
+You may redistribute the Software only as a compiled, integrated part of a
+Product. You may not distribute it on its own, offer it as a component for
+others to build with, or make its functionality available as a stand-alone
+report-design service. The end users of your Product do not need their own
+Licence.
+
+
+5. LICENCE CERTIFICATES
+
+A Licence is a cryptographically signed certificate recording your
+Organisation, its Licence type and its expiry date. The Software verifies it
+locally, against a public key compiled into the package, and makes no network
+call to do so.
+
+It is not a secret, and we do not ask you to treat it as one: it may appear in
+your application's configuration, its build and its distributed code. You may
+not share it with anyone outside your Organisation for their own use, alter it,
+or interfere with the Software's licence checking or its evaluation mark.
+
+
+6. RESTRICTIONS
+
+Except as expressly permitted above, you may not: copy, modify, translate or
+create derivative works of the Software beyond what integrating it into your
+Product requires; reverse engineer it beyond what applicable law allows; remove
+any proprietary notice; use it to build a competing report designer; or use it
+in breach of any law, including to generate documents intended to deceive.
+
+We own the Software and everything in it that is not third-party material.
+Nothing here transfers ownership. Your templates, your data, your themes and
+the documents your Product produces are yours; we claim no rights in them and,
+because the Software makes no calls to us, we never receive them.
+
+
+7. THIRD-PARTY COMPONENTS
+
+The Software incorporates third-party components under their own licences.
+These are listed in the THIRD-PARTY-NOTICES.md file distributed with each
+package — including the fonts and Rust crates statically linked into the Forme
+engine, which no dependency manifest reveals. Those licences govern those
+components.
+
+
+8. NO WARRANTY, AND LIABILITY
+
+Except for the limited ninety-day warranty in the Terms, the Software is
+provided "AS IS", without warranty of any kind, express or implied, including
+merchantability, fitness for a particular purpose and non-infringement. We do
+not warrant that the Software is error-free, or that a document it produces
+meets any regulatory or legal requirement that applies to you: that remains
+your responsibility.
+
+To the extent the law allows, we are not liable for any loss of profit,
+revenue, business, data or goodwill, or for any indirect or consequential
+loss. Our total liability in any twelve-month period is limited to the amount
+you paid us in that period, or $100 if you paid nothing. Nothing here limits
+liability for death or personal injury caused by negligence, for fraud, or for
+anything else that cannot be limited by law.
+
+This notice is governed by the law of England and Wales.
+
+
+Questions, and licence purchases: hello@broadpaper.com
+Pricing and the full Terms: https://www.broadpaper.com/legal/terms/

package/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,255 @@
+# Third-party notices
+
+BroadPaper is built on the work below. This file is generated by
+`scripts/third-party-notices.mjs` from what is actually installed — including
+the contents of the WebAssembly engine, which carries its own dependencies and
+its own fonts inside a single binary. Do not edit it by hand.
+
+It ships inside every published package and beside the demo, because two of the
+licences here require their notice to travel with the software.
+
+## The PDF engine
+
+`@formepdf/core` and `@formepdf/shared` — the browserless layout and PDF engine,
+Rust compiled to WebAssembly. Used unmodified, as an npm dependency.
+
+    MIT License
+
+    Copyright (c) 2026 Daniel Molitor
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+
+## Fonts inside the engine
+
+The engine binary carries complete font files, and subsets of them are embedded
+into any PDF containing a character the standard PDF faces cannot represent — a
+Greek or Cyrillic name, a symbol. Documents produced this way are unrestricted:
+the licence below exempts anything created *with* the font. The notice is
+required because the font software itself travels inside the engine.
+
+### Noto Sans Regular
+
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
+
+Licensed under the SIL Open Font License, Version 1.1.
+
+Its own declaration, verbatim from the font's name table:
+
+    Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-
+    greek-cyrillic)Noto SansRegular2.015;GOOG;NotoSans-RegularNoto Sans RegularV
+    ersion 2.015; ttfautohint (v1.8.4.7-5d5b)NotoSans-RegularNoto is a trademark
+     of Google LLC.Monotype Imaging Inc.Monotype Design TeamDesigned by Monotype
+     design team, Irene Vlachou.http://www.google.com/get/noto/http://www.monoty
+    pe.com/studioThis Font Software is licensed under the SIL Open Font License,
+     Version 1.1. This license is available with a FAQ at: https://scripts.sil.o
+    rg/OFLhttps://scripts.sil.org/OFLflorin symbolTitling Alternates I and J for
+     titling and all cap settingsAccented Greek SCiota adscrip
+    t
+
+### Noto Sans Bold
+
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
+
+Licensed under the SIL Open Font License, Version 1.1.
+
+Its own declaration, verbatim from the font's name table:
+
+    Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-
+    greek-cyrillic)Noto SansBold2.015;GOOG;NotoSans-BoldNoto Sans BoldVersion 2.
+    015; ttfautohint (v1.8.4.7-5d5b)NotoSans-BoldNoto is a trademark of Google L
+    LC.Monotype Imaging Inc.Monotype Design TeamDesigned by Monotype design team
+    , Irene Vlachou.http://www.google.com/get/noto/http://www.monotype.com/studi
+    oThis Font Software is licensed under the SIL Open Font License, Version 1.1
+    . This license is available with a FAQ at: https://scripts.sil.org/OFLhttps:
+    //scripts.sil.org/OFLflorin symbolTitling Alternates I and J for titling and
+     all cap settingsAccented Greek SCiota adscrip
+    t
+
+    -----------------------------------------------------------
+    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.
+
+## Rust crates inside the engine
+
+These 38 crates are statically linked into the engine binary and are
+therefore redistributed with it. The list is read out of the compiled artefact
+rather than from a manifest, so it reflects what is genuinely in there.
+
+- aho-corasick-1.1.4
+- barcoders-2.0.0
+- base64-0.22.1
+- base64ct-1.8.3
+- console_error_panic_hook-0.1.7
+- const-oid-0.9.6
+- der-0.7.10
+- fdeflate-0.3.7
+- hypher-0.1.6
+- image-0.24.9
+- itoa-1.0.17
+- jpeg-decoder-0.3.2
+- memchr-2.8.0
+- miniz_oxide-0.7.4
+- num-bigint-dig-0.8.6
+- num-integer-0.1.46
+- pem-rfc7468-0.7.0
+- png-0.17.16
+- qrcode-0.14.1
+- quick-xml-0.37.5
+- regex-1.12.3
+- regex-automata-0.4.14
+- regex-syntax-0.8.10
+- rsa-0.9.10
+- rustybuzz-0.20.1
+- serde-1.0.228
+- serde-wasm-bindgen-0.6.5
+- serde_core-1.0.228
+- serde_json-1.0.149
+- signature-2.2.0
+- smallvec-1.15.1
+- ttf-parser-0.25.1
+- unicode-bidi-0.3.18
+- unicode-bidi-mirroring-0.4.0
+- unicode-linebreak-0.1.5
+- unicode-properties-0.1.4
+- unicode-script-0.5.8
+- wasm-bindgen-0.2.108
+
+## npm dependencies
+
+Runtime dependencies of the published packages. A consumer installs these from
+npm themselves, under the licences their own packages carry.
+
+| Package | Version | Licence |
+| --- | --- | --- |
+| `@floating-ui/react` | 0.27.20 | MIT |
+| `@formepdf/core` | 0.20.0 | MIT |
+| `@formepdf/shared` | 0.20.0 | MIT |
+| `@noble/ed25519` | 3.2.0 | MIT |
+| `d3-scale` | 4.0.2 | ISC |
+| `d3-shape` | 3.2.0 | ISC |
+| `immer` | 10.2.0 | MIT |
+| `lucide-react` | 0.469.0 | ISC |
+| `pdf-lib` | 1.17.1 | MIT |
+| `prosemirror-commands` | 1.7.2 | MIT |
+| `prosemirror-history` | 1.5.0 | MIT |
+| `prosemirror-keymap` | 1.2.3 | MIT |
+| `prosemirror-model` | 1.25.11 | MIT |
+| `prosemirror-schema-list` | 1.5.1 | MIT |
+| `prosemirror-state` | 1.4.4 | MIT |
+| `prosemirror-view` | 1.42.3 | MIT |
+| `react` | 19.2.8 | MIT |
+| `react-dom` | 19.2.8 | MIT |
+| `tslib` | 2.8.1 | 0BSD |
+| `zod` | 3.25.76 | MIT |
+
+### A note on the Chromium backend
+
+`@broadpaper/pdf` drives headless Chromium through Playwright, which is an
+optional peer dependency: it is absent from the table above because the host
+installs it deliberately, not because the backend stopped needing it.
+`playwright-core` is Apache-2.0, but it *downloads a browser build separately
+at install time*. That browser is covered by nothing here: it carries its own
+licences, several of them, and they are not ours to restate. Anyone shipping an
+image built on that backend needs to carry Chromium's notices too. The
+browserless engine named at the top of this file has no such tail, which is one
+of the reasons it is the recommended backend.
+

package/dist/index.d.ts

@@ -0,0 +1,372 @@
+/**
+ * The licence certificate and the states it can be in.
+ *
+ * A BroadPaper licence is a signed certificate, not a secret. It says who
+ * bought what and until when, BroadPaper signs it, and the SDK checks that
+ * signature with a public key compiled into the package. Nothing here talks to
+ * a network, reads a machine identifier or writes a file: a licence that is
+ * valid on a laptop with no route to the internet is valid, full stop.
+ */
+/**
+ * What the licence permits. Not a feature gate — both entitlements unlock
+ * exactly the same software. The difference is who the resulting application
+ * may be put in front of, which is a contractual matter and is presented as
+ * one in the account area and the licence agreement.
+ */
+type Entitlement = "internal" | "saas";
+/** The product a licence is for. Present so one signing key can serve more later. */
+declare const PRODUCT = "broadpaper-sdk";
+/**
+ * The signed payload.
+ *
+ * `customerId` is the durable identifier of the buying organisation — a Clerk
+ * organisation id — rather than an email address, because people change
+ * addresses and organisations outlive their founders.
+ *
+ * Times are epoch **seconds**, not milliseconds: the payload is base64'd into
+ * a string a developer will paste into a config file, and three characters per
+ * timestamp is three characters.
+ */
+interface LicensePayload {
+    /** Payload schema version. Bumped only when the meaning of a field changes. */
+    version: 1;
+    /** Which signing key signed this. Lets keys be rotated without reissuing everything. */
+    keyId: string;
+    /**
+     * BroadPaper's own identifier for *this certificate*, `lic_…`.
+     *
+     * One per issuance, so a renewal or an upgrade carries a new one and the
+     * document it produced can be dated from it. The customer is identified by
+     * `customerId`, which does not change.
+     */
+    licenseId: string;
+    /** The licensed organisation's durable id. */
+    customerId: string;
+    /** The organisation's name, for display in warnings and PDF metadata. */
+    customerName: string;
+    product: typeof PRODUCT;
+    entitlement: Entitlement;
+    /** Epoch seconds. */
+    issuedAt: number;
+    /** Epoch seconds. */
+    expiresAt: number;
+}
+/**
+ * Why a licence is not being honoured, or how it is being honoured.
+ *
+ * These are deliberately coarse. A developer needs to know whether their PDFs
+ * will carry the evaluation mark and, if so, what to do about it; a taxonomy of
+ * eleven parse failures helps nobody.
+ */
+type LicenseState = 
+/** No licence was configured. The SDK works; PDFs carry the evaluation mark. */
+"unlicensed"
+/** A licence was configured but could not be read, or its signature is wrong. */
+ | "invalid"
+/** Signed by a key this build of the SDK does not trust. */
+ | "untrusted"
+/** For a different product, or a payload version this SDK is older than. */
+ | "unsupported"
+/** Valid, signed, and inside its term. */
+ | "active"
+/** Past `expiresAt` but inside the grace period: honoured, and warned about. */
+ | "grace"
+/** Past `expiresAt` and past the grace period. */
+ | "expired";
+/** The outcome of checking a licence. Everything the SDK needs to decide. */
+interface LicenseStatus {
+    state: LicenseState;
+    /** True when PDFs render clean. `active` and `grace` only. */
+    licensed: boolean;
+    /** The payload, when one could be read and verified. */
+    payload: LicensePayload | null;
+    /** What the licence permits, when it is being honoured. */
+    entitlement: Entitlement | null;
+    /** Expiry as a Date, when known. */
+    expiresAt: Date | null;
+    /** Days until expiry; negative once expired. Null when there is no licence. */
+    daysRemaining: number | null;
+    /**
+     * A developer-facing sentence. Always present for a state that is not
+     * `active`, so callers can log it without composing their own prose.
+     */
+    message: string | null;
+}
+/** A public key this build of the SDK will accept signatures from. */
+interface TrustedKey {
+    /** Matches `keyId` in the payload. */
+    keyId: string;
+    /** The raw 32-byte Ed25519 public key, base64url or base64. */
+    publicKey: string;
+    /** Free text for the key's provenance. Never displayed to end users. */
+    note?: string;
+}
+
+/**
+ * How long an expired licence keeps working.
+ *
+ * A renewal that is a week late is an accounts payable problem, not a reason to
+ * stamp a customer's month-end reports. Thirty days is long enough to cover a
+ * card expiring over a holiday and short enough that it is not a second licence
+ * term.
+ */
+declare const DEFAULT_GRACE_PERIOD_DAYS = 30;
+interface VerifyOptions {
+    /** Fixed clock. Tests and deterministic renders pass one. */
+    now?: Date;
+    /** Extra keys to trust, on top of the ones built into this SDK. */
+    trustedKeys?: readonly TrustedKey[];
+    /** Overrides {@link DEFAULT_GRACE_PERIOD_DAYS}. */
+    gracePeriodDays?: number;
+}
+/** The status of a caller that supplied no licence at all. */
+declare function unlicensed(): LicenseStatus;
+/**
+ * Checks a licence string and reports what it entitles the caller to.
+ *
+ * Never throws for a bad licence: a malformed string, a forged signature and an
+ * expired term are all ordinary answers, and a render is not the place to
+ * discover that a config file has a typo in it.
+ */
+declare function verifyLicense(license: string | null | undefined, options?: VerifyOptions): Promise<LicenseStatus>;
+
+/**
+ * Configuring BroadPaper once, for the life of the process.
+ *
+ *     import { BroadPaper } from "@broadpaper/forme";
+ *     BroadPaper.configure({ license: process.env.BROADPAPER_LICENSE });
+ *
+ * The licence is not a credential, so this is not a secrets API: it is the same
+ * shape of thing as setting a locale. A browser bundle that carries the licence
+ * string in plain text is fine — the string is a signed certificate, and
+ * possessing it grants nothing beyond what its payload already says.
+ *
+ * Configuration is deliberately process-global rather than an argument to every
+ * render. Threading a licence through `renderPdf`, the render service, the
+ * batch endpoint, the .NET client and every future export path is exactly the
+ * kind of plumbing that ends with one path quietly forgetting it, and a
+ * customer who has paid discovering a watermark in production.
+ *
+ * The store hangs off a `Symbol.for` key rather than a module-level variable so
+ * that two copies of this package in one dependency tree — the usual result of
+ * a mixed-version install — still agree about the licence.
+ */
+
+interface BroadPaperConfig {
+    /**
+     * The licence string, `BP1.…`. Read from `BROADPAPER_LICENSE` when this is
+     * not set and the runtime has environment variables.
+     */
+    license?: string | null;
+    /**
+     * Public keys to trust in addition to the ones built into the SDK. This is
+     * how a development licence is honoured on a developer's machine without a
+     * development key ever being trusted by a production build.
+     */
+    trustedKeys?: readonly TrustedKey[];
+    /** Overrides the 30-day post-expiry grace period. Mostly for tests. */
+    gracePeriodDays?: number;
+    /** Where licence warnings go. Defaults to `console.warn`. */
+    logger?: ((message: string) => void) | null;
+}
+/**
+ * Sets the licence and any other SDK-wide options. Call it once, at startup.
+ *
+ * Successive calls merge, so a host can set the licence in one place and the
+ * grace period in another; passing `license: null` clears it.
+ */
+declare function configure(config: BroadPaperConfig): void;
+/** What {@link configure} has been given, plus whatever the environment supplies. */
+declare function getConfig(): BroadPaperConfig;
+/** Forgets the configuration entirely. Exists for tests. */
+declare function resetConfig(): void;
+/**
+ * `BroadPaper.configure({ … })`, for hosts that prefer a namespace to a bare
+ * function. Both are the same store.
+ */
+declare const BroadPaper: {
+    configure: typeof configure;
+    getConfig: typeof getConfig;
+};
+/** Logs a message once, whatever it takes to reach the developer. */
+declare function warn(message: string): void;
+interface ResolveOptions extends VerifyOptions {
+    /** A licence for this call only, overriding the configured one. */
+    license?: string | null;
+}
+/**
+ * The licence status for the current configuration.
+ *
+ * Memoised on the licence string, because every PDF asks and a signature check
+ * per page of a five-hundred-page batch is waste. `configure` clears it, and a
+ * per-call `license` bypasses it.
+ *
+ * Whatever the answer, any developer-facing message is logged once. That is the
+ * only thing the SDK does that a caller did not ask for, and it is the
+ * difference between a developer seeing "your licence expired" and a developer
+ * seeing an unexplained watermark.
+ */
+declare function resolveLicenseStatus(options?: ResolveOptions): Promise<LicenseStatus>;
+
+/** The only string format this SDK can read. */
+declare const FORMAT_PREFIX = "BP1";
+/** A licence string split into its parts, before any signature check. */
+interface ParsedLicense {
+    prefix: string;
+    /** The exact text that was signed. */
+    signedText: string;
+    encodedPayload: string;
+    signature: Uint8Array;
+    payload: LicensePayload;
+}
+declare class LicenseFormatError extends Error {
+    /** `unsupported` when the licence is well-formed but newer than this SDK. */
+    readonly kind: "invalid" | "unsupported";
+    constructor(message: string, 
+    /** `unsupported` when the licence is well-formed but newer than this SDK. */
+    kind?: "invalid" | "unsupported");
+}
+/** Whitespace is stripped: licences get pasted, wrapped and indented. */
+declare function normalizeLicense(license: string): string;
+/**
+ * Reads a licence string without verifying it.
+ *
+ * Nothing here decides whether a licence is *honoured* — that needs the
+ * signature — but a structurally broken string can be rejected before any
+ * cryptography happens, and the account UI can display a licence's contents
+ * without holding a public key.
+ */
+declare function parseLicense(license: string): ParsedLicense;
+/**
+ * Encodes a payload into the text that gets signed.
+ *
+ * Exported because BroadPaper's own licence issuer must produce byte-identical
+ * input to what the SDK verifies, and the only way to guarantee that is for
+ * both to call this function.
+ */
+declare function encodeSigningInput(payload: LicensePayload): {
+    signedText: string;
+    encodedPayload: string;
+};
+/** Assembles the final licence string from a payload and its signature. */
+declare function formatLicense(payload: LicensePayload, signature: Uint8Array): string;
+
+/**
+ * The evaluation mark.
+ *
+ * This is the only thing an unlicensed BroadPaper does differently. Every
+ * block, both PDF backends, the designer, data binding, pagination and the
+ * render service behave identically with and without a licence; what changes is
+ * that the file says, on every page, that it was produced with an evaluation
+ * copy.
+ *
+ * It is drawn to be unmistakable in a document review and harmless to a
+ * developer evaluating the product: a light diagonal line across the page,
+ * behind nothing and over everything, at an opacity that leaves the report
+ * entirely readable. Making the output illegible would only push people towards
+ * evaluating something else.
+ *
+ * Each backend draws the spec with its own primitives — the Forme engine has a
+ * page-native watermark node, Chromium gets a printed overlay — because a
+ * single drawing implementation would mean one of them post-processing a file
+ * the other had already finished, and a stamping pass that can be skipped is a
+ * stamping pass that eventually is.
+ */
+
+interface WatermarkSpec {
+    text: string;
+    /** Points. The engines size the mark from this, not from the page. */
+    fontSize: number;
+    /** Degrees, anticlockwise from horizontal. */
+    angle: number;
+    /** Hex, without alpha. */
+    color: string;
+    /** 0–1. */
+    opacity: number;
+}
+/**
+ * The mark itself.
+ *
+ * No dashes or typographic punctuation: the standard PDF faces carry no em
+ * dash, and a theme that names a font the engine does not have falls back to
+ * them, which turned "BroadPaper — Evaluation Copy" into "BroadPaper
+ * Evaluation Copy" in half the documents and a question mark in the rest.
+ */
+declare const EVALUATION_WATERMARK: WatermarkSpec;
+/**
+ * The mark a render should carry, or null when the licence says none.
+ *
+ * Backends call this rather than reading the licence status themselves, so
+ * "licensed" and "no watermark" cannot drift apart.
+ */
+declare function resolveWatermark(options?: ResolveOptions): Promise<WatermarkSpec | null>;
+/** The pure half of {@link resolveWatermark}, for callers that already have a status. */
+declare function watermarkFor(status: LicenseStatus): WatermarkSpec | null;
+/**
+ * CSS that paints the mark on every `.bp-page` of a rendered document.
+ *
+ * Used by the Chromium backend and by the designer's print path — the two
+ * places a PDF is produced by a browser rather than by the engine. `position:
+ * fixed` would put it on the viewport rather than on each page, so it is an
+ * absolutely positioned pseudo-element on the page box, which prints once per
+ * sheet.
+ *
+ * `print-color-adjust` matters: without it Chromium drops the mark from the
+ * printed file exactly as it drops any other background colour.
+ */
+declare function watermarkCss(spec?: WatermarkSpec): string;
+/**
+ * The PDF Producer string for a render.
+ *
+ * Licensed output records the licence id. It is not a secret — it identifies a
+ * customer's licence, not their account — and having it in the file means a
+ * document that turns up somewhere it should not can be traced back to the
+ * licence that produced it without any of the tracking a phone-home would need.
+ */
+declare function producerString(status: LicenseStatus): string;
+
+/**
+ * The public keys this build of the SDK will accept licence signatures from.
+ *
+ * **This file contains public keys only.** BroadPaper's private signing key
+ * lives in the licence issuer's secret store and is never in this repository,
+ * never in the npm package and never in a browser bundle. Publishing the
+ * public half is the point: it is what lets a licence be checked with no
+ * network call.
+ *
+ * Add a production key with:
+ *
+ *     node scripts/licence-keys.mjs --production --key-id bp-1
+ *
+ * which prints the private key once, for the operator to paste into the
+ * issuer's configuration, and writes the public half into this array.
+ *
+ * The list is an allowlist, so it is also the rotation mechanism: issue with a
+ * new `keyId`, ship an SDK release trusting both, and drop the old entry once
+ * every licence signed with it has expired. Licences carry their `keyId` inside
+ * the signed payload, so an attacker cannot point one at a different key.
+ *
+ * It starts empty on purpose. A key here is trusted by every copy of the SDK in
+ * the world, including production installs, which is exactly why a development
+ * key must never be added to it — development keys are supplied at runtime
+ * instead, through `configure({ trustedKeys })` or `BROADPAPER_TRUSTED_KEYS`,
+ * so a licence signed in development cannot be honoured by a production build.
+ */
+
+declare const TRUSTED_KEYS: readonly TrustedKey[];
+
+/**
+ * base64url and UTF-8, without depending on Node or on the DOM.
+ *
+ * The SDK runs in Node, in edge runtimes, in a worker and in a browser, and the
+ * licence string has to decode identically in all four. `atob`/`btoa` exist
+ * everywhere modern but are byte-oriented and mangle anything above U+00FF, so
+ * text goes through `TextEncoder`/`TextDecoder` first and only bytes are
+ * base64'd. The tables below are the whole implementation, which is smaller
+ * than the runtime detection needed to use `Buffer` where it happens to exist.
+ */
+declare function bytesToBase64Url(bytes: Uint8Array): string;
+/** Throws on anything that is not base64/base64url. Padding is optional. */
+declare function base64UrlToBytes(text: string): Uint8Array;
+
+export { BroadPaper, type BroadPaperConfig, DEFAULT_GRACE_PERIOD_DAYS, EVALUATION_WATERMARK, type Entitlement, FORMAT_PREFIX, LicenseFormatError, type LicensePayload, type LicenseState, type LicenseStatus, PRODUCT, type ParsedLicense, type ResolveOptions, TRUSTED_KEYS, type TrustedKey, type VerifyOptions, type WatermarkSpec, base64UrlToBytes, bytesToBase64Url, configure, encodeSigningInput, formatLicense, getConfig, normalizeLicense, parseLicense, producerString, resetConfig, resolveLicenseStatus, resolveWatermark, unlicensed, verifyLicense, warn, watermarkCss, watermarkFor };

package/dist/index.js

@@ -0,0 +1,412 @@
+// src/verify.ts
+import { verifyAsync } from "@noble/ed25519";
+
+// src/encoding.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+var LOOKUP = /* @__PURE__ */ (() => {
+  const t = new Int8Array(128).fill(-1);
+  for (let i = 0; i < ALPHABET.length; i++) t[ALPHABET.charCodeAt(i)] = i;
+  t["+".charCodeAt(0)] = 62;
+  t["/".charCodeAt(0)] = 63;
+  return t;
+})();
+function bytesToBase64Url(bytes) {
+  let out = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out += ALPHABET[n >>> 18 & 63] + ALPHABET[n >>> 12 & 63] + ALPHABET[n >>> 6 & 63] + ALPHABET[n & 63];
+  }
+  const rest = bytes.length - i;
+  if (rest === 1) {
+    const n = bytes[i] << 16;
+    out += ALPHABET[n >>> 18 & 63] + ALPHABET[n >>> 12 & 63];
+  } else if (rest === 2) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8;
+    out += ALPHABET[n >>> 18 & 63] + ALPHABET[n >>> 12 & 63] + ALPHABET[n >>> 6 & 63];
+  }
+  return out;
+}
+function base64UrlToBytes(text) {
+  let end = text.length;
+  while (end > 0 && text[end - 1] === "=") end--;
+  const chars = [];
+  for (let i2 = 0; i2 < end; i2++) {
+    const code = text.charCodeAt(i2);
+    const value = code < 128 ? LOOKUP[code] : -1;
+    if (value < 0) throw new Error(`not base64: ${JSON.stringify(text[i2])} at ${i2}`);
+    chars.push(value);
+  }
+  if (chars.length % 4 === 1) throw new Error("not base64: truncated");
+  const out = new Uint8Array(Math.floor(chars.length * 3 / 4));
+  let o = 0;
+  let i = 0;
+  for (; i + 3 < chars.length; i += 4) {
+    const n = chars[i] << 18 | chars[i + 1] << 12 | chars[i + 2] << 6 | chars[i + 3];
+    out[o++] = n >>> 16 & 255;
+    out[o++] = n >>> 8 & 255;
+    out[o++] = n & 255;
+  }
+  const rest = chars.length - i;
+  if (rest === 2) {
+    out[o++] = (chars[i] << 18 | chars[i + 1] << 12) >>> 16;
+  } else if (rest === 3) {
+    const n = chars[i] << 18 | chars[i + 1] << 12 | chars[i + 2] << 6;
+    out[o++] = n >>> 16 & 255;
+    out[o++] = n >>> 8 & 255;
+  }
+  return out;
+}
+var encoder = /* @__PURE__ */ new TextEncoder();
+var decoder = /* @__PURE__ */ new TextDecoder("utf-8", { fatal: true });
+var utf8ToBytes = (text) => encoder.encode(text);
+var bytesToUtf8 = (bytes) => decoder.decode(bytes);
+
+// src/format.ts
+var FORMAT_PREFIX = "BP1";
+var LicenseFormatError = class extends Error {
+  constructor(message, kind = "invalid") {
+    super(message);
+    this.kind = kind;
+    this.name = "LicenseFormatError";
+  }
+  kind;
+};
+var ENTITLEMENTS = ["internal", "saas"];
+function normalizeLicense(license) {
+  return license.replace(/\s+/g, "");
+}
+function parseLicense(license) {
+  const text = normalizeLicense(license);
+  if (!text) throw new LicenseFormatError("the licence string is empty");
+  const parts = text.split(".");
+  if (parts.length !== 3) throw new LicenseFormatError(`expected three dot-separated parts, found ${parts.length}`);
+  const [prefix, encodedPayload, encodedSignature] = parts;
+  if (prefix !== FORMAT_PREFIX) {
+    const known = /^BP\d+$/.test(prefix);
+    throw new LicenseFormatError(
+      known ? `licence format ${prefix} is newer than this version of BroadPaper, which reads ${FORMAT_PREFIX}` : `unrecognised licence prefix ${JSON.stringify(prefix)}`,
+      known ? "unsupported" : "invalid"
+    );
+  }
+  if (!encodedPayload || !encodedSignature) throw new LicenseFormatError("the licence string has an empty part");
+  let json;
+  let signature;
+  try {
+    json = bytesToUtf8(base64UrlToBytes(encodedPayload));
+    signature = base64UrlToBytes(encodedSignature);
+  } catch (e) {
+    throw new LicenseFormatError(`the licence string is not valid base64 (${e.message})`);
+  }
+  if (signature.length !== 64) throw new LicenseFormatError(`an Ed25519 signature is 64 bytes, this one is ${signature.length}`);
+  let raw;
+  try {
+    raw = JSON.parse(json);
+  } catch {
+    throw new LicenseFormatError("the licence payload is not valid JSON");
+  }
+  return {
+    prefix,
+    signedText: `${prefix}.${encodedPayload}`,
+    encodedPayload,
+    signature,
+    payload: readPayload(raw)
+  };
+}
+function readPayload(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) throw new LicenseFormatError("the licence payload is not an object");
+  const o = raw;
+  const version = o.version;
+  if (version !== 1) {
+    const numeric = typeof version === "number" && Number.isInteger(version) && version > 1;
+    throw new LicenseFormatError(
+      numeric ? `licence payload version ${version} is newer than this version of BroadPaper, which reads version 1` : "the licence payload has no usable version",
+      numeric ? "unsupported" : "invalid"
+    );
+  }
+  const text = (key) => {
+    const value = o[key];
+    if (typeof value !== "string" || value === "") throw new LicenseFormatError(`the licence payload is missing ${key}`);
+    return value;
+  };
+  const seconds = (key) => {
+    const value = o[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) throw new LicenseFormatError(`the licence payload is missing ${key}`);
+    return value;
+  };
+  const entitlement = text("entitlement");
+  if (!ENTITLEMENTS.includes(entitlement)) {
+    throw new LicenseFormatError(`this version of BroadPaper does not know the entitlement ${JSON.stringify(entitlement)}`, "unsupported");
+  }
+  return {
+    ...o,
+    version: 1,
+    keyId: text("keyId"),
+    licenseId: text("licenseId"),
+    customerId: text("customerId"),
+    customerName: text("customerName"),
+    product: text("product"),
+    entitlement,
+    issuedAt: seconds("issuedAt"),
+    expiresAt: seconds("expiresAt")
+  };
+}
+function encodeSigningInput(payload) {
+  const encodedPayload = bytesToBase64Url(utf8ToBytes(JSON.stringify(payload)));
+  return { encodedPayload, signedText: `${FORMAT_PREFIX}.${encodedPayload}` };
+}
+function formatLicense(payload, signature) {
+  if (signature.length !== 64) throw new LicenseFormatError(`an Ed25519 signature is 64 bytes, this one is ${signature.length}`);
+  const { encodedPayload } = encodeSigningInput(payload);
+  return `${FORMAT_PREFIX}.${encodedPayload}.${bytesToBase64Url(signature)}`;
+}
+
+// src/trusted-keys.ts
+var TRUSTED_KEYS = [
+  { keyId: "bp-2026", publicKey: "woKmWyIazae7SpGhi4dwA7zNK1lWdboq88Rl5xscTs4", note: "production, generated 2026-09-08" }
+];
+
+// src/types.ts
+var PRODUCT = "broadpaper-sdk";
+
+// src/verify.ts
+var DEFAULT_GRACE_PERIOD_DAYS = 30;
+var DAY_MS = 864e5;
+function unlicensed() {
+  return {
+    state: "unlicensed",
+    licensed: false,
+    payload: null,
+    entitlement: null,
+    expiresAt: null,
+    daysRemaining: null,
+    message: "No BroadPaper licence is configured, so PDFs carry the evaluation watermark. Everything else works; see https://www.broadpaper.com/docs/guide/licensing."
+  };
+}
+function failure(state, message, payload = null) {
+  return {
+    state,
+    licensed: false,
+    payload,
+    entitlement: null,
+    expiresAt: payload ? new Date(payload.expiresAt * 1e3) : null,
+    daysRemaining: null,
+    message
+  };
+}
+async function verifyLicense(license, options = {}) {
+  if (!license || !license.trim()) return unlicensed();
+  let parsed;
+  try {
+    parsed = parseLicense(license);
+  } catch (e) {
+    if (e instanceof LicenseFormatError) {
+      return failure(
+        e.kind,
+        e.kind === "unsupported" ? `This BroadPaper licence needs a newer version of the SDK (${e.message}). Update @broadpaper/* or the PDF will carry the evaluation watermark.` : `The BroadPaper licence could not be read (${e.message}), so PDFs carry the evaluation watermark.`
+      );
+    }
+    throw e;
+  }
+  const { payload } = parsed;
+  if (payload.product !== PRODUCT) {
+    return failure(
+      "invalid",
+      `This licence is for ${JSON.stringify(payload.product)}, not the BroadPaper SDK, so PDFs carry the evaluation watermark.`,
+      payload
+    );
+  }
+  const key = findKey(payload.keyId, options.trustedKeys);
+  if (!key) {
+    return failure(
+      "untrusted",
+      `This BroadPaper licence was signed with key ${JSON.stringify(payload.keyId)}, which this build does not trust. A licence issued for development is not honoured by a production build; check BROADPAPER_LICENSE points at the right one.`,
+      payload
+    );
+  }
+  let signatureOk = false;
+  try {
+    signatureOk = await verifyAsync(parsed.signature, utf8ToBytes(parsed.signedText), base64UrlToBytes(key.publicKey));
+  } catch {
+    signatureOk = false;
+  }
+  if (!signatureOk) {
+    return failure("invalid", "This BroadPaper licence failed its signature check \u2014 it has been altered or truncated. PDFs carry the evaluation watermark.", payload);
+  }
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const expiresAt = new Date(payload.expiresAt * 1e3);
+  const graceDays = options.gracePeriodDays ?? DEFAULT_GRACE_PERIOD_DAYS;
+  const msRemaining = expiresAt.getTime() - now.getTime();
+  const daysRemaining = Math.floor(msRemaining / DAY_MS);
+  if (msRemaining > 0) {
+    return {
+      state: "active",
+      licensed: true,
+      payload,
+      entitlement: payload.entitlement,
+      expiresAt,
+      daysRemaining,
+      message: null
+    };
+  }
+  if (msRemaining > -graceDays * DAY_MS) {
+    const daysOver = Math.max(1, Math.ceil(-msRemaining / DAY_MS));
+    return {
+      state: "grace",
+      licensed: true,
+      payload,
+      entitlement: payload.entitlement,
+      expiresAt,
+      daysRemaining,
+      message: `The BroadPaper licence for ${payload.customerName} expired ${daysOver} day${daysOver === 1 ? "" : "s"} ago and is inside its ${graceDays}-day grace period. Renew it and copy the new licence from your account, or PDFs will start carrying the evaluation watermark.`
+    };
+  }
+  return failure(
+    "expired",
+    `The BroadPaper licence for ${payload.customerName} expired on ${expiresAt.toISOString().slice(0, 10)} and its ${graceDays}-day grace period has passed, so PDFs carry the evaluation watermark. Renewing issues a new licence in your BroadPaper account.`,
+    payload
+  );
+}
+function findKey(keyId, extra) {
+  return extra?.find((k) => k.keyId === keyId) ?? TRUSTED_KEYS.find((k) => k.keyId === keyId);
+}
+
+// src/config.ts
+var STORE_KEY = /* @__PURE__ */ Symbol.for("broadpaper.license.store");
+function store() {
+  const g = globalThis;
+  let s = g[STORE_KEY];
+  if (!s) {
+    s = { config: {}, cache: null, logged: /* @__PURE__ */ new Set() };
+    g[STORE_KEY] = s;
+  }
+  return s;
+}
+function configure(config) {
+  const s = store();
+  s.config = { ...s.config, ...config };
+  s.cache = null;
+  s.logged.clear();
+}
+function getConfig() {
+  return { ...store().config };
+}
+function resetConfig() {
+  const g = globalThis;
+  delete g[STORE_KEY];
+}
+var BroadPaper = { configure, getConfig };
+function env(name) {
+  const p = globalThis.process;
+  const value = p?.env?.[name];
+  return value && value.trim() ? value : void 0;
+}
+function trustedKeysFromEnv() {
+  const raw = env("BROADPAPER_TRUSTED_KEYS");
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) throw new Error("expected a JSON array");
+    return parsed.map((entry, i) => {
+      const k = entry;
+      if (typeof k?.keyId !== "string" || typeof k?.publicKey !== "string") throw new Error(`entry ${i} needs keyId and publicKey`);
+      return { keyId: k.keyId, publicKey: k.publicKey };
+    });
+  } catch (e) {
+    warn(`BROADPAPER_TRUSTED_KEYS could not be read (${e.message}); it is being ignored.`);
+    return [];
+  }
+}
+function warn(message) {
+  const s = store();
+  if (s.logged.has(message)) return;
+  s.logged.add(message);
+  const logger = s.config.logger;
+  if (logger === null) return;
+  const line = `[BroadPaper] ${message}`;
+  if (logger) logger(line);
+  else console.warn(line);
+}
+async function resolveLicenseStatus(options = {}) {
+  const s = store();
+  const config = s.config;
+  const license = options.license !== void 0 ? options.license : config.license ?? env("BROADPAPER_LICENSE") ?? null;
+  const trustedKeys = [...options.trustedKeys ?? [], ...config.trustedKeys ?? [], ...trustedKeysFromEnv()];
+  const gracePeriodDays = options.gracePeriodDays ?? config.gracePeriodDays;
+  if (!license) {
+    const status = unlicensed();
+    if (status.message) warn(status.message);
+    return status;
+  }
+  const verify = () => verifyLicense(license, { ...options.now ? { now: options.now } : {}, trustedKeys, ...gracePeriodDays !== void 0 ? { gracePeriodDays } : {} }).then((status) => {
+    if (status.message) warn(status.message);
+    return status;
+  });
+  if (options.now || options.license !== void 0) return verify();
+  const key = `${license}|${trustedKeys.map((k) => k.keyId).join(",")}|${gracePeriodDays ?? ""}`;
+  if (s.cache?.key !== key) s.cache = { key, status: verify() };
+  return s.cache.status;
+}
+
+// src/watermark.ts
+var EVALUATION_WATERMARK = {
+  text: "BroadPaper Evaluation Copy",
+  fontSize: 44,
+  angle: -35,
+  color: "#c8102e",
+  opacity: 0.12
+};
+async function resolveWatermark(options = {}) {
+  const status = await resolveLicenseStatus(options);
+  return watermarkFor(status);
+}
+function watermarkFor(status) {
+  return status.licensed ? null : EVALUATION_WATERMARK;
+}
+function watermarkCss(spec = EVALUATION_WATERMARK) {
+  const text = spec.text.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return [
+    ".bp-page{position:relative;}",
+    ".bp-page::after{",
+    `content:"${text}";`,
+    "position:absolute;inset:0;",
+    "display:flex;align-items:center;justify-content:center;",
+    "pointer-events:none;z-index:2147483647;",
+    `transform:rotate(${spec.angle}deg);`,
+    "font-family:Helvetica,Arial,sans-serif;font-weight:700;letter-spacing:0.04em;white-space:nowrap;",
+    `font-size:${spec.fontSize}pt;color:${spec.color};opacity:${spec.opacity};`,
+    "-webkit-print-color-adjust:exact;print-color-adjust:exact;",
+    "}"
+  ].join("");
+}
+function producerString(status) {
+  if (!status.licensed || !status.payload) return "BroadPaper (evaluation)";
+  return `BroadPaper (${status.payload.licenseId})`;
+}
+export {
+  BroadPaper,
+  DEFAULT_GRACE_PERIOD_DAYS,
+  EVALUATION_WATERMARK,
+  FORMAT_PREFIX,
+  LicenseFormatError,
+  PRODUCT,
+  TRUSTED_KEYS,
+  base64UrlToBytes,
+  bytesToBase64Url,
+  configure,
+  encodeSigningInput,
+  formatLicense,
+  getConfig,
+  normalizeLicense,
+  parseLicense,
+  producerString,
+  resetConfig,
+  resolveLicenseStatus,
+  resolveWatermark,
+  unlicensed,
+  verifyLicense,
+  warn,
+  watermarkCss,
+  watermarkFor
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/verify.ts","../src/encoding.ts","../src/format.ts","../src/trusted-keys.ts","../src/types.ts","../src/config.ts","../src/watermark.ts"],"sourcesContent":["/**\n * Offline licence verification.\n *\n * Everything here is local: a signature check against a compiled-in public key\n * and a comparison against the clock. There is no activation call, no licence\n * server and nothing to be offline from. That is a deliberate product decision\n * as much as a technical one — a report renderer that stops working because a\n * key server is down is a report renderer nobody puts in a payroll run.\n *\n * The failure modes are all *soft*. An unreadable licence never throws out of a\n * render; it produces a status whose `message` says what is wrong, and the PDF\n * comes out carrying the evaluation mark.\n */\nimport { verifyAsync } from \"@noble/ed25519\";\nimport { base64UrlToBytes, utf8ToBytes } from \"./encoding.js\";\nimport { LicenseFormatError, parseLicense } from \"./format.js\";\nimport { TRUSTED_KEYS } from \"./trusted-keys.js\";\nimport { PRODUCT, type LicensePayload, type LicenseStatus, type TrustedKey } from \"./types.js\";\n\n/**\n * How long an expired licence keeps working.\n *\n * A renewal that is a week late is an accounts payable problem, not a reason to\n * stamp a customer's month-end reports. Thirty days is long enough to cover a\n * card expiring over a holiday and short enough that it is not a second licence\n * term.\n */\nexport const DEFAULT_GRACE_PERIOD_DAYS = 30;\n\nconst DAY_MS = 86_400_000;\n\nexport interface VerifyOptions {\n  /** Fixed clock. Tests and deterministic renders pass one. */\n  now?: Date;\n  /** Extra keys to trust, on top of the ones built into this SDK. */\n  trustedKeys?: readonly TrustedKey[];\n  /** Overrides {@link DEFAULT_GRACE_PERIOD_DAYS}. */\n  gracePeriodDays?: number;\n}\n\n/** The status of a caller that supplied no licence at all. */\nexport function unlicensed(): LicenseStatus {\n  return {\n    state: \"unlicensed\",\n    licensed: false,\n    payload: null,\n    entitlement: null,\n    expiresAt: null,\n    daysRemaining: null,\n    message:\n      \"No BroadPaper licence is configured, so PDFs carry the evaluation watermark. Everything else works; see https://www.broadpaper.com/docs/guide/licensing.\"\n  };\n}\n\nfunction failure(state: LicenseStatus[\"state\"], message: string, payload: LicensePayload | null = null): LicenseStatus {\n  return {\n    state,\n    licensed: false,\n    payload,\n    entitlement: null,\n    expiresAt: payload ? new Date(payload.expiresAt * 1000) : null,\n    daysRemaining: null,\n    message\n  };\n}\n\n/**\n * Checks a licence string and reports what it entitles the caller to.\n *\n * Never throws for a bad licence: a malformed string, a forged signature and an\n * expired term are all ordinary answers, and a render is not the place to\n * discover that a config file has a typo in it.\n */\nexport async function verifyLicense(license: string | null | undefined, options: VerifyOptions = {}): Promise<LicenseStatus> {\n  if (!license || !license.trim()) return unlicensed();\n\n  let parsed;\n  try {\n    parsed = parseLicense(license);\n  } catch (e) {\n    if (e instanceof LicenseFormatError) {\n      return failure(\n        e.kind,\n        e.kind === \"unsupported\"\n          ? `This BroadPaper licence needs a newer version of the SDK (${e.message}). Update @broadpaper/* or the PDF will carry the evaluation watermark.`\n          : `The BroadPaper licence could not be read (${e.message}), so PDFs carry the evaluation watermark.`\n      );\n    }\n    /* c8 ignore next -- parseLicense only throws LicenseFormatError */\n    throw e;\n  }\n\n  const { payload } = parsed;\n  if (payload.product !== PRODUCT) {\n    return failure(\n      \"invalid\",\n      `This licence is for ${JSON.stringify(payload.product)}, not the BroadPaper SDK, so PDFs carry the evaluation watermark.`,\n      payload\n    );\n  }\n\n  const key = findKey(payload.keyId, options.trustedKeys);\n  if (!key) {\n    return failure(\n      \"untrusted\",\n      `This BroadPaper licence was signed with key ${JSON.stringify(payload.keyId)}, which this build does not trust. ` +\n        \"A licence issued for development is not honoured by a production build; check BROADPAPER_LICENSE points at the right one.\",\n      payload\n    );\n  }\n\n  let signatureOk = false;\n  try {\n    signatureOk = await verifyAsync(parsed.signature, utf8ToBytes(parsed.signedText), base64UrlToBytes(key.publicKey));\n  } catch {\n    // A malformed public key or a point that is not on the curve. Either way\n    // this licence is not going to verify, and a render must not fail over it.\n    signatureOk = false;\n  }\n  if (!signatureOk) {\n    return failure(\"invalid\", \"This BroadPaper licence failed its signature check — it has been altered or truncated. PDFs carry the evaluation watermark.\", payload);\n  }\n\n  const now = options.now ?? new Date();\n  const expiresAt = new Date(payload.expiresAt * 1000);\n  const graceDays = options.gracePeriodDays ?? DEFAULT_GRACE_PERIOD_DAYS;\n  const msRemaining = expiresAt.getTime() - now.getTime();\n  const daysRemaining = Math.floor(msRemaining / DAY_MS);\n\n  if (msRemaining > 0) {\n    return {\n      state: \"active\",\n      licensed: true,\n      payload,\n      entitlement: payload.entitlement,\n      expiresAt,\n      daysRemaining,\n      message: null\n    };\n  }\n\n  if (msRemaining > -graceDays * DAY_MS) {\n    const daysOver = Math.max(1, Math.ceil(-msRemaining / DAY_MS));\n    return {\n      state: \"grace\",\n      licensed: true,\n      payload,\n      entitlement: payload.entitlement,\n      expiresAt,\n      daysRemaining,\n      message:\n        `The BroadPaper licence for ${payload.customerName} expired ${daysOver} day${daysOver === 1 ? \"\" : \"s\"} ago and is inside its ${graceDays}-day grace period. ` +\n        \"Renew it and copy the new licence from your account, or PDFs will start carrying the evaluation watermark.\"\n    };\n  }\n\n  return failure(\n    \"expired\",\n    `The BroadPaper licence for ${payload.customerName} expired on ${expiresAt.toISOString().slice(0, 10)} and its ${graceDays}-day grace period has passed, ` +\n      \"so PDFs carry the evaluation watermark. Renewing issues a new licence in your BroadPaper account.\",\n    payload\n  );\n}\n\nfunction findKey(keyId: string, extra: readonly TrustedKey[] | undefined): TrustedKey | undefined {\n  // Runtime keys are searched first so a development key can shadow a built-in\n  // one of the same name without a rebuild.\n  return extra?.find((k) => k.keyId === keyId) ?? TRUSTED_KEYS.find((k) => k.keyId === keyId);\n}\n","/**\n * base64url and UTF-8, without depending on Node or on the DOM.\n *\n * The SDK runs in Node, in edge runtimes, in a worker and in a browser, and the\n * licence string has to decode identically in all four. `atob`/`btoa` exist\n * everywhere modern but are byte-oriented and mangle anything above U+00FF, so\n * text goes through `TextEncoder`/`TextDecoder` first and only bytes are\n * base64'd. The tables below are the whole implementation, which is smaller\n * than the runtime detection needed to use `Buffer` where it happens to exist.\n */\n\nconst ALPHABET = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_\";\nconst LOOKUP = /* @__PURE__ */ (() => {\n  const t = new Int8Array(128).fill(-1);\n  for (let i = 0; i < ALPHABET.length; i++) t[ALPHABET.charCodeAt(i)] = i;\n  // Accept standard base64 as well, so a licence that survived a round trip\n  // through a system that rewrote the alphabet still reads.\n  t[\"+\".charCodeAt(0)] = 62;\n  t[\"/\".charCodeAt(0)] = 63;\n  return t;\n})();\n\nexport function bytesToBase64Url(bytes: Uint8Array): string {\n  let out = \"\";\n  let i = 0;\n  for (; i + 2 < bytes.length; i += 3) {\n    const n = (bytes[i]! << 16) | (bytes[i + 1]! << 8) | bytes[i + 2]!;\n    out += ALPHABET[(n >>> 18) & 63]! + ALPHABET[(n >>> 12) & 63]! + ALPHABET[(n >>> 6) & 63]! + ALPHABET[n & 63]!;\n  }\n  const rest = bytes.length - i;\n  if (rest === 1) {\n    const n = bytes[i]! << 16;\n    out += ALPHABET[(n >>> 18) & 63]! + ALPHABET[(n >>> 12) & 63]!;\n  } else if (rest === 2) {\n    const n = (bytes[i]! << 16) | (bytes[i + 1]! << 8);\n    out += ALPHABET[(n >>> 18) & 63]! + ALPHABET[(n >>> 12) & 63]! + ALPHABET[(n >>> 6) & 63]!;\n  }\n  return out;\n}\n\n/** Throws on anything that is not base64/base64url. Padding is optional. */\nexport function base64UrlToBytes(text: string): Uint8Array {\n  let end = text.length;\n  while (end > 0 && text[end - 1] === \"=\") end--;\n  const chars: number[] = [];\n  for (let i = 0; i < end; i++) {\n    const code = text.charCodeAt(i);\n    const value = code < 128 ? LOOKUP[code]! : -1;\n    if (value < 0) throw new Error(`not base64: ${JSON.stringify(text[i])} at ${i}`);\n    chars.push(value);\n  }\n  // 4 base64 characters carry 3 bytes; a group of 1 is never valid.\n  if (chars.length % 4 === 1) throw new Error(\"not base64: truncated\");\n  const out = new Uint8Array(Math.floor((chars.length * 3) / 4));\n  let o = 0;\n  let i = 0;\n  for (; i + 3 < chars.length; i += 4) {\n    const n = (chars[i]! << 18) | (chars[i + 1]! << 12) | (chars[i + 2]! << 6) | chars[i + 3]!;\n    out[o++] = (n >>> 16) & 255;\n    out[o++] = (n >>> 8) & 255;\n    out[o++] = n & 255;\n  }\n  const rest = chars.length - i;\n  if (rest === 2) {\n    out[o++] = ((chars[i]! << 18) | (chars[i + 1]! << 12)) >>> 16;\n  } else if (rest === 3) {\n    const n = (chars[i]! << 18) | (chars[i + 1]! << 12) | (chars[i + 2]! << 6);\n    out[o++] = (n >>> 16) & 255;\n    out[o++] = (n >>> 8) & 255;\n  }\n  return out;\n}\n\nconst encoder = /* @__PURE__ */ new TextEncoder();\nconst decoder = /* @__PURE__ */ new TextDecoder(\"utf-8\", { fatal: true });\n\nexport const utf8ToBytes = (text: string): Uint8Array => encoder.encode(text);\nexport const bytesToUtf8 = (bytes: Uint8Array): string => decoder.decode(bytes);\n","/**\n * The licence string.\n *\n *     BP1.<base64url payload>.<base64url signature>\n *\n * Three parts, dot-separated, safe in an environment variable, a YAML file, a\n * URL and a shell argument without quoting. The leading `BP1` is the *string\n * format* version and `payload.version` is the *payload schema* version; they\n * move independently, and both are checked, so a licence issued for a later\n * format is reported as unsupported rather than as corrupt.\n *\n * What is signed is the bytes of `BP1.<payload>` — prefix included. Signing the\n * encoded text rather than the decoded object means verification never depends\n * on two JSON serialisers agreeing about key order or number formatting, and\n * covering the prefix stops a payload being lifted into a future format that\n * might read a field differently.\n */\nimport { base64UrlToBytes, bytesToBase64Url, bytesToUtf8, utf8ToBytes } from \"./encoding.js\";\nimport { PRODUCT, type Entitlement, type LicensePayload } from \"./types.js\";\n\n/** The only string format this SDK can read. */\nexport const FORMAT_PREFIX = \"BP1\";\n\n/** A licence string split into its parts, before any signature check. */\nexport interface ParsedLicense {\n  prefix: string;\n  /** The exact text that was signed. */\n  signedText: string;\n  encodedPayload: string;\n  signature: Uint8Array;\n  payload: LicensePayload;\n}\n\nexport class LicenseFormatError extends Error {\n  constructor(\n    message: string,\n    /** `unsupported` when the licence is well-formed but newer than this SDK. */\n    readonly kind: \"invalid\" | \"unsupported\" = \"invalid\"\n  ) {\n    super(message);\n    this.name = \"LicenseFormatError\";\n  }\n}\n\nconst ENTITLEMENTS: readonly Entitlement[] = [\"internal\", \"saas\"];\n\n/** Whitespace is stripped: licences get pasted, wrapped and indented. */\nexport function normalizeLicense(license: string): string {\n  return license.replace(/\\s+/g, \"\");\n}\n\n/**\n * Reads a licence string without verifying it.\n *\n * Nothing here decides whether a licence is *honoured* — that needs the\n * signature — but a structurally broken string can be rejected before any\n * cryptography happens, and the account UI can display a licence's contents\n * without holding a public key.\n */\nexport function parseLicense(license: string): ParsedLicense {\n  const text = normalizeLicense(license);\n  if (!text) throw new LicenseFormatError(\"the licence string is empty\");\n\n  const parts = text.split(\".\");\n  if (parts.length !== 3) throw new LicenseFormatError(`expected three dot-separated parts, found ${parts.length}`);\n  const [prefix, encodedPayload, encodedSignature] = parts as [string, string, string];\n\n  if (prefix !== FORMAT_PREFIX) {\n    // A licence issued in a format this SDK predates is a version problem, not\n    // a corrupt string, and the fix is to upgrade rather than to re-copy it.\n    const known = /^BP\\d+$/.test(prefix);\n    throw new LicenseFormatError(\n      known\n        ? `licence format ${prefix} is newer than this version of BroadPaper, which reads ${FORMAT_PREFIX}`\n        : `unrecognised licence prefix ${JSON.stringify(prefix)}`,\n      known ? \"unsupported\" : \"invalid\"\n    );\n  }\n  if (!encodedPayload || !encodedSignature) throw new LicenseFormatError(\"the licence string has an empty part\");\n\n  let json: string;\n  let signature: Uint8Array;\n  try {\n    json = bytesToUtf8(base64UrlToBytes(encodedPayload));\n    signature = base64UrlToBytes(encodedSignature);\n  } catch (e) {\n    throw new LicenseFormatError(`the licence string is not valid base64 (${(e as Error).message})`);\n  }\n  if (signature.length !== 64) throw new LicenseFormatError(`an Ed25519 signature is 64 bytes, this one is ${signature.length}`);\n\n  let raw: unknown;\n  try {\n    raw = JSON.parse(json);\n  } catch {\n    throw new LicenseFormatError(\"the licence payload is not valid JSON\");\n  }\n\n  return {\n    prefix,\n    signedText: `${prefix}.${encodedPayload}`,\n    encodedPayload,\n    signature,\n    payload: readPayload(raw)\n  };\n}\n\n/**\n * Validates the payload's shape.\n *\n * Unknown properties are kept, not rejected: they are inside the signature, so\n * a licence issued by a later BroadPaper carrying a field this SDK has never\n * heard of is still a licence this SDK can honour.\n */\nfunction readPayload(raw: unknown): LicensePayload {\n  if (typeof raw !== \"object\" || raw === null || Array.isArray(raw)) throw new LicenseFormatError(\"the licence payload is not an object\");\n  const o = raw as Record<string, unknown>;\n\n  const version = o.version;\n  if (version !== 1) {\n    const numeric = typeof version === \"number\" && Number.isInteger(version) && version > 1;\n    throw new LicenseFormatError(\n      numeric ? `licence payload version ${version} is newer than this version of BroadPaper, which reads version 1` : \"the licence payload has no usable version\",\n      numeric ? \"unsupported\" : \"invalid\"\n    );\n  }\n\n  const text = (key: string): string => {\n    const value = o[key];\n    if (typeof value !== \"string\" || value === \"\") throw new LicenseFormatError(`the licence payload is missing ${key}`);\n    return value;\n  };\n  const seconds = (key: string): number => {\n    const value = o[key];\n    if (typeof value !== \"number\" || !Number.isFinite(value)) throw new LicenseFormatError(`the licence payload is missing ${key}`);\n    return value;\n  };\n\n  const entitlement = text(\"entitlement\");\n  if (!ENTITLEMENTS.includes(entitlement as Entitlement)) {\n    // An entitlement this SDK does not know is a newer commercial model, and\n    // refusing to honour a licence we cannot classify would punish the customer\n    // for buying something new. It is reported as unsupported so the developer\n    // is told to upgrade.\n    throw new LicenseFormatError(`this version of BroadPaper does not know the entitlement ${JSON.stringify(entitlement)}`, \"unsupported\");\n  }\n\n  return {\n    ...o,\n    version: 1,\n    keyId: text(\"keyId\"),\n    licenseId: text(\"licenseId\"),\n    customerId: text(\"customerId\"),\n    customerName: text(\"customerName\"),\n    product: text(\"product\") as typeof PRODUCT,\n    entitlement: entitlement as Entitlement,\n    issuedAt: seconds(\"issuedAt\"),\n    expiresAt: seconds(\"expiresAt\")\n  };\n}\n\n/**\n * Encodes a payload into the text that gets signed.\n *\n * Exported because BroadPaper's own licence issuer must produce byte-identical\n * input to what the SDK verifies, and the only way to guarantee that is for\n * both to call this function.\n */\nexport function encodeSigningInput(payload: LicensePayload): { signedText: string; encodedPayload: string } {\n  const encodedPayload = bytesToBase64Url(utf8ToBytes(JSON.stringify(payload)));\n  return { encodedPayload, signedText: `${FORMAT_PREFIX}.${encodedPayload}` };\n}\n\n/** Assembles the final licence string from a payload and its signature. */\nexport function formatLicense(payload: LicensePayload, signature: Uint8Array): string {\n  if (signature.length !== 64) throw new LicenseFormatError(`an Ed25519 signature is 64 bytes, this one is ${signature.length}`);\n  const { encodedPayload } = encodeSigningInput(payload);\n  return `${FORMAT_PREFIX}.${encodedPayload}.${bytesToBase64Url(signature)}`;\n}\n","/**\n * The public keys this build of the SDK will accept licence signatures from.\n *\n * **This file contains public keys only.** BroadPaper's private signing key\n * lives in the licence issuer's secret store and is never in this repository,\n * never in the npm package and never in a browser bundle. Publishing the\n * public half is the point: it is what lets a licence be checked with no\n * network call.\n *\n * Add a production key with:\n *\n *     node scripts/licence-keys.mjs --production --key-id bp-1\n *\n * which prints the private key once, for the operator to paste into the\n * issuer's configuration, and writes the public half into this array.\n *\n * The list is an allowlist, so it is also the rotation mechanism: issue with a\n * new `keyId`, ship an SDK release trusting both, and drop the old entry once\n * every licence signed with it has expired. Licences carry their `keyId` inside\n * the signed payload, so an attacker cannot point one at a different key.\n *\n * It starts empty on purpose. A key here is trusted by every copy of the SDK in\n * the world, including production installs, which is exactly why a development\n * key must never be added to it — development keys are supplied at runtime\n * instead, through `configure({ trustedKeys })` or `BROADPAPER_TRUSTED_KEYS`,\n * so a licence signed in development cannot be honoured by a production build.\n */\nimport type { TrustedKey } from \"./types.js\";\n\nexport const TRUSTED_KEYS: readonly TrustedKey[] = [\n  { keyId: \"bp-2026\", publicKey: \"woKmWyIazae7SpGhi4dwA7zNK1lWdboq88Rl5xscTs4\", note: \"production, generated 2026-09-08\" }\n];\n","/**\n * The licence certificate and the states it can be in.\n *\n * A BroadPaper licence is a signed certificate, not a secret. It says who\n * bought what and until when, BroadPaper signs it, and the SDK checks that\n * signature with a public key compiled into the package. Nothing here talks to\n * a network, reads a machine identifier or writes a file: a licence that is\n * valid on a laptop with no route to the internet is valid, full stop.\n */\n\n/**\n * What the licence permits. Not a feature gate — both entitlements unlock\n * exactly the same software. The difference is who the resulting application\n * may be put in front of, which is a contractual matter and is presented as\n * one in the account area and the licence agreement.\n */\nexport type Entitlement = \"internal\" | \"saas\";\n\n/** The product a licence is for. Present so one signing key can serve more later. */\nexport const PRODUCT = \"broadpaper-sdk\";\n\n/**\n * The signed payload.\n *\n * `customerId` is the durable identifier of the buying organisation — a Clerk\n * organisation id — rather than an email address, because people change\n * addresses and organisations outlive their founders.\n *\n * Times are epoch **seconds**, not milliseconds: the payload is base64'd into\n * a string a developer will paste into a config file, and three characters per\n * timestamp is three characters.\n */\nexport interface LicensePayload {\n  /** Payload schema version. Bumped only when the meaning of a field changes. */\n  version: 1;\n  /** Which signing key signed this. Lets keys be rotated without reissuing everything. */\n  keyId: string;\n  /**\n   * BroadPaper's own identifier for *this certificate*, `lic_…`.\n   *\n   * One per issuance, so a renewal or an upgrade carries a new one and the\n   * document it produced can be dated from it. The customer is identified by\n   * `customerId`, which does not change.\n   */\n  licenseId: string;\n  /** The licensed organisation's durable id. */\n  customerId: string;\n  /** The organisation's name, for display in warnings and PDF metadata. */\n  customerName: string;\n  product: typeof PRODUCT;\n  entitlement: Entitlement;\n  /** Epoch seconds. */\n  issuedAt: number;\n  /** Epoch seconds. */\n  expiresAt: number;\n}\n\n/**\n * Why a licence is not being honoured, or how it is being honoured.\n *\n * These are deliberately coarse. A developer needs to know whether their PDFs\n * will carry the evaluation mark and, if so, what to do about it; a taxonomy of\n * eleven parse failures helps nobody.\n */\nexport type LicenseState =\n  /** No licence was configured. The SDK works; PDFs carry the evaluation mark. */\n  | \"unlicensed\"\n  /** A licence was configured but could not be read, or its signature is wrong. */\n  | \"invalid\"\n  /** Signed by a key this build of the SDK does not trust. */\n  | \"untrusted\"\n  /** For a different product, or a payload version this SDK is older than. */\n  | \"unsupported\"\n  /** Valid, signed, and inside its term. */\n  | \"active\"\n  /** Past `expiresAt` but inside the grace period: honoured, and warned about. */\n  | \"grace\"\n  /** Past `expiresAt` and past the grace period. */\n  | \"expired\";\n\n/** The outcome of checking a licence. Everything the SDK needs to decide. */\nexport interface LicenseStatus {\n  state: LicenseState;\n  /** True when PDFs render clean. `active` and `grace` only. */\n  licensed: boolean;\n  /** The payload, when one could be read and verified. */\n  payload: LicensePayload | null;\n  /** What the licence permits, when it is being honoured. */\n  entitlement: Entitlement | null;\n  /** Expiry as a Date, when known. */\n  expiresAt: Date | null;\n  /** Days until expiry; negative once expired. Null when there is no licence. */\n  daysRemaining: number | null;\n  /**\n   * A developer-facing sentence. Always present for a state that is not\n   * `active`, so callers can log it without composing their own prose.\n   */\n  message: string | null;\n}\n\n/** A public key this build of the SDK will accept signatures from. */\nexport interface TrustedKey {\n  /** Matches `keyId` in the payload. */\n  keyId: string;\n  /** The raw 32-byte Ed25519 public key, base64url or base64. */\n  publicKey: string;\n  /** Free text for the key's provenance. Never displayed to end users. */\n  note?: string;\n}\n","/**\n * Configuring BroadPaper once, for the life of the process.\n *\n *     import { BroadPaper } from \"@broadpaper/forme\";\n *     BroadPaper.configure({ license: process.env.BROADPAPER_LICENSE });\n *\n * The licence is not a credential, so this is not a secrets API: it is the same\n * shape of thing as setting a locale. A browser bundle that carries the licence\n * string in plain text is fine — the string is a signed certificate, and\n * possessing it grants nothing beyond what its payload already says.\n *\n * Configuration is deliberately process-global rather than an argument to every\n * render. Threading a licence through `renderPdf`, the render service, the\n * batch endpoint, the .NET client and every future export path is exactly the\n * kind of plumbing that ends with one path quietly forgetting it, and a\n * customer who has paid discovering a watermark in production.\n *\n * The store hangs off a `Symbol.for` key rather than a module-level variable so\n * that two copies of this package in one dependency tree — the usual result of\n * a mixed-version install — still agree about the licence.\n */\nimport { unlicensed, verifyLicense, type VerifyOptions } from \"./verify.js\";\nimport type { LicenseStatus, TrustedKey } from \"./types.js\";\n\nexport interface BroadPaperConfig {\n  /**\n   * The licence string, `BP1.…`. Read from `BROADPAPER_LICENSE` when this is\n   * not set and the runtime has environment variables.\n   */\n  license?: string | null;\n  /**\n   * Public keys to trust in addition to the ones built into the SDK. This is\n   * how a development licence is honoured on a developer's machine without a\n   * development key ever being trusted by a production build.\n   */\n  trustedKeys?: readonly TrustedKey[];\n  /** Overrides the 30-day post-expiry grace period. Mostly for tests. */\n  gracePeriodDays?: number;\n  /** Where licence warnings go. Defaults to `console.warn`. */\n  logger?: ((message: string) => void) | null;\n}\n\ninterface Store {\n  config: BroadPaperConfig;\n  /** Memoised by the licence string that produced it. */\n  cache: { key: string; status: Promise<LicenseStatus> } | null;\n  /** Messages already logged, so a hundred renders do not print a hundred lines. */\n  logged: Set<string>;\n}\n\nconst STORE_KEY = Symbol.for(\"broadpaper.license.store\");\n\nfunction store(): Store {\n  const g = globalThis as Record<symbol, unknown>;\n  let s = g[STORE_KEY] as Store | undefined;\n  if (!s) {\n    s = { config: {}, cache: null, logged: new Set() };\n    g[STORE_KEY] = s;\n  }\n  return s;\n}\n\n/**\n * Sets the licence and any other SDK-wide options. Call it once, at startup.\n *\n * Successive calls merge, so a host can set the licence in one place and the\n * grace period in another; passing `license: null` clears it.\n */\nexport function configure(config: BroadPaperConfig): void {\n  const s = store();\n  s.config = { ...s.config, ...config };\n  s.cache = null;\n  s.logged.clear();\n}\n\n/** What {@link configure} has been given, plus whatever the environment supplies. */\nexport function getConfig(): BroadPaperConfig {\n  return { ...store().config };\n}\n\n/** Forgets the configuration entirely. Exists for tests. */\nexport function resetConfig(): void {\n  const g = globalThis as Record<symbol, unknown>;\n  delete g[STORE_KEY];\n}\n\n/**\n * `BroadPaper.configure({ … })`, for hosts that prefer a namespace to a bare\n * function. Both are the same store.\n */\nexport const BroadPaper = { configure, getConfig };\n\nfunction env(name: string): string | undefined {\n  // Node, Deno and bundlers that inline `process.env` all satisfy this; a\n  // browser without a shim simply has no environment, which is not an error.\n  const p = (globalThis as { process?: { env?: Record<string, string | undefined> } }).process;\n  const value = p?.env?.[name];\n  return value && value.trim() ? value : undefined;\n}\n\n/**\n * Keys trusted in addition to the built-in ones, from configuration and from\n * `BROADPAPER_TRUSTED_KEYS` — a JSON array of `{ keyId, publicKey }`.\n *\n * A syntax error there is reported rather than swallowed: someone setting that\n * variable is doing so on purpose, and silently ignoring it would present as\n * \"my development licence is not being honoured\" with nothing to go on.\n */\nfunction trustedKeysFromEnv(): readonly TrustedKey[] {\n  const raw = env(\"BROADPAPER_TRUSTED_KEYS\");\n  if (!raw) return [];\n  try {\n    const parsed: unknown = JSON.parse(raw);\n    if (!Array.isArray(parsed)) throw new Error(\"expected a JSON array\");\n    return parsed.map((entry, i) => {\n      const k = entry as Record<string, unknown>;\n      if (typeof k?.keyId !== \"string\" || typeof k?.publicKey !== \"string\") throw new Error(`entry ${i} needs keyId and publicKey`);\n      return { keyId: k.keyId, publicKey: k.publicKey };\n    });\n  } catch (e) {\n    warn(`BROADPAPER_TRUSTED_KEYS could not be read (${(e as Error).message}); it is being ignored.`);\n    return [];\n  }\n}\n\n/** Logs a message once, whatever it takes to reach the developer. */\nexport function warn(message: string): void {\n  const s = store();\n  if (s.logged.has(message)) return;\n  s.logged.add(message);\n  const logger = s.config.logger;\n  if (logger === null) return;\n  const line = `[BroadPaper] ${message}`;\n  if (logger) logger(line);\n  else console.warn(line);\n}\n\nexport interface ResolveOptions extends VerifyOptions {\n  /** A licence for this call only, overriding the configured one. */\n  license?: string | null;\n}\n\n/**\n * The licence status for the current configuration.\n *\n * Memoised on the licence string, because every PDF asks and a signature check\n * per page of a five-hundred-page batch is waste. `configure` clears it, and a\n * per-call `license` bypasses it.\n *\n * Whatever the answer, any developer-facing message is logged once. That is the\n * only thing the SDK does that a caller did not ask for, and it is the\n * difference between a developer seeing \"your licence expired\" and a developer\n * seeing an unexplained watermark.\n */\nexport async function resolveLicenseStatus(options: ResolveOptions = {}): Promise<LicenseStatus> {\n  const s = store();\n  const config = s.config;\n  const license = options.license !== undefined ? options.license : config.license ?? env(\"BROADPAPER_LICENSE\") ?? null;\n  const trustedKeys = [...(options.trustedKeys ?? []), ...(config.trustedKeys ?? []), ...trustedKeysFromEnv()];\n  const gracePeriodDays = options.gracePeriodDays ?? config.gracePeriodDays;\n\n  if (!license) {\n    const status = unlicensed();\n    if (status.message) warn(status.message);\n    return status;\n  }\n\n  const verify = (): Promise<LicenseStatus> =>\n    verifyLicense(license, { ...(options.now ? { now: options.now } : {}), trustedKeys, ...(gracePeriodDays !== undefined ? { gracePeriodDays } : {}) }).then((status) => {\n      if (status.message) warn(status.message);\n      return status;\n    });\n\n  // A fixed clock is a test or a deterministic render; caching across different\n  // clocks would make the grace-period boundary depend on call order.\n  if (options.now || options.license !== undefined) return verify();\n\n  const key = `${license}|${trustedKeys.map((k) => k.keyId).join(\",\")}|${gracePeriodDays ?? \"\"}`;\n  if (s.cache?.key !== key) s.cache = { key, status: verify() };\n  return s.cache.status;\n}\n","/**\n * The evaluation mark.\n *\n * This is the only thing an unlicensed BroadPaper does differently. Every\n * block, both PDF backends, the designer, data binding, pagination and the\n * render service behave identically with and without a licence; what changes is\n * that the file says, on every page, that it was produced with an evaluation\n * copy.\n *\n * It is drawn to be unmistakable in a document review and harmless to a\n * developer evaluating the product: a light diagonal line across the page,\n * behind nothing and over everything, at an opacity that leaves the report\n * entirely readable. Making the output illegible would only push people towards\n * evaluating something else.\n *\n * Each backend draws the spec with its own primitives — the Forme engine has a\n * page-native watermark node, Chromium gets a printed overlay — because a\n * single drawing implementation would mean one of them post-processing a file\n * the other had already finished, and a stamping pass that can be skipped is a\n * stamping pass that eventually is.\n */\nimport { resolveLicenseStatus, type ResolveOptions } from \"./config.js\";\nimport type { LicenseStatus } from \"./types.js\";\n\nexport interface WatermarkSpec {\n  text: string;\n  /** Points. The engines size the mark from this, not from the page. */\n  fontSize: number;\n  /** Degrees, anticlockwise from horizontal. */\n  angle: number;\n  /** Hex, without alpha. */\n  color: string;\n  /** 0–1. */\n  opacity: number;\n}\n\n/**\n * The mark itself.\n *\n * No dashes or typographic punctuation: the standard PDF faces carry no em\n * dash, and a theme that names a font the engine does not have falls back to\n * them, which turned \"BroadPaper — Evaluation Copy\" into \"BroadPaper\n * Evaluation Copy\" in half the documents and a question mark in the rest.\n */\nexport const EVALUATION_WATERMARK: WatermarkSpec = {\n  text: \"BroadPaper Evaluation Copy\",\n  fontSize: 44,\n  angle: -35,\n  color: \"#c8102e\",\n  opacity: 0.12\n};\n\n/**\n * The mark a render should carry, or null when the licence says none.\n *\n * Backends call this rather than reading the licence status themselves, so\n * \"licensed\" and \"no watermark\" cannot drift apart.\n */\nexport async function resolveWatermark(options: ResolveOptions = {}): Promise<WatermarkSpec | null> {\n  const status = await resolveLicenseStatus(options);\n  return watermarkFor(status);\n}\n\n/** The pure half of {@link resolveWatermark}, for callers that already have a status. */\nexport function watermarkFor(status: LicenseStatus): WatermarkSpec | null {\n  return status.licensed ? null : EVALUATION_WATERMARK;\n}\n\n/**\n * CSS that paints the mark on every `.bp-page` of a rendered document.\n *\n * Used by the Chromium backend and by the designer's print path — the two\n * places a PDF is produced by a browser rather than by the engine. `position:\n * fixed` would put it on the viewport rather than on each page, so it is an\n * absolutely positioned pseudo-element on the page box, which prints once per\n * sheet.\n *\n * `print-color-adjust` matters: without it Chromium drops the mark from the\n * printed file exactly as it drops any other background colour.\n */\nexport function watermarkCss(spec: WatermarkSpec = EVALUATION_WATERMARK): string {\n  const text = spec.text.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"');\n  return [\n    \".bp-page{position:relative;}\",\n    \".bp-page::after{\",\n    `content:\"${text}\";`,\n    \"position:absolute;inset:0;\",\n    \"display:flex;align-items:center;justify-content:center;\",\n    \"pointer-events:none;z-index:2147483647;\",\n    `transform:rotate(${spec.angle}deg);`,\n    \"font-family:Helvetica,Arial,sans-serif;font-weight:700;letter-spacing:0.04em;white-space:nowrap;\",\n    `font-size:${spec.fontSize}pt;color:${spec.color};opacity:${spec.opacity};`,\n    \"-webkit-print-color-adjust:exact;print-color-adjust:exact;\",\n    \"}\"\n  ].join(\"\");\n}\n\n/**\n * The PDF Producer string for a render.\n *\n * Licensed output records the licence id. It is not a secret — it identifies a\n * customer's licence, not their account — and having it in the file means a\n * document that turns up somewhere it should not can be traced back to the\n * licence that produced it without any of the tracking a phone-home would need.\n */\nexport function producerString(status: LicenseStatus): string {\n  if (!status.licensed || !status.payload) return \"BroadPaper (evaluation)\";\n  return `BroadPaper (${status.payload.licenseId})`;\n}\n"],"mappings":"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","names":["i"]}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@broadpaper/license",
+  "version": "0.1.1",
+  "description": "BroadPaper licence certificates: offline Ed25519 verification, entitlement states and the evaluation watermark. Contains only the public verification keys.",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.md"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@noble/ed25519": "^3.2.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --sourcemap --clean",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}