@lpdfio/lpdf 0.7.0 → 0.10.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

@@ -1,4 +1,4 @@
-<p align="center"><img src="lpdf-light.png" height="48" alt="Lpdf"></p>
+<img src="lpdf-mark.svg" height="48" alt="Lpdf - PDF as Code" />
 
 # @lpdfio/lpdf
 

package/dist/{pdf.d.ts → L.d.ts}

@@ -1,4 +1,4 @@
-import type { PdfDocument } from './kit';
+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;
@@ -33,6 +33,7 @@ export declare const L: Readonly<{
     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;
@@ -50,6 +51,7 @@ export declare const L: Readonly<{
     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;
@@ -57,5 +59,5 @@ export declare const L: Readonly<{
     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;
+    imgAt: (x: number, y: number, w: number, h: number, name: string, anchor?: string) => import("./canvas").LpdfCanvasImgNode;
 }>;

package/dist/{pdf.js → L.js}

@@ -40,6 +40,7 @@ exports.L = Object.freeze({
     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,
@@ -58,6 +59,7 @@ exports.L = Object.freeze({
     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,

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;
@@ -118,7 +125,7 @@ declare function ellipse(cx: number, cy: number, rx: number, ry: number, style?:
 declare function circle(cx: number, cy: number, r: number, style?: CanvasEllipseStyle): LpdfCanvasCircleNode;
 declare function path(d: string, style?: CanvasPathStyle): LpdfCanvasPathNode;
 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 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;

package/dist/canvas.js

@@ -60,6 +60,10 @@ function rect(x, y, w, h, style) {
         attrs['stroke-dash'] = style.strokeDash.join(' ');
     if (style?.borderRadius !== undefined)
         attrs['radius'] = String(style.borderRadius);
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     return { type: 'canvas-rect', attrs };
 }
 function line(x1, y1, x2, y2, style) {
@@ -90,6 +94,10 @@ function ellipse(cx, cy, rx, ry, style) {
         attrs['stroke-width'] = String(style.strokeWidth);
     if (style?.strokeDash !== undefined)
         attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     return { type: 'canvas-ellipse', attrs };
 }
 function circle(cx, cy, r, style) {
@@ -104,6 +112,10 @@ function circle(cx, cy, r, style) {
         attrs['stroke-width'] = String(style.strokeWidth);
     if (style?.strokeDash !== undefined)
         attrs['stroke-dash'] = style.strokeDash.join(' ');
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     return { type: 'canvas-circle', attrs };
 }
 function path(d, style) {
@@ -122,6 +134,8 @@ function path(d, style) {
         attrs['line-cap'] = style.lineCap;
     if (style?.lineJoin !== undefined)
         attrs['line-join'] = style.lineJoin;
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
     return { type: 'canvas-path', attrs };
 }
 function textAt(x, y, content, style, runs) {
@@ -138,6 +152,10 @@ function textAt(x, y, content, style, runs) {
         attrs['line-height'] = String(style.lineHeight);
     if (style?.width !== undefined)
         attrs['w'] = String(style.width);
+    if (style?.opacity !== undefined)
+        attrs['opacity'] = String(style.opacity);
+    if (style?.anchor !== undefined)
+        attrs['anchor'] = style.anchor;
     const node = { type: 'canvas-text', text: content, attrs };
     if (runs && runs.length > 0) {
         node.runs = runs.map(r => {
@@ -153,11 +171,11 @@ function textAt(x, y, content, style, runs) {
     }
     return node;
 }
-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 imgAt(x, y, w, h, name, anchor) {
+    const attrs = { x: String(x), y: String(y), w: String(w), h: String(h), name };
+    if (anchor !== undefined)
+        attrs['anchor'] = anchor;
+    return { type: 'canvas-img', attrs };
 }
 function layer(attrs, nodes) {
     const a = {};

package/dist/index.d.ts

@@ -2,8 +2,8 @@ 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 type { StackAttr, FlankAttr, SplitAttr, ClusterAttr, GridAttr, FrameAttr, LinkAttr, TableAttr, TheadAttr, TrAttr, TdAttr, TextAttr, SpanAttr, DividerAttr, ImgAttr, BarcodeAttr, RegionAttr, FieldAttr, } from './layout';
+export type { LpdfNode, LpdfContainerNode, LpdfTextNode, LpdfSpanNode, LpdfDividerNode, LpdfImgNode, LpdfBarcodeNode, LpdfTableNode, LpdfTheadNode, LpdfTrNode, LpdfTdNode, LpdfRegionNode, LpdfFieldNode, } 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';
+export { L, NoAttr } from './L';

package/dist/index.js

@@ -9,6 +9,6 @@ Object.defineProperty(exports, "LpdfRenderError", { enumerable: true, get: funct
 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; } });
+var L_1 = require("./L");
+Object.defineProperty(exports, "L", { enumerable: true, get: function () { return L_1.L; } });
+Object.defineProperty(exports, "NoAttr", { enumerable: true, get: function () { return L_1.NoAttr; } });

package/dist/kit.d.ts

@@ -32,7 +32,7 @@ export interface LpdfTokens {
     border?: Record<string, string>;
     radius?: Record<string, string>;
     width?: Record<string, string>;
-    text?: Record<string, string>;
+    textSize?: Record<string, string>;
     fonts?: Record<string, LpdfFontDef>;
 }
 export type LpdfFontDef = {

package/dist/kit.js

@@ -58,8 +58,10 @@ function document(attrs, nodes) {
     const attrsObj = {
         ...buildAttrs(restOpts),
     };
-    if (tokens !== undefined)
-        attrsObj['tokens'] = tokens;
+    if (tokens !== undefined) {
+        const { textSize, ...rest } = tokens;
+        attrsObj['tokens'] = textSize !== undefined ? { 'text-size': textSize, ...rest } : rest;
+    }
     if (meta !== undefined)
         attrsObj['meta'] = meta;
     return {

package/dist/layout.d.ts

@@ -73,6 +73,7 @@ export interface FrameAttr {
 }
 export interface LinkAttr {
     url?: string;
+    gap?: string;
     width?: string;
     height?: string;
     debug?: string;
@@ -163,6 +164,20 @@ export interface BarcodeAttr {
     repeat?: string;
     debug?: string;
 }
+export interface FieldAttr {
+    label?: string;
+    value?: string;
+    options?: string;
+    group?: string;
+    checked?: string;
+    required?: string;
+    readonly?: string;
+    maxLen?: string;
+    actionUrl?: string;
+    width?: string;
+    height?: string;
+    debug?: string;
+}
 export interface RegionAttr {
     pin: string;
     page?: PageScope | string;
@@ -221,7 +236,11 @@ export interface LpdfRegionNode {
     attrs: Record<string, string>;
     nodes: LpdfNode[];
 }
-export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode;
+export interface LpdfFieldNode {
+    type: 'field';
+    attrs: Record<string, string>;
+}
+export type LpdfNode = LpdfContainerNode | LpdfTextNode | LpdfDividerNode | LpdfTableNode | LpdfImgNode | LpdfBarcodeNode | LpdfRegionNode | LpdfFieldNode;
 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;
@@ -239,6 +258,7 @@ 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;
+declare function field(type: string, name: string, attrs?: FieldAttr | null): LpdfFieldNode;
 export declare const LpdfLayout: Readonly<{
     stack: typeof stack;
     flank: typeof flank;
@@ -257,5 +277,6 @@ export declare const LpdfLayout: Readonly<{
     tr: typeof tr;
     td: typeof td;
     region: typeof region;
+    field: typeof field;
 }>;
 export {};

package/dist/layout.js

@@ -110,6 +110,12 @@ function region(attrs, nodes) {
         a['debug'] = attrs.debug;
     return { type: 'layout-region', attrs: a, nodes };
 }
+function field(type, name, attrs) {
+    const a = { type, name };
+    if (attrs)
+        Object.assign(a, buildAttrs(attrs));
+    return { type: 'field', attrs: a };
+}
 exports.LpdfLayout = Object.freeze({
     stack,
     flank,
@@ -128,4 +134,5 @@ exports.LpdfLayout = Object.freeze({
     tr,
     td,
     region,
+    field,
 });

package/dist/wasm/lpdf-web.js

@@ -205,6 +205,79 @@ export class LpdfEngine {
 }
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
 
+/**
+ * Generate SDK source code from one or more bare Lpdf XML elements (a fragment).
+ *
+ * Unlike `codegen_wasm`, this accepts a snippet without the `<lpdf>` wrapper and
+ * returns just the node expression(s) — no imports, no engine setup, no boilerplate.
+ * Ideal for documentation code examples where the same XML snippet should be shown
+ * in multiple target languages.
+ *
+ * `options_json` accepts the same shape as `codegen_wasm`:
+ * - `target`: `"js"`, `"dotnet"`, `"php"`, or `"python"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function codegen_fragment_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_fragment_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
+/**
+ * Generate SDK source code from an Lpdf XML string.
+ *
+ * `options_json` is a JSON object with:
+ * - `target`: `"js"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ *
+ * Returns the generated source code as a string.
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function codegen_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 /**
  * Convert a JSON kit-tree (produced by `LpdfKit` in any adapter) to an lpdf
  * XML string.

package/dist/wasm/lpdf.js

@@ -206,6 +206,81 @@ class LpdfEngine {
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
 exports.LpdfEngine = LpdfEngine;
 
+/**
+ * Generate SDK source code from one or more bare Lpdf XML elements (a fragment).
+ *
+ * Unlike `codegen_wasm`, this accepts a snippet without the `<lpdf>` wrapper and
+ * returns just the node expression(s) — no imports, no engine setup, no boilerplate.
+ * Ideal for documentation code examples where the same XML snippet should be shown
+ * in multiple target languages.
+ *
+ * `options_json` accepts the same shape as `codegen_wasm`:
+ * - `target`: `"js"`, `"dotnet"`, `"php"`, or `"python"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+function codegen_fragment_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_fragment_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.codegen_fragment_wasm = codegen_fragment_wasm;
+
+/**
+ * Generate SDK source code from an Lpdf XML string.
+ *
+ * `options_json` is a JSON object with:
+ * - `target`: `"js"` (required)
+ * - `indent`: `2` or `4` (optional, default `4`)
+ *
+ * Returns the generated source code as a string.
+ * @param {string} xml
+ * @param {string} options_json
+ * @returns {string}
+ */
+function codegen_wasm(xml, options_json) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(xml, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.codegen_wasm(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.codegen_wasm = codegen_wasm;
+
 /**
  * Convert a JSON kit-tree (produced by `LpdfKit` in any adapter) to an lpdf
  * XML string.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lpdfio/lpdf",
-  "version": "0.7.0",
+  "version": "0.10.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",