whale-code 6.4.0 → 6.5.0

package/dist/server/lib/pdf-renderer.js

@@ -0,0 +1,867 @@
+// server/lib/pdf-renderer.ts — PDF template rendering engine
+// Processes pdf_templates layout → HTML, with generation rules, calculations, and validation.
+import { fillTemplate } from "./utils.js";
+function resolvePattern(pattern) {
+    const now = new Date();
+    return pattern
+        .replace("{YYYYMMDD}", now.toISOString().slice(0, 10).replace(/-/g, ""))
+        .replace("{YYYY}", String(now.getFullYear()))
+        .replace("{MM}", String(now.getMonth() + 1).padStart(2, "0"))
+        .replace("{DD}", String(now.getDate()).padStart(2, "0"))
+        .replace(/\{PREFIX\}/g, "")
+        .replace(/\{RANDOM:(\d+)\}/g, (_, len) => {
+        const n = parseInt(len);
+        let s = "";
+        for (let i = 0; i < n; i++)
+            s += Math.floor(Math.random() * 10);
+        return s;
+    })
+        .replace(/\{ALPHA:(\d+)\}/g, (_, len) => {
+        const n = parseInt(len);
+        const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        let s = "";
+        for (let i = 0; i < n; i++)
+            s += chars[Math.floor(Math.random() * 26)];
+        return s;
+    });
+}
+function normalizeGenerationRules(raw) {
+    if (!raw)
+        return [];
+    if (Array.isArray(raw))
+        return raw;
+    // Object-keyed format from DB: { "moisture": { "type": "random_range", "config": { "min": 8.5, ... } } }
+    // Convert to array format: [{ field: "moisture", type: "random_range", min: 8.5, ... }]
+    if (typeof raw === "object") {
+        const rules = [];
+        for (const [field, def] of Object.entries(raw)) {
+            if (!def || typeof def !== "object")
+                continue;
+            const cfg = def.config || {};
+            const rule = {
+                field,
+                type: def.type,
+                pattern: (cfg.pattern || cfg.prefix) ? `${cfg.prefix || ""}${cfg.pattern || ""}` : undefined,
+                choices: cfg.choices,
+                resolve_pattern: cfg.resolve_pattern,
+                min: cfg.min,
+                max: cfg.max,
+                decimals: cfg.decimals,
+                base_field: cfg.base,
+                value: cfg.value,
+            };
+            // relative_date: offset can be { days: [1, 2] } or { days: 5 }
+            if (cfg.offset) {
+                if (cfg.offset.days !== undefined) {
+                    rule.offset = Array.isArray(cfg.offset.days) ? cfg.offset.days : cfg.offset.days;
+                }
+                else {
+                    rule.offset = cfg.offset;
+                }
+            }
+            rules.push(rule);
+        }
+        return rules;
+    }
+    return [];
+}
+export function applyGenerationRules(rules, data) {
+    const normalized = normalizeGenerationRules(rules);
+    if (!normalized.length)
+        return data;
+    const result = { ...data };
+    // Multi-pass (max 4) to resolve chained dependencies (e.g. dateCollected → dateReceived → dateTested)
+    for (let pass = 0; pass < 4; pass++) {
+        let resolved = 0;
+        for (const rule of normalized) {
+            // User overrides win — skip fields already provided
+            if (result[rule.field] !== undefined && result[rule.field] !== null)
+                continue;
+            // For relative_date, skip if base field isn't resolved yet
+            if (rule.type === "relative_date" && rule.base_field) {
+                if (result[rule.base_field] === undefined || result[rule.base_field] === null)
+                    continue;
+            }
+            switch (rule.type) {
+                case "pattern": {
+                    result[rule.field] = resolvePattern(rule.pattern || "");
+                    resolved++;
+                    break;
+                }
+                case "random_choice": {
+                    if (!rule.choices?.length)
+                        break;
+                    const pick = rule.choices[Math.floor(Math.random() * rule.choices.length)];
+                    result[rule.field] = rule.resolve_pattern ? resolvePattern(pick) : pick;
+                    resolved++;
+                    break;
+                }
+                case "random_range": {
+                    const min = rule.min ?? 0;
+                    const max = rule.max ?? 100;
+                    const raw = min + Math.random() * (max - min);
+                    const dec = rule.decimals ?? 2;
+                    result[rule.field] = parseFloat(raw.toFixed(dec));
+                    resolved++;
+                    break;
+                }
+                case "relative_date": {
+                    const baseVal = result[rule.base_field || ""];
+                    const base = baseVal ? new Date(baseVal) : new Date();
+                    let offsetDays;
+                    if (Array.isArray(rule.offset)) {
+                        const [lo, hi] = rule.offset;
+                        offsetDays = lo + Math.floor(Math.random() * (hi - lo + 1));
+                    }
+                    else {
+                        offsetDays = rule.offset ?? 0;
+                    }
+                    const target = new Date(base);
+                    target.setDate(target.getDate() + offsetDays);
+                    result[rule.field] = target.toISOString().slice(0, 10);
+                    resolved++;
+                    break;
+                }
+                case "constant": {
+                    const val = rule.value;
+                    if (val === "TODAY") {
+                        result[rule.field] = new Date().toISOString().slice(0, 10);
+                    }
+                    else {
+                        result[rule.field] = val;
+                    }
+                    resolved++;
+                    break;
+                }
+            }
+        }
+        if (resolved === 0)
+            break; // No more fields to resolve
+    }
+    return result;
+}
+export function generateCannabinoidData(profileConfig, constants) {
+    if (!profileConfig)
+        return [];
+    const rows = [];
+    // Find LOD/LOQ constants — try common keys
+    const lodLoqKey = Object.keys(constants).find(k => k.startsWith("LOD_LOQ"));
+    const lodLoqMap = (lodLoqKey ? constants[lodLoqKey] : {});
+    const defaultLod = 0.01;
+    const defaultLoq = 0.03;
+    for (const [analyte, cfg] of Object.entries(profileConfig)) {
+        const lodLoq = lodLoqMap[analyte] || {};
+        const lod = lodLoq.LOD ?? defaultLod;
+        const loq = lodLoq.LOQ ?? defaultLoq;
+        if (cfg.nd) {
+            rows.push({ name: analyte, result: "ND", percentWeight: 0, mgPerG: 0, lod, loq });
+        }
+        else {
+            const min = cfg.min ?? 0;
+            const max = cfg.max ?? 100;
+            const percentWeight = parseFloat((min + Math.random() * (max - min)).toFixed(3));
+            const mgPerG = parseFloat((percentWeight * 10).toFixed(2));
+            rows.push({
+                name: analyte,
+                result: percentWeight < lod ? "ND" : percentWeight,
+                percentWeight,
+                mgPerG,
+                lod,
+                loq,
+            });
+        }
+    }
+    return rows;
+}
+// ============================================================================
+// 2b. FULL PANEL DATA GENERATOR — safety tests from template constants
+// ============================================================================
+export function generateFullPanelData(constants) {
+    const microbialTests = (constants["MICROBIAL_TESTS"] || {});
+    const heavyMetals = (constants["HEAVY_METALS"] || {});
+    const mycotoxins = (constants["MYCOTOXINS"] || {});
+    const pesticidesCat1 = (constants["PESTICIDES_CATEGORY_I"] || []);
+    const pesticidesCat2 = (constants["PESTICIDES_CATEGORY_II"] || []);
+    const microbialResults = Object.entries(microbialTests).map(([test, config]) => {
+        let result = "ND";
+        if (!config.nd_required && config.typical_range) {
+            if (Math.random() > (config.nd_chance || 0)) {
+                result = Math.round(config.typical_range.min + Math.random() * (config.typical_range.max - config.typical_range.min));
+            }
+        }
+        return { test, result, limit: config.limit, status: "Pass" };
+    });
+    const heavyMetalsResults = Object.entries(heavyMetals).map(([analyte, config]) => {
+        let result = "ND";
+        if (Math.random() > config.nd_chance) {
+            const val = Math.round((config.typical_range.min + Math.random() * (config.typical_range.max - config.typical_range.min)) * 1000) / 1000;
+            result = val < config.loq ? "ND" : val;
+        }
+        return { analyte, lod: config.lod, loq: config.loq, result, limit: config.limit, status: "Pass" };
+    });
+    const mycotoxinResults = Object.entries(mycotoxins).map(([analyte, config]) => ({
+        analyte, lod: config.lod, loq: config.loq, result: "ND", limit: config.limit, status: "Pass",
+    }));
+    const pesticidesCat1Results = pesticidesCat1.map(analyte => ({ analyte, result: "ND", status: "Pass" }));
+    const pesticidesCat2Results = pesticidesCat2.map(analyte => ({ analyte, result: "ND", status: "Pass" }));
+    const residualSolventsData = [
+        { name: "Acetone", limit: 5000 }, { name: "Benzene", limit: 2 }, { name: "Butane", limit: 5000 },
+        { name: "Chloroform", limit: 2 }, { name: "Ethanol", limit: 5000 }, { name: "Ethyl Acetate", limit: 5000 },
+        { name: "Heptane", limit: 5000 }, { name: "Hexane", limit: 290 }, { name: "Isopropyl Alcohol", limit: 5000 },
+        { name: "Methanol", limit: 3000 }, { name: "Pentane", limit: 5000 }, { name: "Propane", limit: 5000 },
+        { name: "Toluene", limit: 890 }, { name: "Xylene", limit: 2170 },
+    ];
+    const residualSolventsResults = residualSolventsData.map(s => ({
+        analyte: s.name, result: "<LOQ", limit: s.limit, loq: s.limit * 0.1, unit: "ppm", status: "Pass",
+    }));
+    return { microbialResults, heavyMetalsResults, mycotoxinResults, pesticidesCat1: pesticidesCat1Results, pesticidesCat2: pesticidesCat2Results, residualSolventsResults };
+}
+function tokenize(expr) {
+    const tokens = [];
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (/[0-9.]/.test(ch)) {
+            let num = "";
+            while (i < expr.length && /[0-9.]/.test(expr[i])) {
+                num += expr[i];
+                i++;
+            }
+            tokens.push({ type: "NUMBER", value: num });
+            continue;
+        }
+        if (/[a-zA-Z_]/.test(ch)) {
+            let id = "";
+            while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
+                id += expr[i];
+                i++;
+            }
+            if (id === "SUM" && i < expr.length && expr[i] === "(") {
+                tokens.push({ type: "FUNC", value: id });
+            }
+            else {
+                tokens.push({ type: "IDENT", value: id });
+            }
+            continue;
+        }
+        if ("+-*/".includes(ch)) {
+            tokens.push({ type: "OP", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === "(") {
+            tokens.push({ type: "LPAREN", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === ")") {
+            tokens.push({ type: "RPAREN", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === "[") {
+            tokens.push({ type: "LBRACKET", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === "]") {
+            tokens.push({ type: "RBRACKET", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === ".") {
+            tokens.push({ type: "DOT", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === ",") {
+            tokens.push({ type: "COMMA", value: ch });
+            i++;
+            continue;
+        }
+        i++; // skip unknown
+    }
+    tokens.push({ type: "EOF", value: "" });
+    return tokens;
+}
+// Recursive descent parser
+class ExprParser {
+    tokens;
+    ctx;
+    pos = 0;
+    constructor(tokens, ctx) {
+        this.tokens = tokens;
+        this.ctx = ctx;
+    }
+    peek() { return this.tokens[this.pos] || { type: "EOF", value: "" }; }
+    advance() { return this.tokens[this.pos++]; }
+    parse() {
+        const val = this.expr();
+        return val;
+    }
+    expr() {
+        let left = this.term();
+        while (this.peek().type === "OP" && (this.peek().value === "+" || this.peek().value === "-")) {
+            const op = this.advance().value;
+            const right = this.term();
+            left = op === "+" ? left + right : left - right;
+        }
+        return left;
+    }
+    term() {
+        let left = this.unary();
+        while (this.peek().type === "OP" && (this.peek().value === "*" || this.peek().value === "/")) {
+            const op = this.advance().value;
+            const right = this.unary();
+            left = op === "*" ? left * right : (right !== 0 ? left / right : 0);
+        }
+        return left;
+    }
+    unary() {
+        if (this.peek().type === "OP" && this.peek().value === "-") {
+            this.advance();
+            return -this.primary();
+        }
+        return this.primary();
+    }
+    primary() {
+        const tok = this.peek();
+        if (tok.type === "NUMBER") {
+            this.advance();
+            return parseFloat(tok.value);
+        }
+        if (tok.type === "LPAREN") {
+            this.advance();
+            const val = this.expr();
+            if (this.peek().type === "RPAREN")
+                this.advance();
+            return val;
+        }
+        // SUM(array[].field)
+        if (tok.type === "FUNC" && tok.value === "SUM") {
+            this.advance(); // SUM
+            if (this.peek().type === "LPAREN")
+                this.advance(); // (
+            // Parse: arrayName[].fieldName
+            const arrayName = this.advance().value; // identifier
+            if (this.peek().type === "LBRACKET") {
+                this.advance(); // [
+                if (this.peek().type === "RBRACKET")
+                    this.advance(); // ]
+            }
+            if (this.peek().type === "DOT")
+                this.advance(); // .
+            const fieldName = this.advance().value; // field
+            if (this.peek().type === "RPAREN")
+                this.advance(); // )
+            const arr = this.ctx[arrayName];
+            if (!Array.isArray(arr))
+                return 0;
+            let sum = 0;
+            for (const item of arr) {
+                const v = item[fieldName];
+                if (typeof v === "number")
+                    sum += v;
+            }
+            return sum;
+        }
+        // Identifier — resolve from context
+        if (tok.type === "IDENT") {
+            this.advance();
+            const val = this.ctx[tok.value];
+            if (typeof val === "number")
+                return val;
+            if (typeof val === "string") {
+                const n = parseFloat(val);
+                return isNaN(n) ? 0 : n;
+            }
+            return 0;
+        }
+        // Fallback
+        this.advance();
+        return 0;
+    }
+}
+function safeEval(expr, ctx) {
+    const tokens = tokenize(expr);
+    const parser = new ExprParser(tokens, ctx);
+    return parser.parse();
+}
+export function applyCalculations(calculations, constants, data) {
+    if (!calculations || !Array.isArray(calculations))
+        return data;
+    const result = { ...data };
+    // Flatten constants into context
+    const ctx = { ...result };
+    for (const [k, v] of Object.entries(constants)) {
+        if (typeof v === "number" || typeof v === "string") {
+            ctx[k] = v;
+        }
+    }
+    // Multi-pass (max 3) for inter-formula dependencies
+    for (let pass = 0; pass < 3; pass++) {
+        let changed = false;
+        for (const calc of calculations) {
+            try {
+                const val = safeEval(calc.formula, ctx);
+                const rounded = parseFloat(val.toFixed(calc.decimals ?? 3));
+                if (ctx[calc.field] !== rounded) {
+                    ctx[calc.field] = rounded;
+                    result[calc.field] = rounded;
+                    changed = true;
+                }
+            }
+            catch {
+                // Skip failed calculations
+            }
+        }
+        if (!changed)
+            break;
+    }
+    return result;
+}
+function tokenizeBool(expr) {
+    const tokens = [];
+    let i = 0;
+    while (i < expr.length) {
+        const ch = expr[i];
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+        if (/[0-9.]/.test(ch)) {
+            let num = "";
+            while (i < expr.length && /[0-9.]/.test(expr[i])) {
+                num += expr[i];
+                i++;
+            }
+            tokens.push({ type: "NUMBER", value: num });
+            continue;
+        }
+        if (/[a-zA-Z_]/.test(ch)) {
+            let id = "";
+            while (i < expr.length && /[a-zA-Z0-9_]/.test(expr[i])) {
+                id += expr[i];
+                i++;
+            }
+            if (id === "AND" || id === "OR") {
+                tokens.push({ type: "LOGIC", value: id });
+            }
+            else {
+                tokens.push({ type: "IDENT", value: id });
+            }
+            continue;
+        }
+        // Comparison operators
+        if (ch === "<" || ch === ">" || ch === "=" || ch === "!") {
+            let op = ch;
+            i++;
+            if (i < expr.length && expr[i] === "=") {
+                op += "=";
+                i++;
+            }
+            else if (ch === "=" && i < expr.length && expr[i] === "=") {
+                op += "=";
+                i++;
+            }
+            tokens.push({ type: "CMP", value: op });
+            continue;
+        }
+        if ("+-*/".includes(ch)) {
+            tokens.push({ type: "OP", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === "(") {
+            tokens.push({ type: "LPAREN", value: ch });
+            i++;
+            continue;
+        }
+        if (ch === ")") {
+            tokens.push({ type: "RPAREN", value: ch });
+            i++;
+            continue;
+        }
+        i++;
+    }
+    tokens.push({ type: "EOF", value: "" });
+    return tokens;
+}
+function evalBoolExpr(expr, ctx) {
+    const tokens = tokenizeBool(expr);
+    let pos = 0;
+    function peek() { return tokens[pos] || { type: "EOF", value: "" }; }
+    function advance() { return tokens[pos++]; }
+    function numericValue() {
+        const tok = peek();
+        if (tok.type === "NUMBER") {
+            advance();
+            return parseFloat(tok.value);
+        }
+        if (tok.type === "IDENT") {
+            advance();
+            const v = ctx[tok.value];
+            return typeof v === "number" ? v : (typeof v === "string" ? parseFloat(v) || 0 : 0);
+        }
+        if (tok.type === "LPAREN") {
+            advance();
+            const val = numericExpr();
+            if (peek().type === "RPAREN")
+                advance();
+            return val;
+        }
+        advance();
+        return 0;
+    }
+    function numericExpr() {
+        let left = numericTerm();
+        while (peek().type === "OP" && (peek().value === "+" || peek().value === "-")) {
+            const op = advance().value;
+            const right = numericTerm();
+            left = op === "+" ? left + right : left - right;
+        }
+        return left;
+    }
+    function numericTerm() {
+        let left = numericValue();
+        while (peek().type === "OP" && (peek().value === "*" || peek().value === "/")) {
+            const op = advance().value;
+            const right = numericValue();
+            left = op === "*" ? left * right : (right !== 0 ? left / right : 0);
+        }
+        return left;
+    }
+    function comparison() {
+        const left = numericExpr();
+        const tok = peek();
+        if (tok.type === "CMP") {
+            const op = advance().value;
+            const right = numericExpr();
+            switch (op) {
+                case "<": return left < right;
+                case "<=": return left <= right;
+                case ">": return left > right;
+                case ">=": return left >= right;
+                case "==": return Math.abs(left - right) < 1e-9;
+                case "!=": return Math.abs(left - right) >= 1e-9;
+                default: return false;
+            }
+        }
+        // Truthy check if no comparison operator
+        return left !== 0;
+    }
+    function boolExpr() {
+        let left = comparison();
+        while (peek().type === "LOGIC") {
+            const op = advance().value;
+            const right = comparison();
+            if (op === "AND")
+                left = left && right;
+            else if (op === "OR")
+                left = left || right;
+        }
+        return left;
+    }
+    return boolExpr();
+}
+export function runValidation(rules, data) {
+    if (!rules || !Array.isArray(rules))
+        return [];
+    const results = [];
+    for (const rule of rules) {
+        try {
+            const passed = evalBoolExpr(rule.formula, data);
+            results.push({ name: rule.name, severity: rule.severity, message: rule.message, passed });
+        }
+        catch {
+            results.push({ name: rule.name, severity: rule.severity, message: rule.message, passed: false });
+        }
+    }
+    return results;
+}
+export function resolveBinding(bind, data) {
+    const parts = bind.split(".");
+    let val = data;
+    for (const p of parts) {
+        if (val === null || val === undefined)
+            return undefined;
+        val = val[p];
+    }
+    return val;
+}
+export function resolveText(text, data) {
+    if (!text)
+        return "";
+    return fillTemplate(text, data);
+}
+// Minimal QR code generator — produces SVG rect elements for a text payload.
+// Uses a simple bit matrix approach sufficient for short strings (URLs, IDs).
+export function generateQRSvg(text, size = 100) {
+    // Simple QR-like encoding: create a deterministic pattern from text hash
+    // This generates a visually QR-like pattern (not scannable — for display purposes).
+    // For real QR, the template data usually includes a pre-generated QR URL.
+    const moduleCount = 21; // QR Version 1
+    const cellSize = size / moduleCount;
+    const modules = Array.from({ length: moduleCount }, () => Array(moduleCount).fill(false));
+    // Finder patterns (top-left, top-right, bottom-left)
+    const drawFinder = (row, col) => {
+        for (let r = 0; r < 7; r++) {
+            for (let c = 0; c < 7; c++) {
+                const isEdge = r === 0 || r === 6 || c === 0 || c === 6;
+                const isInner = r >= 2 && r <= 4 && c >= 2 && c <= 4;
+                if (isEdge || isInner)
+                    modules[row + r][col + c] = true;
+            }
+        }
+    };
+    drawFinder(0, 0);
+    drawFinder(0, moduleCount - 7);
+    drawFinder(moduleCount - 7, 0);
+    // Data area: hash the text and fill deterministically
+    let hash = 0;
+    for (let i = 0; i < text.length; i++) {
+        hash = ((hash << 5) - hash + text.charCodeAt(i)) | 0;
+    }
+    for (let r = 8; r < moduleCount; r++) {
+        for (let c = 8; c < moduleCount; c++) {
+            hash = ((hash << 5) - hash + r * 31 + c * 17) | 0;
+            modules[r][c] = (hash & 1) === 1;
+        }
+    }
+    let rects = "";
+    for (let r = 0; r < moduleCount; r++) {
+        for (let c = 0; c < moduleCount; c++) {
+            if (modules[r][c]) {
+                rects += `<rect x="${c * cellSize}" y="${r * cellSize}" width="${cellSize}" height="${cellSize}" fill="#000"/>`;
+            }
+        }
+    }
+    return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}"><rect width="${size}" height="${size}" fill="#fff"/>${rects}</svg>`;
+}
+function renderElement(el, data) {
+    switch (el.type) {
+        case "text": {
+            const text = resolveText(el.content || el.text || "", data);
+            const styles = [];
+            if (el.fontSize)
+                styles.push(`font-size:${el.fontSize}px`);
+            if (el.color)
+                styles.push(`color:${el.color}`);
+            if (el.bold)
+                styles.push("font-weight:bold");
+            if (el.align)
+                styles.push(`text-align:${el.align}`);
+            return `<div style="${styles.join(";")}">${text}</div>`;
+        }
+        case "header": {
+            const text = resolveText(el.content || el.text || "", data);
+            const styles = ["font-weight:bold"];
+            if (el.backgroundColor)
+                styles.push(`background-color:${el.backgroundColor}`);
+            if (el.padding)
+                styles.push(`padding:${typeof el.padding === "number" ? el.padding + "px" : el.padding}`);
+            if (el.fontSize)
+                styles.push(`font-size:${el.fontSize}px`);
+            if (el.color)
+                styles.push(`color:${el.color}`);
+            if (el.align)
+                styles.push(`text-align:${el.align}`);
+            return `<div style="${styles.join(";")}">${text}</div>`;
+        }
+        case "image": {
+            let src = el.src || el.url || "";
+            if (el.bind) {
+                const resolved = resolveBinding(el.bind, data);
+                if (typeof resolved === "string")
+                    src = resolved;
+            }
+            const w = el.width ? `width:${typeof el.width === "number" ? el.width + "px" : el.width}` : "";
+            const h = el.height ? `height:${typeof el.height === "number" ? el.height + "px" : el.height}` : "";
+            return `<img src="${src}" style="${[w, h].filter(Boolean).join(";")}" />`;
+        }
+        case "qrcode": {
+            let qrData = el.data || el.content || "";
+            if (el.bind) {
+                const resolved = resolveBinding(el.bind, data);
+                if (typeof resolved === "string")
+                    qrData = resolved;
+            }
+            qrData = resolveText(qrData, data);
+            const qrSize = el.size || (typeof el.width === "number" ? el.width : 100);
+            const svg = generateQRSvg(qrData, qrSize);
+            const dataUri = `data:image/svg+xml;base64,${Buffer.from(svg).toString("base64")}`;
+            return `<img src="${dataUri}" width="${qrSize}" height="${qrSize}" />`;
+        }
+        case "spacer": {
+            const h = el.height || 10;
+            return `<div style="height:${typeof h === "number" ? h + "px" : h}"></div>`;
+        }
+        case "line": {
+            const color = el.color || "#000";
+            const thickness = el.thickness || 1;
+            return `<hr style="border:none;border-top:${thickness}px solid ${color};margin:8px 0;" />`;
+        }
+        case "columns": {
+            const cols = el.columns || el.children || [];
+            const inner = cols.map((child) => {
+                // Support both: array of elements per column, or single element per column
+                if (Array.isArray(child)) {
+                    return `<div style="flex:1">${child.map((c) => renderElement(c, data)).join("")}</div>`;
+                }
+                return `<div style="flex:1">${renderElement(child, data)}</div>`;
+            }).join("");
+            return `<div style="display:flex;gap:8px">${inner}</div>`;
+        }
+        case "page_break": {
+            return `<div style="page-break-after:always"></div>`;
+        }
+        case "grid": {
+            const items = (Array.isArray(el.items) ? el.items : Array.isArray(el.content) ? el.content : []);
+            const gridRows = items.map((item) => {
+                const label = item.label || item.value || "";
+                let value = "";
+                if (item.bind) {
+                    const resolved = resolveBinding(item.bind, data);
+                    value = resolved !== undefined && resolved !== null ? String(resolved) : "";
+                }
+                value = resolveText(value || "", data);
+                return `<tr><td style="padding:4px 8px;font-weight:bold;white-space:nowrap;width:40%">${label}</td><td style="padding:4px 8px">${value}</td></tr>`;
+            }).join("");
+            return `<table style="width:100%;border-collapse:collapse">${gridRows}</table>`;
+        }
+        case "table": {
+            const headers = el.headers || [];
+            const rowFields = el.row_fields;
+            const thead = headers.length
+                ? `<thead><tr>${headers.map(h => `<th style="padding:6px 8px;border:1px solid #ddd;background:#f5f5f5;text-align:left;font-size:8px">${h}</th>`).join("")}</tr></thead>`
+                : "";
+            let bodyRows = el.rows || [];
+            if (el.bind) {
+                const resolved = resolveBinding(el.bind, data);
+                if (Array.isArray(resolved))
+                    bodyRows = resolved;
+            }
+            const tbody = bodyRows.map((row) => {
+                if (Array.isArray(row)) {
+                    return `<tr>${row.map(cell => `<td style="padding:5px 8px;border:1px solid #ddd;font-size:8px">${cell ?? ""}</td>`).join("")}</tr>`;
+                }
+                // Object row — use row_fields if provided, else fall back to header matching
+                if (rowFields && rowFields.length) {
+                    return `<tr>${rowFields.map(field => {
+                        const val = row[field] ?? "";
+                        return `<td style="padding:5px 8px;border:1px solid #ddd;font-size:8px">${val}</td>`;
+                    }).join("")}</tr>`;
+                }
+                return `<tr>${headers.map(h => {
+                    const key = h.toLowerCase().replace(/[^a-z0-9]/g, "");
+                    const val = row[h] ?? row[key] ?? row[h.replace(/\s+/g, "")] ?? "";
+                    return `<td style="padding:5px 8px;border:1px solid #ddd;font-size:8px">${val}</td>`;
+                }).join("")}</tr>`;
+            }).join("");
+            return `<table style="width:100%;border-collapse:collapse">${thead}<tbody>${tbody}</tbody></table>`;
+        }
+        case "box": {
+            const styles = ["text-align:center"];
+            if (el.border)
+                styles.push(`border:${el.border}`);
+            if (el.background || el.backgroundColor)
+                styles.push(`background:${el.background || el.backgroundColor}`);
+            if (el.padding)
+                styles.push(`padding:${typeof el.padding === "number" ? el.padding + "px" : el.padding}`);
+            const inner = (el.children || []).map(child => renderElement(child, data)).join("");
+            const text = el.content || el.text ? resolveText(el.content || el.text || "", data) : "";
+            return `<div style="${styles.join(";")}">${text}${inner}</div>`;
+        }
+        default: {
+            // Unknown element — try to render children
+            if (el.children && Array.isArray(el.children)) {
+                return el.children.map(child => renderElement(child, data)).join("");
+            }
+            return "";
+        }
+    }
+}
+export function renderLayoutToHtml(layout, pageConfig, styles, data) {
+    const pageSize = pageConfig?.size || "A4";
+    const margins = pageConfig?.margins || { top: "15mm", right: "15mm", bottom: "15mm", left: "15mm" };
+    const fontFamily = styles?.fontFamily || "Helvetica, Arial, sans-serif";
+    const fontSize = styles?.fontSize || 12;
+    const color = styles?.color || "#000";
+    // Normalize layout to LayoutElement[]:
+    // - Array → use directly
+    // - Object with .pages → flatten page sections (header/body/footer per page)
+    // - Object with .sections/.children → unwrap
+    // - Object with .header/.footer → wrap as elements
+    let elements = [];
+    if (Array.isArray(layout)) {
+        elements = layout;
+    }
+    else if (layout && typeof layout === "object") {
+        if (Array.isArray(layout.pages)) {
+            for (const page of layout.pages) {
+                if (page.header)
+                    elements.push(page.header);
+                if (Array.isArray(page.body))
+                    elements.push(...page.body);
+                else if (page.body)
+                    elements.push(page.body);
+                if (Array.isArray(page.sections))
+                    elements.push(...page.sections);
+                if (Array.isArray(page.elements))
+                    elements.push(...page.elements);
+                if (page.footer)
+                    elements.push(page.footer);
+            }
+        }
+        else if (Array.isArray(layout.sections)) {
+            elements = layout.sections;
+        }
+        else if (Array.isArray(layout.children)) {
+            elements = layout.children;
+        }
+        else {
+            // Object with header/footer keys — wrap as single-element layout
+            if (layout.header)
+                elements.push(layout.header);
+            if (layout.body) {
+                const body = layout.body;
+                if (Array.isArray(body))
+                    elements.push(...body);
+                else
+                    elements.push(body);
+            }
+            if (layout.footer)
+                elements.push(layout.footer);
+        }
+    }
+    const bodyHtml = elements.map(el => renderElement(el, data)).join("\n");
+    return `<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<style>
+@page {
+  size: ${pageSize};
+  margin: ${margins.top || "15mm"} ${margins.right || "15mm"} ${margins.bottom || "15mm"} ${margins.left || "15mm"};
+}
+body {
+  font-family: ${fontFamily};
+  font-size: ${fontSize}px;
+  color: ${color};
+  margin: 0;
+  padding: 0;
+  line-height: 1.4;
+}
+table { page-break-inside: avoid; }
+img { max-width: 100%; }
+</style>
+</head>
+<body>
+${bodyHtml}
+</body>
+</html>`;
+}