@lpdfio/lpdf 0.6.0 → 0.7.0

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/_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

@@ -100,7 +100,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 +117,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): 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 {};

package/dist/canvas.js

@@ -124,7 +124,7 @@ function path(d, style) {
         attrs['line-join'] = style.lineJoin;
     return { type: 'canvas-path', attrs };
 }
-function canvasText(x, y, content, style, runs) {
+function textAt(x, y, content, style, runs) {
     const attrs = { x: String(x), y: String(y) };
     if (style?.font !== undefined)
         attrs['font'] = style.font;
@@ -153,21 +153,21 @@ function canvasText(x, y, content, style, runs) {
     }
     return node;
 }
-function img(x, y, w, h, name) {
+function imgAt(x, y, w, h, name) {
     return {
         type: 'canvas-img',
         attrs: { x: String(x), y: String(y), w: String(w), h: String(h), name },
     };
 }
-function layer(nodes, options) {
-    const attrs = {};
-    if (options?.page !== undefined)
-        attrs['page'] = options.page;
-    if (options?.opacity !== undefined)
-        attrs['opacity'] = String(options.opacity);
-    if (options?.transform !== undefined)
-        attrs['transform'] = options.transform.toString();
-    return { type: 'canvas-layer', attrs, nodes };
+function layer(attrs, nodes) {
+    const a = {};
+    if (attrs?.page !== undefined)
+        a['page'] = attrs.page;
+    if (attrs?.opacity !== undefined)
+        a['opacity'] = String(attrs.opacity);
+    if (attrs?.transform !== undefined)
+        a['transform'] = attrs.transform.toString();
+    return { type: 'canvas-layer', attrs: a, nodes };
 }
 exports.LpdfCanvas = Object.freeze({
     rect,
@@ -175,7 +175,7 @@ exports.LpdfCanvas = Object.freeze({
     ellipse,
     circle,
     path,
-    text: canvasText,
-    img,
+    textAt,
+    imgAt,
     layer,
 });

package/dist/engine.d.ts

@@ -1,5 +1,5 @@
 import type { RenderOptions } from './_shared';
-import type { LpdfDocument } from './kit';
+import type { PdfDocument } from './kit';
 /** Thrown when the lpdf engine returns a layout or parse error. */
 export declare class LpdfRenderError extends Error {
     constructor(message: string);
@@ -15,7 +15,7 @@ export interface EncryptPermissions {
     assemble?: boolean;
     print_hq?: boolean;
 }
-/** RC4-128 encryption options passed to {@link LpdfEngine.setEncryption}. */
+/** RC4-128 encryption options passed to {@link PdfEngine.setEncryption}. */
 export interface EncryptOptions {
     /** Open password shown to readers. Empty string = no open password required. */
     userPassword: string;
@@ -24,26 +24,29 @@ export interface EncryptOptions {
     /** Permission flags applied to the document. Omitted flags default to `true`. */
     permissions?: EncryptPermissions;
 }
-export declare class LpdfEngine {
-    private readonly _licenseKey;
-    private readonly _opts;
+export declare class PdfEngine {
+    private _licenseKey;
     private readonly _fonts;
     private readonly _images;
     private _disposed;
     private _encrypt;
-    constructor(licenseKey: string, options?: RenderOptions);
+    constructor();
+    /**
+     * Set the license key. Returns `this` for chaining.
+     */
+    setLicenseKey(key: string): this;
     /**
      * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadFont(name: string, bytes: Uint8Array): this;
     /**
      * Register raw image bytes (PNG or JPEG) for an image name used in `<img name="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadImage(name: string, bytes: Uint8Array): this;
     /**
-     * Configure RC4-128 encryption for all subsequent `renderPdf` calls.
+     * Configure RC4-128 encryption for all subsequent `render` calls.
      * Returns `this` for chaining.
      */
     setEncryption(options: EncryptOptions): this;
@@ -53,7 +56,7 @@ export declare class LpdfEngine {
      */
     clearEncryption(): this;
     /**
-     * Release held resources. Idempotent. Subsequent `renderPdf` / `loadFont`
+     * Release held resources. Idempotent. Subsequent `render` / `loadFont`
      * calls after disposal will throw.
      */
     dispose(): void;
@@ -62,9 +65,9 @@ export declare class LpdfEngine {
     /**
      * Render an lpdf XML string to PDF bytes (Node.js).
      */
-    renderPdf(input: string, callOptions?: RenderOptions): Promise<Uint8Array>;
+    render(input: string, callOptions?: RenderOptions): Promise<Uint8Array>;
     /**
-     * Render an `LpdfDocument` tree (built with `LpdfKit`) to PDF bytes (Node.js).
+     * Render a `PdfDocument` tree (built with `Pdf.document`) to PDF bytes (Node.js).
      */
-    renderPdf(input: LpdfDocument, callOptions?: RenderOptions): Promise<Uint8Array>;
+    render(input: PdfDocument, callOptions?: RenderOptions): Promise<Uint8Array>;
 }

package/dist/engine.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LpdfEngine = exports.LpdfRenderError = void 0;
+exports.PdfEngine = exports.LpdfRenderError = void 0;
 const node_fs_1 = require("node:fs");
 // require() path is relative to the compiled output at dist/engine.js.
 // In the published package, wasm-pack artifacts live in dist/wasm/.
@@ -16,18 +16,25 @@ class LpdfRenderError extends Error {
     }
 }
 exports.LpdfRenderError = LpdfRenderError;
-class LpdfEngine {
-    constructor(licenseKey, options = {}) {
+class PdfEngine {
+    constructor() {
+        this._licenseKey = '';
         this._fonts = new Map();
         this._images = new Map();
         this._disposed = false;
         this._encrypt = null;
-        this._licenseKey = licenseKey;
-        this._opts = options;
+    }
+    /**
+     * Set the license key. Returns `this` for chaining.
+     */
+    setLicenseKey(key) {
+        this._throwIfDisposed();
+        this._licenseKey = key;
+        return this;
     }
     /**
      * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadFont(name, bytes) {
         this._throwIfDisposed();
@@ -36,7 +43,7 @@ class LpdfEngine {
     }
     /**
      * Register raw image bytes (PNG or JPEG) for an image name used in `<img name="…">`.
-     * Call before `renderPdf`. Returns `this` for chaining.
+     * Call before `render`. Returns `this` for chaining.
      */
     loadImage(name, bytes) {
         this._throwIfDisposed();
@@ -44,7 +51,7 @@ class LpdfEngine {
         return this;
     }
     /**
-     * Configure RC4-128 encryption for all subsequent `renderPdf` calls.
+     * Configure RC4-128 encryption for all subsequent `render` calls.
      * Returns `this` for chaining.
      */
     setEncryption(options) {
@@ -62,7 +69,7 @@ class LpdfEngine {
         return this;
     }
     /**
-     * Release held resources. Idempotent. Subsequent `renderPdf` / `loadFont`
+     * Release held resources. Idempotent. Subsequent `render` / `loadFont`
      * calls after disposal will throw.
      */
     dispose() {
@@ -71,28 +78,20 @@ class LpdfEngine {
     [Symbol.dispose]() { this.dispose(); }
     _throwIfDisposed() {
         if (this._disposed)
-            throw new Error('LpdfEngine has been disposed.');
+            throw new Error('PdfEngine has been disposed.');
     }
-    async renderPdf(input, callOptions = {}) {
+    async render(input, callOptions = {}) {
         this._throwIfDisposed();
-        // Merge fonts: instance-level loadFont() calls take precedence over the
-        // deprecated fontBytes option, which is kept for one-version compat.
-        const allFonts = new Map(this._fonts);
-        const extraBytes = { ...this._opts.fontBytes, ...callOptions.fontBytes };
-        for (const [name, bytes] of Object.entries(extraBytes)) {
-            if (!allFonts.has(name))
-                allFonts.set(name, bytes);
-        }
         const engine = new WasmEngine(this._licenseKey);
-        const createdOn = callOptions.createdOn ?? this._opts.createdOn;
-        if (createdOn) {
-            engine.set_created_on(createdOn);
+        if (callOptions.createdOn) {
+            engine.set_created_on(callOptions.createdOn);
         }
         let pdf;
         try {
             if (typeof input === 'string') {
                 // XML path — auto-load fonts and images declared via src="…".
                 const xml = input;
+                const allFonts = new Map(this._fonts);
                 for (const [key, src] of extractAssetSrcs(xml, 'font')) {
                     if (!allFonts.has(key)) {
                         try {
@@ -126,6 +125,7 @@ class LpdfEngine {
             else {
                 // JSON (Kit tree) path — pass JSON directly to render_tree_pdf.
                 const json = JSON.stringify(input);
+                const allFonts = new Map(this._fonts);
                 for (const [key, src] of extractFontSrcsFromJson(json)) {
                     if (!allFonts.has(key)) {
                         try {
@@ -156,7 +156,7 @@ class LpdfEngine {
         return pdf;
     }
 }
-exports.LpdfEngine = LpdfEngine;
+exports.PdfEngine = PdfEngine;
 // ── Helpers ───────────────────────────────────────────────────────────────────
 /** Extract `ref??name → src` pairs from `<font>` or `<image>` tags in XML. */
 function extractAssetSrcs(xml, tag) {

package/dist/index.d.ts

@@ -1,45 +1,9 @@
-export * from './engine';
-export * from './kit';
-export * from './layout';
-export * from './canvas';
-export * from './_shared';
-export { kitToXml } from './kit-to-xml';
-import { LpdfEngine } from './engine';
-export declare const Lpdf: Readonly<{
-    Engine: typeof LpdfEngine;
-    Kit: Readonly<{
-        layout: (nodes?: import("./layout").LpdfNode[]) => import("./kit").LpdfLayoutBlock;
-        canvas: (layers?: import("./canvas").LpdfCanvasLayerNode[]) => import("./kit").LpdfCanvasBlock;
-        section: (input?: import("./kit").SectionInput) => import("./kit").LpdfSectionNode;
-        document: (input?: import("./kit").DocumentInput) => import("./kit").LpdfDocument;
-    }>;
-    Layout: Readonly<{
-        stack: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").StackOptions) => import("./layout").LpdfContainerNode;
-        flank: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").FlankOptions) => import("./layout").LpdfContainerNode;
-        split: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").SplitOptions) => import("./layout").LpdfContainerNode;
-        cluster: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").ClusterOptions) => import("./layout").LpdfContainerNode;
-        grid: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").GridOptions) => import("./layout").LpdfContainerNode;
-        frame: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").FrameOptions) => import("./layout").LpdfContainerNode;
-        link: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").LinkOptions) => import("./layout").LpdfContainerNode;
-        text: (nodes?: (string | import("./layout").LpdfSpanNode)[], options?: import("./layout").TextOptions) => import("./layout").LpdfTextNode;
-        span: (nodes?: string[], options?: import("./layout").SpanOptions) => import("./layout").LpdfSpanNode;
-        divider: (options?: import("./layout").DividerOptions) => import("./layout").LpdfDividerNode;
-        img: (options: import("./layout").ImgOptions) => import("./layout").LpdfImgNode;
-        barcode: (options: import("./layout").BarcodeOptions) => import("./layout").LpdfBarcodeNode;
-        table: (options: import("./layout").TableOptions, nodes?: (import("./layout").LpdfTheadNode | import("./layout").LpdfTrNode)[]) => import("./layout").LpdfTableNode;
-        thead: (nodes?: import("./layout").LpdfTdNode[], options?: import("./layout").TheadOptions) => import("./layout").LpdfTheadNode;
-        tr: (nodes?: import("./layout").LpdfTdNode[], options?: import("./layout").TrOptions) => import("./layout").LpdfTrNode;
-        td: (nodes?: import("./layout").LpdfNode[], options?: import("./layout").TdOptions) => import("./layout").LpdfTdNode;
-        region: (pin: string, nodes?: import("./layout").LpdfNode[], options?: import("./layout").RegionOptions) => import("./layout").LpdfRegionNode;
-    }>;
-    Canvas: Readonly<{
-        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;
-        text: (x: number, y: number, content: string, style?: import("./canvas").CanvasTextStyle, runs?: import("./canvas").CanvasRun[]) => import("./canvas").LpdfCanvasTextNode;
-        img: (x: number, y: number, w: number, h: number, name: string) => import("./canvas").LpdfCanvasImgNode;
-        layer: (nodes: import("./canvas").LpdfCanvasPrimitiveNode[], options?: import("./canvas").CanvasLayerOptions) => import("./canvas").LpdfCanvasLayerNode;
-    }>;
-}>;
+export { PdfEngine, LpdfRenderError } from './engine';
+export type { EncryptPermissions, EncryptOptions } from './engine';
+export type { RenderOptions, EngineOptions, PageScope } from './_shared';
+export type { PdfDocument, LpdfSectionNode, LpdfLayoutBlock, LpdfCanvasBlock, LpdfTokens, LpdfFontDef, LpdfMeta, SectionAttr, DocumentAttr, } from './kit';
+export type { StackAttr, FlankAttr, SplitAttr, ClusterAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, RegionAttr, } from './layout';
+export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfDividerNode, LpdfImgNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, } from './layout';
+export { CanvasTransform } from './canvas';
+export type { LineCap, LineJoin, TextAlign, LayerAttr, CanvasRun, CanvasRectStyle, CanvasLineStyle, CanvasEllipseStyle, CanvasPathStyle, CanvasTextStyle, LpdfCanvasLayerNode, LpdfCanvasPrimitiveNode, LpdfCanvasRectNode, LpdfCanvasLineNode, LpdfCanvasEllipseNode, LpdfCanvasCircleNode, LpdfCanvasPathNode, LpdfCanvasTextNode, LpdfCanvasImgNode, } from './canvas';
+export { L, NoAttr } from './pdf';

package/dist/index.js

@@ -1,34 +1,14 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Lpdf = exports.kitToXml = void 0;
-__exportStar(require("./engine"), exports);
-__exportStar(require("./kit"), exports);
-__exportStar(require("./layout"), exports);
-__exportStar(require("./canvas"), exports);
-__exportStar(require("./_shared"), exports);
-var kit_to_xml_1 = require("./kit-to-xml");
-Object.defineProperty(exports, "kitToXml", { enumerable: true, get: function () { return kit_to_xml_1.kitToXml; } });
-const engine_1 = require("./engine");
-const kit_1 = require("./kit");
-const layout_1 = require("./layout");
-const canvas_1 = require("./canvas");
-exports.Lpdf = Object.freeze({
-    Engine: engine_1.LpdfEngine,
-    Kit: kit_1.LpdfKit,
-    Layout: layout_1.LpdfLayout,
-    Canvas: canvas_1.LpdfCanvas,
-});
+exports.NoAttr = exports.L = exports.CanvasTransform = exports.LpdfRenderError = exports.PdfEngine = void 0;
+// ── Engine ────────────────────────────────────────────────────────────────────
+var engine_1 = require("./engine");
+Object.defineProperty(exports, "PdfEngine", { enumerable: true, get: function () { return engine_1.PdfEngine; } });
+Object.defineProperty(exports, "LpdfRenderError", { enumerable: true, get: function () { return engine_1.LpdfRenderError; } });
+// ── Canvas types ──────────────────────────────────────────────────────────────
+var canvas_1 = require("./canvas");
+Object.defineProperty(exports, "CanvasTransform", { enumerable: true, get: function () { return canvas_1.CanvasTransform; } });
+// ── Facade ────────────────────────────────────────────────────────────────────
+var pdf_1 = require("./pdf");
+Object.defineProperty(exports, "L", { enumerable: true, get: function () { return pdf_1.L; } });
+Object.defineProperty(exports, "NoAttr", { enumerable: true, get: function () { return pdf_1.NoAttr; } });

package/dist/kit-to-xml.d.ts

@@ -16,7 +16,7 @@
  * console.log(xml);
  * ```
  */
-import type { LpdfDocument } from './kit';
+import type { PdfDocument } from './kit';
 /**
  * Convert an `LpdfDocument` tree (built with `LpdfKit`) into an lpdf XML
  * string.
@@ -27,4 +27,4 @@ import type { LpdfDocument } from './kit';
  * @param doc - The document tree returned by `LpdfKit.document(...)`.
  * @returns A well-formed XML string with an `<?xml ...?>` declaration.
  */
-export declare function kitToXml(doc: LpdfDocument): string;
+export declare function kitToXml(doc: PdfDocument): string;

package/dist/kit.d.ts

@@ -49,7 +49,7 @@ export interface LpdfMeta {
     keywords?: string;
     creator?: string;
 }
-export interface SectionOptions {
+export interface SectionAttr {
     size?: string;
     orientation?: string;
     margin?: string;
@@ -57,7 +57,7 @@ export interface SectionOptions {
     title?: string;
     debug?: string;
 }
-export interface DocumentOptions {
+export interface DocumentAttr {
     size?: string;
     orientation?: string;
     margin?: string;
@@ -81,25 +81,16 @@ export interface LpdfSectionNode {
     attrs: Record<string, string>;
     nodes: (LpdfLayoutBlock | LpdfCanvasBlock)[];
 }
-export interface LpdfDocument {
+export interface PdfDocument {
     version: 1;
     type: 'document';
     attrs: Record<string, unknown>;
     nodes: LpdfSectionNode[];
 }
-export interface SectionInput {
-    nodes?: (LpdfLayoutBlock | LpdfCanvasBlock)[];
-    options?: SectionOptions;
-}
-export interface DocumentInput {
-    /** Sections — serialised as `nodes` on the wire (matching kit_to_xml and parse_tree). */
-    sections?: LpdfSectionNode[];
-    options?: DocumentOptions;
-}
-declare function layout(nodes?: LpdfNode[]): LpdfLayoutBlock;
-declare function canvas(layers?: LpdfCanvasLayerNode[]): LpdfCanvasBlock;
-declare function section(input?: SectionInput): LpdfSectionNode;
-declare function document(input?: DocumentInput): LpdfDocument;
+declare function layout(_attrs: null, nodes: LpdfNode[]): LpdfLayoutBlock;
+declare function canvas(_attrs: null, layers: LpdfCanvasLayerNode[]): LpdfCanvasBlock;
+declare function section(attrs: SectionAttr | null, nodes: (LpdfLayoutBlock | LpdfCanvasBlock)[]): LpdfSectionNode;
+declare function document(attrs: DocumentAttr | null, nodes: LpdfSectionNode[]): PdfDocument;
 export declare const LpdfKit: Readonly<{
     layout: typeof layout;
     canvas: typeof canvas;

package/dist/kit.js

@@ -40,33 +40,33 @@ function buildAttrs(options) {
     return result;
 }
 // ── Factory functions ─────────────────────────────────────────────────────────
-function layout(nodes = []) {
+function layout(_attrs, nodes) {
     return { type: 'layout', nodes };
 }
-function canvas(layers = []) {
+function canvas(_attrs, layers) {
     return { type: 'canvas', nodes: layers };
 }
-function section(input = {}) {
+function section(attrs, nodes) {
     return {
         type: 'section',
-        attrs: buildAttrs((input.options ?? {})),
-        nodes: input.nodes ?? [],
+        attrs: buildAttrs((attrs ?? {})),
+        nodes,
     };
 }
-function document(input = {}) {
-    const { tokens, meta, ...restOpts } = input.options ?? {};
-    const attrs = {
+function document(attrs, nodes) {
+    const { tokens, meta, ...restOpts } = attrs ?? {};
+    const attrsObj = {
         ...buildAttrs(restOpts),
     };
     if (tokens !== undefined)
-        attrs['tokens'] = tokens;
+        attrsObj['tokens'] = tokens;
     if (meta !== undefined)
-        attrs['meta'] = meta;
+        attrsObj['meta'] = meta;
     return {
         version: 1,
         type: 'document',
-        attrs,
-        nodes: input.sections ?? [],
+        attrs: attrsObj,
+        nodes,
     };
 }
 // ── LpdfKit export ────────────────────────────────────────────────────────────

package/dist/layout.d.ts

@@ -1,5 +1,5 @@
 import type { PageScope } from './_shared';
-export interface StackOptions {
+export interface StackAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -11,7 +11,7 @@ export interface StackOptions {
     radius?: string;
     debug?: string;
 }
-export interface FlankOptions {
+export interface FlankAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -24,7 +24,7 @@ export interface FlankOptions {
     radius?: string;
     debug?: string;
 }
-export interface SplitOptions {
+export interface SplitAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -36,7 +36,7 @@ export interface SplitOptions {
     radius?: string;
     debug?: string;
 }
-export interface ClusterOptions {
+export interface ClusterAttr {
     gap?: string;
     padding?: string;
     background?: string;
@@ -48,7 +48,7 @@ export interface ClusterOptions {
     radius?: string;
     debug?: string;
 }
-export interface GridOptions {
+export interface GridAttr {
     cols?: string;
     colWidth?: string;
     gap?: string;
@@ -61,7 +61,7 @@ export interface GridOptions {
     radius?: string;
     debug?: string;
 }
-export interface FrameOptions {
+export interface FrameAttr {
     width?: string;
     height?: string;
     padding?: string;
@@ -71,13 +71,13 @@ export interface FrameOptions {
     align?: string;
     debug?: string;
 }
-export interface LinkOptions {
+export interface LinkAttr {
     url?: string;
     width?: string;
     height?: string;
     debug?: string;
 }
-export interface TableOptions {
+export interface TableAttr {
     cols: string;
     border?: string;
     stripe?: string;
@@ -89,13 +89,13 @@ export interface TableOptions {
     repeat?: string;
     debug?: string;
 }
-export interface TheadOptions {
+export interface TheadAttr {
     background?: string;
 }
-export interface TrOptions {
+export interface TrAttr {
     background?: string;
 }
-export interface TdOptions {
+export interface TdAttr {
     padding?: string;
     background?: string;
     align?: string;
@@ -105,7 +105,7 @@ export interface TdOptions {
     gap?: string;
     debug?: string;
 }
-export interface TextOptions {
+export interface TextAttr {
     font?: string;
     fontSize?: string;
     textAlign?: string;
@@ -121,7 +121,7 @@ export interface TextOptions {
     repeat?: string;
     debug?: string;
 }
-export interface SpanOptions {
+export interface SpanAttr {
     font?: string;
     fontSize?: string;
     color?: string;
@@ -130,13 +130,13 @@ export interface SpanOptions {
     underline?: string;
     strike?: string;
 }
-export interface DividerOptions {
+export interface DividerAttr {
     color?: string;
     thickness?: string;
     direction?: string;
     debug?: string;
 }
-export interface ImgOptions {
+export interface ImgAttr {
     name: string;
     height?: string;
     width?: string;
@@ -150,7 +150,7 @@ export interface ImgOptions {
     repeat?: string;
     debug?: string;
 }
-export interface BarcodeOptions {
+export interface BarcodeAttr {
     type: string;
     data: string;
     size?: string;
@@ -163,7 +163,8 @@ export interface BarcodeOptions {
     repeat?: string;
     debug?: string;
 }
-export interface RegionOptions {
+export interface RegionAttr {
+    pin: string;
     page?: PageScope | string;
     w?: string;
     debug?: string;
@@ -221,23 +222,23 @@ export interface LpdfRegionNode {
     nodes: LpdfNode[];
 }
 export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode;
-declare function stack(nodes?: LpdfNode[], options?: StackOptions): LpdfContainerNode;
-declare function flank(nodes?: LpdfNode[], options?: FlankOptions): LpdfContainerNode;
-declare function split(nodes?: LpdfNode[], options?: SplitOptions): LpdfContainerNode;
-declare function cluster(nodes?: LpdfNode[], options?: ClusterOptions): LpdfContainerNode;
-declare function grid(nodes?: LpdfNode[], options?: GridOptions): LpdfContainerNode;
-declare function frame(nodes?: LpdfNode[], options?: FrameOptions): LpdfContainerNode;
-declare function link(nodes?: LpdfNode[], options?: LinkOptions): LpdfContainerNode;
-declare function table(options: TableOptions, nodes?: (LpdfTheadNode | LpdfTrNode)[]): LpdfTableNode;
-declare function thead(nodes?: LpdfTdNode[], options?: TheadOptions): LpdfTheadNode;
-declare function tr(nodes?: LpdfTdNode[], options?: TrOptions): LpdfTrNode;
-declare function td(nodes?: LpdfNode[], options?: TdOptions): LpdfTdNode;
-declare function text(nodes?: (string | LpdfSpanNode)[], options?: TextOptions): LpdfTextNode;
-declare function span(nodes?: string[], options?: SpanOptions): LpdfSpanNode;
-declare function divider(options?: DividerOptions): LpdfDividerNode;
-declare function img(options: ImgOptions): LpdfImgNode;
-declare function barcode(options: BarcodeOptions): LpdfBarcodeNode;
-declare function region(pin: string, nodes?: LpdfNode[], options?: RegionOptions): LpdfRegionNode;
+declare function stack(attrs: StackAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function flank(attrs: FlankAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function split(attrs: SplitAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function cluster(attrs: ClusterAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function grid(attrs: GridAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function frame(attrs: FrameAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function link(attrs: LinkAttr | null, nodes: LpdfNode[]): LpdfContainerNode;
+declare function table(attrs: TableAttr, nodes: (LpdfTheadNode | LpdfTrNode)[]): LpdfTableNode;
+declare function thead(attrs: TheadAttr | null, nodes: LpdfTdNode[]): LpdfTheadNode;
+declare function tr(attrs: TrAttr | null, nodes: LpdfTdNode[]): LpdfTrNode;
+declare function td(attrs: TdAttr | null, nodes: LpdfNode[]): LpdfTdNode;
+declare function text(attrs: TextAttr | null, nodes: (string | LpdfSpanNode)[]): LpdfTextNode;
+declare function span(attrs: SpanAttr | null, nodes: string[]): LpdfSpanNode;
+declare function divider(attrs: DividerAttr | null): LpdfDividerNode;
+declare function img(attrs: ImgAttr): LpdfImgNode;
+declare function barcode(attrs: BarcodeAttr): LpdfBarcodeNode;
+declare function region(attrs: RegionAttr, nodes: LpdfNode[]): LpdfRegionNode;
 export declare const LpdfLayout: Readonly<{
     stack: typeof stack;
     flank: typeof flank;

package/dist/layout.js

@@ -15,100 +15,100 @@ function buildAttrs(options) {
     return result;
 }
 // ── Helper ────────────────────────────────────────────────────────────────────
-function makeContainer(type, nodes, options) {
-    return { type, attrs: buildAttrs(options ?? {}), nodes };
+function makeContainer(type, attrs, nodes) {
+    return { type, attrs: buildAttrs(attrs ?? {}), nodes };
 }
 // ── LpdfLayout factory ────────────────────────────────────────────────────────
-function stack(nodes = [], options) {
-    return makeContainer('stack', nodes, options);
+function stack(attrs, nodes) {
+    return makeContainer('stack', attrs, nodes);
 }
-function flank(nodes = [], options) {
-    return makeContainer('flank', nodes, options);
+function flank(attrs, nodes) {
+    return makeContainer('flank', attrs, nodes);
 }
-function split(nodes = [], options) {
-    return makeContainer('split', nodes, options);
+function split(attrs, nodes) {
+    return makeContainer('split', attrs, nodes);
 }
-function cluster(nodes = [], options) {
-    return makeContainer('cluster', nodes, options);
+function cluster(attrs, nodes) {
+    return makeContainer('cluster', attrs, nodes);
 }
-function grid(nodes = [], options) {
-    return makeContainer('grid', nodes, options);
+function grid(attrs, nodes) {
+    return makeContainer('grid', attrs, nodes);
 }
-function frame(nodes = [], options) {
-    return makeContainer('frame', nodes, options);
+function frame(attrs, nodes) {
+    return makeContainer('frame', attrs, nodes);
 }
-function link(nodes = [], options) {
-    return makeContainer('link', nodes, options);
+function link(attrs, nodes) {
+    return makeContainer('link', attrs, nodes);
 }
-function table(options, nodes = []) {
+function table(attrs, nodes) {
     return {
         type: 'table',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
         nodes,
     };
 }
-function thead(nodes = [], options) {
+function thead(attrs, nodes) {
     return {
         type: 'thead',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function tr(nodes = [], options) {
+function tr(attrs, nodes) {
     return {
         type: 'tr',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function td(nodes = [], options) {
+function td(attrs, nodes) {
     return {
         type: 'td',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function text(nodes = [], options) {
+function text(attrs, nodes) {
     return {
         type: 'text',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function span(nodes = [], options) {
+function span(attrs, nodes) {
     return {
         type: 'span',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
         nodes,
     };
 }
-function divider(options) {
+function divider(attrs) {
     return {
         type: 'divider',
-        attrs: buildAttrs((options ?? {})),
+        attrs: buildAttrs((attrs ?? {})),
     };
 }
-function img(options) {
+function img(attrs) {
     return {
         type: 'img',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
     };
 }
-function barcode(options) {
+function barcode(attrs) {
     return {
         type: 'barcode',
-        attrs: buildAttrs(options),
+        attrs: buildAttrs(attrs),
     };
 }
-function region(pin, nodes = [], options) {
-    const attrs = { pin };
-    if (options?.page !== undefined)
-        attrs['page'] = options.page;
-    if (options?.w !== undefined)
-        attrs['w'] = options.w;
-    if (options?.debug !== undefined)
-        attrs['debug'] = options.debug;
-    return { type: 'layout-region', attrs, nodes };
+function region(attrs, nodes) {
+    const a = { pin: attrs.pin };
+    if (attrs.page !== undefined)
+        a['page'] = attrs.page;
+    if (attrs.w !== undefined)
+        a['w'] = attrs.w;
+    if (attrs.debug !== undefined)
+        a['debug'] = attrs.debug;
+    return { type: 'layout-region', attrs: a, nodes };
 }
 exports.LpdfLayout = Object.freeze({
     stack,

package/dist/pdf.d.ts

@@ -0,0 +1,61 @@
+import type { 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;
+    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;
+    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) => import("./canvas").LpdfCanvasImgNode;
+}>;

package/dist/pdf.js

@@ -0,0 +1,70 @@
+"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,
+    // ── 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,
+    // ── 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lpdfio/lpdf",
-  "version": "0.6.0",
-  "description": "Node.js adapter for Lpdf — 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.",
+  "version": "0.7.0",
+  "description": "Node.js SDK for Lpdf — PDF as Code on every platform. You describe a document as code or XML. Lpdf renders a compact, pixel-perfect PDF — identical across platforms.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {