whale-code 6.5.5 → 6.5.6

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

@@ -1,859 +1,1022 @@
 // 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";
+
+// ============================================================================
+// 1. GENERATION RULES — auto-fill missing fields from pdf_templates.generation_rules
+// ============================================================================
+
 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;
-    });
+  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);
+  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;
         }
-        return rules;
+      }
+      rules.push(rule);
     }
-    return [];
+    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;
+  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;
             }
-            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;
-                }
+            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;
             }
-        }
-        if (resolved === 0)
-            break; // No more fields to resolve
+            resolved++;
+            break;
+          }
+      }
     }
-    return result;
+    if (resolved === 0) break; // No more fields to resolve
+  }
+  return result;
 }
+
+// ============================================================================
+// 2. CANNABINOID DATA GENERATOR — from document_profiles config
+// ============================================================================
+
 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,
-            });
-        }
+  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;
+  }
+  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 };
+  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
+  };
 }
+
+// ============================================================================
+// 3. CALCULATION ENGINE — safe expression evaluator (NO eval)
+// ============================================================================
+
+// Tokenizer
+
 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) || (ch === "." && i + 1 < expr.length && /[0-9]/.test(expr[i + 1]))) {
-            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
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && i + 1 < expr.length && /[0-9]/.test(expr[i + 1])) {
+      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;
     }
-    tokens.push({ type: "EOF", value: "" });
-    return tokens;
+    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;
+  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;
     }
-    unary() {
-        if (this.peek().type === "OP" && this.peek().value === "-") {
-            this.advance();
-            return -this.primary();
-        }
-        return this.primary();
+    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;
     }
-    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;
+    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();
+  const tokens = tokenize(expr);
+  const parser = new ExprParser(tokens, ctx);
+  return parser.parse();
 }
 function normalizeCalculations(raw) {
-    if (!raw)
-        return [];
-    if (Array.isArray(raw))
-        return raw;
-    if (typeof raw === "object") {
-        return Object.entries(raw).map(([field, formula]) => ({
-            field,
-            formula: String(formula),
-        }));
-    }
-    return [];
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === "object") {
+    return Object.entries(raw).map(([field, formula]) => ({
+      field,
+      formula: String(formula)
+    }));
+  }
+  return [];
 }
 export function applyCalculations(calculations, constants, data) {
-    const normalized = normalizeCalculations(calculations);
-    if (!normalized.length)
-        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;
-        }
+  const normalized = normalizeCalculations(calculations);
+  if (!normalized.length) 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 normalized) {
-            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
-            }
+  }
+
+  // Multi-pass (max 3) for inter-formula dependencies
+  for (let pass = 0; pass < 3; pass++) {
+    let changed = false;
+    for (const calc of normalized) {
+      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;
         }
-        if (!changed)
-            break;
+      } catch {
+        // Skip failed calculations
+      }
     }
-    return result;
+    if (!changed) break;
+  }
+  return result;
 }
+
+// ============================================================================
+// 4. VALIDATION ENGINE — evaluates formula strings from pdf_templates.validation_rules
+// ============================================================================
+
+// Tokenizer for boolean expressions
+
 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) || (ch === "." && i + 1 < expr.length && /[0-9]/.test(expr[i + 1]))) {
-            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;
-        }
+  const tokens = [];
+  let i = 0;
+  while (i < expr.length) {
+    const ch = expr[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && i + 1 < expr.length && /[0-9]/.test(expr[i + 1])) {
+      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;
     }
-    tokens.push({ type: "EOF", value: "" });
-    return tokens;
+    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;
+  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;
+      }
     }
-    return boolExpr();
+    // 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 });
-        }
+  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;
+  }
+  return results;
 }
+
+// ============================================================================
+// 5. LAYOUT → HTML RENDERER
+// ============================================================================
+
 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;
+  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);
+  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;
-        }
+  // 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;
+      }
     }
-    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"/>`;
-            }
-        }
+  };
+  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;
     }
-    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>`;
+  }
+  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>`;
+  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;
         }
-        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(";")}" />`;
+        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;
         }
-        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}" />`;
+        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;
         }
-        case "spacer": {
-            const h = el.height || 10;
-            return `<div style="height:${typeof h === "number" ? h + "px" : h}"></div>`;
+        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("");
         }
-        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 "";
-        }
-    }
+        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 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>
+  }
+  const bodyHtml = elements.map(el => renderElement(el, data)).join("\n");
+  return `<!DOCTYPE html>
 <html>
 <head>
 <meta charset="utf-8">
@@ -879,3 +1042,4 @@ ${bodyHtml}
 </body>
 </html>`;
 }
+//# sourceMappingURL=pdf-renderer.js.map