@lpdfio/lpdf 0.6.0 → 0.8.0

package/LICENSE

@@ -10,13 +10,21 @@ License inquiries: license@lpdf.io
 
 Lpdf is available under three license tiers: a free Community License for individuals and qualifying organizations, a Professional License for mid-size commercial use, and an Enterprise License for larger organizations. All license tiers receive the complete feature set — no capabilities are gated behind paid plans.
 
+### Definitions
+
+"Production environment" means any environment in which the Software processes real user data or supports live business operations, including staging environments accessible by end users.
+
+"Production Context" means a distinct, independently operated system, application, or automated workflow that uses the Software in a production environment, where "independently operated" means it serves a separate and identifiable purpose, user base, or business function. For the avoidance of doubt: multiple delivery channels (web, mobile, desktop, API) of the same system serving the same purpose and user base constitute a single Production Context; all internal business operations of an organization where the organization's own personnel are the sole end users constitute a single Production Context regardless of the number of internal systems or services involved; a service or component that operates exclusively as part of a larger system and has no independent production deployment is not a separate Production Context.
+
 ### Equal Features Across All Tiers
 
 Every user of Lpdf, regardless of license tier, has access to the same library, the same layout engine, the same adapters, and the same output quality. Licensing determines the terms of use, not the features available.
 
 ### Transitive Dependency
 
-If Lpdf is pulled in as an indirect dependency of another library or framework rather than used directly in your project, the Community License applies automatically, regardless of your organization's revenue.
+If Lpdf is pulled in as an indirect dependency of another library or framework rather than used directly in your project, the Community License terms apply automatically with respect to revenue thresholds — no upgrade to a Professional or Enterprise License is required solely on account of the indirect dependency. 
+
+The author of the wrapping library or framework is responsible for obtaining a valid license key; end users of that library or framework are not required to obtain a separate Lpdf license key for their indirect use. 
 
 This exemption does not apply if the dependency was introduced, created, or controlled by the licensee's organization for the purpose of circumventing license requirements.
 
@@ -36,13 +44,11 @@ Organizations whose revenue crosses the 1,000,000 USD threshold have a **90-day
 
 ### Mid-Size Businesses
 
-Companies and organizations whose total annual gross revenue exceeded **1,000,000 USD** but did not exceed **10,000,000 USD** in the most recent 12-month fiscal year must obtain a Professional License to use Lpdf in production environments.
-
-"Production environment" means any environment in which the Software processes real user data or supports live business operations, including staging environments accessible by end users.
+Companies and organizations whose total annual gross revenue exceeded **1,000,000 USD** but did not exceed **10,000,000 USD** in the most recent 12-month fiscal year must obtain a Professional License for each Production Context in which they use the Software.
 
 ### Larger Businesses
 
-Companies and organizations whose total annual gross revenue exceeded **10,000,000 USD** in the most recent 12-month fiscal year must obtain an Enterprise License to use Lpdf in production environments.
+Companies and organizations whose total annual gross revenue exceeded **10,000,000 USD** in the most recent 12-month fiscal year must obtain an Enterprise License for each Production Context in which they use the Software.
 
 Organizations whose revenue crosses the 10,000,000 USD threshold have a **90-day grace period** following the close of their fiscal year to obtain an Enterprise license. During this grace period, continued use under a Professional License is permitted. The licensee remains subject to the terms of their existing Professional License and does not gain Enterprise rights until an Enterprise License is obtained.
 
@@ -52,6 +58,18 @@ Paid licenses directly fund the continued development, maintenance, and improvem
 
 ---
 
+## Unregistered Use
+
+Use of the Software without a valid license key ("Unregistered Use") is permitted solely for evaluation and local testing. It does not constitute a license for use in a production environment, commercial deployment, or distribution.
+
+Unregistered Use is subject to the following restriction:
+
+**Attribution.** Each document rendered shall include an attribution notice in the form specified in the Software documentation. This notice may not be suppressed, removed, or obscured.
+
+This restriction is lifted upon obtaining a valid license key. Community keys are available at no cost at lpdf.io.
+
+---
+
 ## Lpdf Community License
 
 *Applies to: individuals, open-source projects, non-profit organizations, and companies with annual gross revenue under 1,000,000 USD.*
@@ -60,9 +78,17 @@ Permission is hereby granted, free of charge, to any person or qualifying organi
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. Any redistribution of the Software must be made under the terms of this Community License and may not be sublicensed under different terms.
 
+### License Key
+
+A license key issued under this license may be used by you, your employees, and contractors working on your behalf on your projects. You may not share, distribute, or otherwise make your license key available to individuals or organizations outside your own. Any person or organization outside your own that wishes to use Lpdf must obtain their own license key at lpdf.io.
+
 All modifications to the Software made by the licensee remain the intellectual property of the licensee. Codesense LLC claims no ownership over modifications unless they are voluntarily submitted as contributions to the Lpdf project under a separate Contributor License Agreement.
 
-If your organization's annual gross revenue exceeds 1,000,000 USD, your rights under this Community License are automatically terminated upon expiration of the 90-day grace period described above, and you must obtain a Professional or Enterprise license before continuing to use Lpdf in production.
+If your organization's annual gross revenue exceeds 1,000,000 USD, your rights under this Community License to use the Software in commercial Production Contexts are automatically terminated upon expiration of the 90-day grace period described above, and you must obtain a Professional or Enterprise license for each such Production Context. Use under this Community License by individuals, open-source projects, and non-profit organizations is not subject to revenue thresholds and is unaffected by this provision.
+
+### License Key Expiration
+
+License keys issued under this license are valid for one year from the date of issuance. Before expiry, a new key must be generated from the portal and deployed in place of the expiring key. A key may be renewed at no cost provided the licensee continues to qualify under this Community License. Use of an expired key is treated as Unregistered Use — documents rendered without a valid key will include an attribution notice as described above.
 
 ### Governing Law
 
@@ -76,28 +102,36 @@ THE SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 
 ## Lpdf Professional License
 
-*Applies to: companies and organizations with annual gross revenue exceeding 1,000,000 USD and not exceeding 10,000,000 USD.*
+*Minimum required for companies and organizations with annual gross revenue exceeding 1,000,000 USD and not exceeding 10,000,000 USD.*
 
 ### Conduct
 
 Licensees agree not to make false statements of fact about Lpdf, Codesense LLC, or its contributors that are intended to cause material harm to the reputation of the project or the company. This clause does not restrict good-faith criticism, bug reports, public discussion of software deficiencies, or reviews based on the licensee's genuine experience.
 
-License rights may not be rented, leased, or transferred to any third party.
+License rights may not be rented, leased, or transferred to any third party. A license key issued under this license may be used by the licensee's employees and contractors working on the licensee's behalf; the licensee may not share or distribute a license key to individuals or organizations outside their own, who must obtain their own license key.
 
 ### License Grant
 
-Subject to payment of the applicable license fee, Codesense LLC grants the licensee a non-exclusive, worldwide, royalty-free license to:
+Subject to payment of the applicable license fee per Production Context, Codesense LLC grants the licensee a non-exclusive, worldwide, royalty-free license to use the Software within a single licensed Production Context:
 
-- Use, copy, modify, and integrate the Software into unlimited applications and projects
-- Distribute the Software as part of compiled or packaged commercial products
-- Deploy the Software across unlimited servers, environments, and infrastructure
+- Use, copy, modify, and integrate the Software into the licensed Production Context
+- Deploy the Software across any number of servers, environments, and infrastructure serving that Production Context
+- Distribute the Software as a component of the licensed Production Context
+
+A separate license is required for each additional Production Context in which the licensee uses the Software in a production environment.
+
+**Tier compliance.** Licensee is responsible for ensuring their use of the Software complies with the applicable license tier at all times. If the licensee's annual gross revenue crosses 10,000,000 USD, the licensee must obtain an Enterprise License for each affected Production Context within 90 days of the close of the fiscal year in which the threshold was crossed. Use of a Professional License key while qualifying for the Enterprise tier is a material breach of this Agreement.
 
 ### License Fees and Evaluation
 
-A license fee is required for use of Lpdf in production environments (as defined above). Evaluation and testing in non-production environments is permitted without a license for a period not exceeding 30 days.
+A license fee is required per Production Context for use of the Software in a production environment (as defined above). Evaluation and testing in non-production environments is permitted without a license for a period not exceeding 30 days.
 
 Upon payment, the licensee receives a perpetual license for the version of Lpdf current at the time of purchase, plus one year of updates, new features, and security patches. Continued access to new versions after the first year requires annual renewal. Cancellation of renewal does not affect the perpetual license for the version already held.
 
+License keys issued under this license are valid for one year and are renewed automatically upon annual payment. An expired key reverts to Unregistered Use behavior — documents rendered without a valid key will include an attribution notice. A valid key is required to exercise the license grant in any production environment.
+
+**Active subscription required.** The license grant is contingent on an active subscription in good standing. A technically valid key does not authorize use of the Software after the subscription has expired or been cancelled. Use of any key following subscription lapse — including keys that remain technically valid — constitutes unauthorized use and a material breach of this Agreement.
+
 ### Support
 
 Professional License holders receive email support from Codesense LLC with a target response time of 3 business days for standard inquiries. Support terms are further detailed at lpdf.io/support.
@@ -140,28 +174,37 @@ Notwithstanding the foregoing, either party may seek injunctive or other equitab
 
 ## Lpdf Enterprise License
 
-*Applies to: companies and organizations with annual gross revenue exceeding 10,000,000 USD.*
+*Required for companies and organizations with annual gross revenue exceeding 10,000,000 USD. Available to any organization that prefers Enterprise license terms.*
 
 ### Conduct
 
 Licensees agree not to make false statements of fact about Lpdf, Codesense LLC, or its contributors that are intended to cause material harm to the reputation of the project or the company. This clause does not restrict good-faith criticism, bug reports, public discussion of software deficiencies, or reviews based on the licensee's genuine experience.
 
-License rights may not be rented, leased, or transferred to any third party, except as expressly permitted under the subsidiary grant below.
+License rights may not be rented, leased, or transferred to any third party. A license key issued under this license may be used by the licensee's employees, contractors, and personnel of Controlled Entities (as defined in the License Grant below) working on Production Contexts licensed by the licensee. The licensee may not share or distribute a license key for use in Production Contexts not licensed by the licensee; any Production Context operated independently by a Controlled Entity requires its own license obtained by that entity.
 
 ### License Grant
 
-Subject to payment of the applicable license fee, Codesense LLC grants the licensee a non-exclusive, worldwide, royalty-free license for an unlimited number of developers within the licensee's organization to:
+Subject to payment of the applicable license fee per Production Context, Codesense LLC grants the licensee a non-exclusive, worldwide, royalty-free license for an unlimited number of developers within the licensee's organization to use the Software within a single licensed Production Context:
+
+- Use, copy, modify, and integrate the Software into the licensed Production Context
+- Deploy the Software across any number of servers, environments, and infrastructure serving that Production Context
+- Distribute the Software as a component of the licensed Production Context
+
+A separate license is required for each additional Production Context in which the licensee uses the Software in a production environment.
+
+**Controlled Entities.** "Controlled Entities" means wholly owned subsidiaries and entities in which the licensee holds more than 50% ownership or voting control. Personnel of Controlled Entities may use license keys issued under this license solely for Production Contexts licensed by the licensee. This does not extend the license to Production Contexts operated independently by a Controlled Entity; each such Production Context requires its own license obtained by the Controlled Entity at the tier applicable to that entity's annual gross revenue.
 
-- Use, copy, modify, and integrate the Software into unlimited applications and projects
-- Distribute the Software as part of compiled or packaged commercial products
-- Deploy the Software across unlimited servers, environments, and infrastructure
-- Extend license rights to wholly owned subsidiaries and entities in which the licensee holds more than 50% ownership or voting control ("Controlled Entities"), provided such Controlled Entities are identified to Codesense LLC upon request and remain subject to the terms of this license
+**Tier compliance.** Licensee is responsible for ensuring their use of the Software complies with the applicable license tier at all times. Each Controlled Entity using the Software must qualify for the tier under which they operate. If a Controlled Entity's annual gross revenue would independently qualify that entity for a different tier, that entity must obtain its own license at the applicable tier for any Production Context it independently operates.
 
 ### License Fees and Evaluation
 
-A license fee is required for use of Lpdf in production environments (as defined above). Evaluation and testing in non-production environments is permitted without a license for a period not exceeding 30 days.
+A license fee is required per Production Context for use of the Software in a production environment (as defined above). Evaluation and testing in non-production environments is permitted without a license for a period not exceeding 30 days.
 
-Upon payment, the licensee receives a perpetual license for the version of Lpdf current at the time of purchase, plus one year of updates, new features, and security patches. Continued access to new versions after the first year requires annual renewal. Cancellation of renewal does not affect the perpetual license for the version already held.
+Upon payment, the licensee receives a perpetual license for the major version of Lpdf current at the time of purchase, plus access to updates, new features, and security patches within that major version for the duration of the active subscription. Cancellation of renewal does not affect the perpetual license for the major version already held.
+
+**License keys.** License keys issued under this license are locked to the major version of Lpdf current at the time of generation and carry no date expiry. While the subscription is active and in good standing, the licensee may generate new keys for the current major version from the portal at any time. When a new major version of Lpdf is released, a new key must be generated from the portal to use that version; keys generated for a prior major version continue to function with that version only. The right to generate new keys requires an active subscription; key generation rights terminate upon subscription lapse.
+
+**Active subscription required.** The license grant is contingent on an active subscription in good standing. A technically valid key does not authorize use of the Software after the subscription has expired or been cancelled. Use of any key following subscription lapse — including keys that carry no date expiry and remain technically valid — constitutes unauthorized use and a material breach of this Agreement.
 
 ### Support
 
@@ -173,7 +216,7 @@ Enterprise licensees may request a Master Service Agreement (MSA) in place of th
 
 ### Audit
 
-Codesense LLC may, upon 30 days' written notice and no more than once per calendar year, request a written certification from the licensee confirming their applicable license tier and annual gross revenue for the most recent fiscal year, and may request a list of Controlled Entities covered under the subsidiary grant. The licensee agrees to provide such certification within 15 business days of the request. For Enterprise licensees under an MSA, audit rights may be further defined therein.
+Codesense LLC may, upon 30 days' written notice and no more than once per calendar year, request a written certification from the licensee confirming their applicable license tier and annual gross revenue for the most recent fiscal year, and may request a list of Controlled Entities whose personnel have been granted access to the licensee's license keys. The licensee agrees to provide such certification within 15 business days of the request. For Enterprise licensees under an MSA, audit rights may be further defined therein.
 
 ### Ownership and Modifications
 

package/README.md

@@ -2,9 +2,9 @@
 
 # @lpdfio/lpdf
 
-Node.js adapter for [Lpdf](https://lpdf.io) — PDF as Code, on every platform. 
+**Node.js SDK for [Lpdf](https://lpdf.io) — PDF as Code on every platform**
 
-Describe your document structure in code using the programming Kit or XML. Every PDF is compact, pixel-perfect, and identical across platforms.
+You describe a document as code or XML. Lpdf renders a compact, pixel-perfect PDF — identical across platforms.
 
 ## Installation
 
@@ -15,48 +15,41 @@ npm install @lpdfio/lpdf
 ## Usage — Node.js
 
 ```ts
-import { LpdfEngine } from '@lpdfio/lpdf';
-import { readFileSync, writeFileSync } from 'node:fs';
-
-const engine = new LpdfEngine('');
-
-engine.loadFont('montserrat', readFileSync('fonts/Montserrat-Regular.ttf'));
-engine.loadImage('logo', readFileSync('images/logo.png'));
-
-const xml = readFileSync('document.xml', 'utf8');
-const pdf = await engine.renderPdf(xml);
-
-writeFileSync('output.pdf', pdf);
+import { L, NoAttr } from 'lpdf'
+
+const engine = L.engine()
+
+const doc = L.document({ size: 'letter', margin: '48pt' }, [
+    L.section(NoAttr, [
+        L.layout(NoAttr, [
+            L.stack({ gap: '24pt' }, [
+                L.split(NoAttr, [
+                    L.text({ fontSize: '8pt', color: '#888888' }, ['ACME CORP']),
+                    L.text({ fontSize: '22pt', bold: 'true' }, ['Project Proposal']),
+                ]),
+                L.divider({ thickness: 'xs' }),
+                L.text({ fontSize: '13pt', bold: 'true' }, ['Scope of Work']),
+                L.flank({ gap: '12pt', align: 'start' }, [
+                    L.text({ color: '#888888', width: '24pt' }, ['01']),
+                    L.text(NoAttr, ['Discovery & Research']),
+                ]),
+            ]),
+        ]),
+    ]),
+])
+
+const pdf = await engine.render(doc)
 ```
 
-## Usage — Browser
-
-```ts
-import { LpdfEngine } from '@lpdfio/lpdf/browser';
+## Requirements
 
-const engine = new LpdfEngine('');
+- Node.js 16+
+- No external runtime dependencies — the WASM engine is embedded in the package.
 
-const xml = `<stack><text>Hello, Lpdf</text></stack>`;
-const pdf = await engine.renderPdf(xml);
+## Docs
 
-const blob = new Blob([pdf], { type: 'application/pdf' });
-window.open(URL.createObjectURL(blob));
-```
-
-## XML format
-
-Documents are defined in a layout XML format. See the [Lpdf documentation](https://lpdf.io/docs) and [examples](https://github.com/lpdfio/lpdf/tree/main/docs/examples) for the full schema.
-
-```xml
-<stack spacing="m" padding="l">
-  <text font-size="xl" font="Montserrat-Bold">Invoice #1001</text>
-  <grid columns="2">
-    <text>Date</text>      <text>2026-04-25</text>
-    <text>Due</text>       <text>2026-05-25</text>
-  </grid>
-</stack>
-```
+[lpdf.io/docs/js](https://lpdf.io/docs/js)
 
-## License
+--
 
 Dual-licensed: Community License (free) and Commercial License (paid). See [LICENSE](LICENSE) for full terms.

package/dist/L.d.ts

@@ -0,0 +1,63 @@
+import type { LpdfTokens, PdfDocument } from './kit';
+import { PdfEngine } from './engine';
+/** Pass as `attrs` when a node has no attributes. Equivalent to `null`. */
+export declare const NoAttr: null;
+/**
+ * Unified lpdf facade.
+ *
+ * All document, layout, and canvas factory methods are available as flat
+ * properties on this object. Construction-time configuration is handled via
+ * `L.engine()`.
+ *
+ * @example
+ * ```ts
+ * import { L, NoAttr } from 'lpdf';
+ *
+ * const engine = L.engine().setLicenseKey(process.env.LPDF_KEY);
+ *
+ * const doc = L.document(NoAttr, [
+ *   L.section(NoAttr, [
+ *     L.layout(null, [ L.text(NoAttr, ['Hello']) ]),
+ *   ]),
+ * ]);
+ *
+ * const pdf = await engine.render(doc);
+ * ```
+ */
+export declare const L: Readonly<{
+    /** Create a new {@link PdfEngine} instance. Call `.setLicenseKey()` to configure. */
+    engine: () => PdfEngine;
+    /** Convert a `PdfDocument` tree to an lpdf XML string. */
+    toXml: (doc: PdfDocument) => string;
+    document: (attrs: import("./kit").DocumentAttr | null, nodes: import("./kit").LpdfSectionNode[]) => PdfDocument;
+    section: (attrs: import("./kit").SectionAttr | null, nodes: (import("./kit").LpdfLayoutBlock | import("./kit").LpdfCanvasBlock)[]) => import("./kit").LpdfSectionNode;
+    layout: (_attrs: null, nodes: import("./layout").LpdfNode[]) => import("./kit").LpdfLayoutBlock;
+    canvas: (_attrs: null, layers: import("./canvas").LpdfCanvasLayerNode[]) => import("./kit").LpdfCanvasBlock;
+    tokens: (attrs: LpdfTokens) => LpdfTokens;
+    stack: (attrs: import("./layout").StackAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    flank: (attrs: import("./layout").FlankAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    split: (attrs: import("./layout").SplitAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    cluster: (attrs: import("./layout").ClusterAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    grid: (attrs: import("./layout").GridAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    frame: (attrs: import("./layout").FrameAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    link: (attrs: import("./layout").LinkAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfContainerNode;
+    table: (attrs: import("./layout").TableAttr, nodes: (import("./layout").LpdfTheadNode | import("./layout").LpdfTrNode)[]) => import("./layout").LpdfTableNode;
+    thead: (attrs: import("./layout").TheadAttr | null, nodes: import("./layout").LpdfTdNode[]) => import("./layout").LpdfTheadNode;
+    tr: (attrs: import("./layout").TrAttr | null, nodes: import("./layout").LpdfTdNode[]) => import("./layout").LpdfTrNode;
+    td: (attrs: import("./layout").TdAttr | null, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfTdNode;
+    text: (attrs: import("./layout").TextAttr | null, nodes: (string | import("./layout").LpdfSpanNode)[]) => import("./layout").LpdfTextNode;
+    span: (attrs: import("./layout").SpanAttr | null, nodes: string[]) => import("./layout").LpdfSpanNode;
+    divider: (attrs: import("./layout").DividerAttr | null) => import("./layout").LpdfDividerNode;
+    img: (attrs: import("./layout").ImgAttr) => import("./layout").LpdfImgNode;
+    barcode: (attrs: import("./layout").BarcodeAttr) => import("./layout").LpdfBarcodeNode;
+    region: (attrs: import("./layout").RegionAttr, nodes: import("./layout").LpdfNode[]) => import("./layout").LpdfRegionNode;
+    field: (type: string, name: string, attrs?: import("./layout").FieldAttr | null) => import("./layout").LpdfFieldNode;
+    layer: (attrs: import("./canvas").LayerAttr | null, nodes: import("./canvas").LpdfCanvasPrimitiveNode[]) => import("./canvas").LpdfCanvasLayerNode;
+    rect: (x: number, y: number, w: number, h: number, style?: import("./canvas").CanvasRectStyle) => import("./canvas").LpdfCanvasRectNode;
+    line: (x1: number, y1: number, x2: number, y2: number, style?: import("./canvas").CanvasLineStyle) => import("./canvas").LpdfCanvasLineNode;
+    ellipse: (cx: number, cy: number, rx: number, ry: number, style?: import("./canvas").CanvasEllipseStyle) => import("./canvas").LpdfCanvasEllipseNode;
+    circle: (cx: number, cy: number, r: number, style?: import("./canvas").CanvasEllipseStyle) => import("./canvas").LpdfCanvasCircleNode;
+    path: (d: string, style?: import("./canvas").CanvasPathStyle) => import("./canvas").LpdfCanvasPathNode;
+    textAt: (x: number, y: number, content: string, style?: import("./canvas").CanvasTextStyle, runs?: import("./canvas").CanvasRun[]) => import("./canvas").LpdfCanvasTextNode;
+    imgAt: (x: number, y: number, w: number, h: number, name: string, anchor?: string) => import("./canvas").LpdfCanvasImgNode;
+}>;

package/dist/L.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.L = exports.NoAttr = void 0;
+const kit_1 = require("./kit");
+const layout_1 = require("./layout");
+const canvas_1 = require("./canvas");
+const engine_1 = require("./engine");
+const kit_to_xml_1 = require("./kit-to-xml");
+/** Pass as `attrs` when a node has no attributes. Equivalent to `null`. */
+exports.NoAttr = null;
+/**
+ * Unified lpdf facade.
+ *
+ * All document, layout, and canvas factory methods are available as flat
+ * properties on this object. Construction-time configuration is handled via
+ * `L.engine()`.
+ *
+ * @example
+ * ```ts
+ * import { L, NoAttr } from 'lpdf';
+ *
+ * const engine = L.engine().setLicenseKey(process.env.LPDF_KEY);
+ *
+ * const doc = L.document(NoAttr, [
+ *   L.section(NoAttr, [
+ *     L.layout(null, [ L.text(NoAttr, ['Hello']) ]),
+ *   ]),
+ * ]);
+ *
+ * const pdf = await engine.render(doc);
+ * ```
+ */
+exports.L = Object.freeze({
+    /** Create a new {@link PdfEngine} instance. Call `.setLicenseKey()` to configure. */
+    engine: () => new engine_1.PdfEngine(),
+    /** Convert a `PdfDocument` tree to an lpdf XML string. */
+    toXml: (doc) => (0, kit_to_xml_1.kitToXml)(doc),
+    // ── Kit ───────────────────────────────────────────────────────────────────
+    document: kit_1.LpdfKit.document,
+    section: kit_1.LpdfKit.section,
+    layout: kit_1.LpdfKit.layout,
+    canvas: kit_1.LpdfKit.canvas,
+    tokens: (attrs) => attrs,
+    // ── Layout ────────────────────────────────────────────────────────────────
+    stack: layout_1.LpdfLayout.stack,
+    flank: layout_1.LpdfLayout.flank,
+    split: layout_1.LpdfLayout.split,
+    cluster: layout_1.LpdfLayout.cluster,
+    grid: layout_1.LpdfLayout.grid,
+    frame: layout_1.LpdfLayout.frame,
+    link: layout_1.LpdfLayout.link,
+    table: layout_1.LpdfLayout.table,
+    thead: layout_1.LpdfLayout.thead,
+    tr: layout_1.LpdfLayout.tr,
+    td: layout_1.LpdfLayout.td,
+    text: layout_1.LpdfLayout.text,
+    span: layout_1.LpdfLayout.span,
+    divider: layout_1.LpdfLayout.divider,
+    img: layout_1.LpdfLayout.img,
+    barcode: layout_1.LpdfLayout.barcode,
+    region: layout_1.LpdfLayout.region,
+    field: layout_1.LpdfLayout.field,
+    // ── Canvas ────────────────────────────────────────────────────────────────
+    layer: canvas_1.LpdfCanvas.layer,
+    rect: canvas_1.LpdfCanvas.rect,
+    line: canvas_1.LpdfCanvas.line,
+    ellipse: canvas_1.LpdfCanvas.ellipse,
+    circle: canvas_1.LpdfCanvas.circle,
+    path: canvas_1.LpdfCanvas.path,
+    textAt: canvas_1.LpdfCanvas.textAt,
+    imgAt: canvas_1.LpdfCanvas.imgAt,
+});

package/dist/_shared.d.ts

@@ -1,13 +1,10 @@
 /**
  * Shared types used by both the Node.js and browser entry points.
  */
+/** Construction-time configuration for {@link PdfEngine}. Node has no infra options. */
+export interface EngineOptions {
+}
 export interface RenderOptions {
-    /**
-     * Pre-loaded font bytes for custom fonts referenced via <fonts src="…">.
-     * Keys are the font names used in the document; values are raw TTF/OTF bytes.
-     * @deprecated Pass font bytes via `LpdfEngine.loadFont()` instead.
-     */
-    fontBytes?: Record<string, Uint8Array>;
     /**
      * Optional ISO 8601 creation timestamp (e.g. `"2024-06-01T12:00:00"`).
      * When provided, written as `/CreationDate` in the PDF info dictionary.

package/dist/browser.js

@@ -378,63 +378,12 @@ async function __wbg_init(module_or_path) {
   return __wbg_finalize_init(instance, module);
 }
 
-// src/kit.ts
-function attrKey(camel) {
-  return camel.replace(/[A-Z]/g, (c) => "-" + c.toLowerCase());
-}
-function buildAttrs(options) {
-  const result = {};
-  for (const [key, val] of Object.entries(options)) {
-    if (val !== void 0) {
-      result[attrKey(key)] = val;
-    }
-  }
-  return result;
-}
-function layout(nodes = []) {
-  return { type: "layout", nodes };
-}
-function canvas(layers = []) {
-  return { type: "canvas", nodes: layers };
-}
-function section(input = {}) {
-  return {
-    type: "section",
-    attrs: buildAttrs(input.options ?? {}),
-    nodes: input.nodes ?? []
-  };
-}
-function document(input = {}) {
-  const { tokens, meta, ...restOpts } = input.options ?? {};
-  const attrs = {
-    ...buildAttrs(restOpts)
-  };
-  if (tokens !== void 0) attrs["tokens"] = tokens;
-  if (meta !== void 0) attrs["meta"] = meta;
-  return {
-    version: 1,
-    type: "document",
-    attrs,
-    nodes: input.sections ?? []
-  };
-}
-var LpdfKit = Object.freeze({
-  layout,
-  canvas,
-  section,
-  document
-});
-
 // src/browser.ts
-async function initLpdf(wasmSource, licenseKey = "", initOptions = {}) {
+var NoAttr = null;
+async function initLpdf(wasmSource, licenseKey = "") {
   await __wbg_init(wasmSource);
   const fontMap = /* @__PURE__ */ new Map();
   const imageMap = /* @__PURE__ */ new Map();
-  if (initOptions.fontBytes) {
-    for (const [name, bytes] of Object.entries(initOptions.fontBytes)) {
-      fontMap.set(name, bytes);
-    }
-  }
   return {
     loadFont(name, bytes) {
       fontMap.set(name, bytes);
@@ -442,27 +391,37 @@ async function initLpdf(wasmSource, licenseKey = "", initOptions = {}) {
     loadImage(name, bytes) {
       imageMap.set(name, bytes);
     },
-    async renderPdf(xml, callOptions = {}) {
+    async render(input, callOptions = {}) {
       const engine = new LpdfEngine(licenseKey);
       for (const [name, bytes] of fontMap) {
         engine.load_font(name, bytes);
       }
-      if (callOptions.fontBytes) {
-        for (const [name, bytes] of Object.entries(callOptions.fontBytes)) {
-          if (!fontMap.has(name)) engine.load_font(name, bytes);
-        }
-      }
       for (const [name, bytes] of imageMap) {
         engine.load_image(name, bytes);
       }
-      const dataJson = callOptions.data != null ? JSON.stringify(callOptions.data) : null;
-      const pdf = engine.render_pdf(xml, dataJson);
+      if (callOptions.createdOn) {
+        engine.set_created_on(callOptions.createdOn);
+      }
+      let pdf;
+      if (typeof input === "string") {
+        const dataJson = callOptions.data != null ? JSON.stringify(callOptions.data) : null;
+        pdf = engine.render_pdf(input, dataJson);
+      } else {
+        const wasmExt = engine;
+        if (typeof wasmExt.render_tree_pdf === "function") {
+          pdf = wasmExt.render_tree_pdf(JSON.stringify(input));
+        } else {
+          const mod = engine;
+          const xml = mod.constructor.kit_to_xml?.(JSON.stringify(input)) ?? "";
+          pdf = engine.render_pdf(xml, null);
+        }
+      }
       engine.free();
       return pdf;
     }
   };
 }
 export {
-  LpdfKit,
+  NoAttr,
   initLpdf
 };

package/dist/canvas.d.ts

@@ -8,6 +8,8 @@ export interface CanvasRectStyle {
     strokeWidth?: number;
     strokeDash?: number[];
     borderRadius?: number;
+    opacity?: number;
+    anchor?: string;
 }
 export interface CanvasLineStyle {
     stroke?: string;
@@ -21,6 +23,8 @@ export interface CanvasEllipseStyle {
     stroke?: string;
     strokeWidth?: number;
     strokeDash?: number[];
+    opacity?: number;
+    anchor?: string;
 }
 export interface CanvasPathStyle {
     fill?: string;
@@ -30,6 +34,7 @@ export interface CanvasPathStyle {
     fillRuleEvenodd?: boolean;
     lineCap?: LineCap;
     lineJoin?: LineJoin;
+    opacity?: number;
 }
 export interface CanvasTextStyle {
     font?: string;
@@ -38,6 +43,8 @@ export interface CanvasTextStyle {
     align?: TextAlign;
     lineHeight?: number;
     width?: number;
+    opacity?: number;
+    anchor?: string;
 }
 export interface CanvasRun {
     text: string;
@@ -100,7 +107,9 @@ export interface LpdfCanvasImgNode {
     attrs: Record<string, string>;
 }
 export type LpdfCanvasPrimitiveNode = LpdfCanvasRectNode | LpdfCanvasLineNode | LpdfCanvasEllipseNode | LpdfCanvasCircleNode | LpdfCanvasPathNode | LpdfCanvasTextNode | LpdfCanvasImgNode;
-export interface CanvasLayerOptions {
+/** @deprecated Use {@link LayerAttr} */
+export type CanvasLayerOptions = LayerAttr;
+export interface LayerAttr {
     page?: PageScope | string;
     opacity?: number;
     transform?: CanvasTransform;
@@ -115,17 +124,17 @@ declare function line(x1: number, y1: number, x2: number, y2: number, style?: Ca
 declare function ellipse(cx: number, cy: number, rx: number, ry: number, style?: CanvasEllipseStyle): LpdfCanvasEllipseNode;
 declare function circle(cx: number, cy: number, r: number, style?: CanvasEllipseStyle): LpdfCanvasCircleNode;
 declare function path(d: string, style?: CanvasPathStyle): LpdfCanvasPathNode;
-declare function canvasText(x: number, y: number, content: string, style?: CanvasTextStyle, runs?: CanvasRun[]): LpdfCanvasTextNode;
-declare function img(x: number, y: number, w: number, h: number, name: string): LpdfCanvasImgNode;
-declare function layer(nodes: LpdfCanvasPrimitiveNode[], options?: CanvasLayerOptions): LpdfCanvasLayerNode;
+declare function textAt(x: number, y: number, content: string, style?: CanvasTextStyle, runs?: CanvasRun[]): LpdfCanvasTextNode;
+declare function imgAt(x: number, y: number, w: number, h: number, name: string, anchor?: string): LpdfCanvasImgNode;
+declare function layer(attrs: LayerAttr | null, nodes: LpdfCanvasPrimitiveNode[]): LpdfCanvasLayerNode;
 export declare const LpdfCanvas: Readonly<{
     rect: typeof rect;
     line: typeof line;
     ellipse: typeof ellipse;
     circle: typeof circle;
     path: typeof path;
-    text: typeof canvasText;
-    img: typeof img;
+    textAt: typeof textAt;
+    imgAt: typeof imgAt;
     layer: typeof layer;
 }>;
 export {};