/* ===================== Excel Export (xlsx-js-style) — BOM (วัสดุ) + BOQ (ปร.4/ปร.5) =====================
   สร้าง .xlsx ตาม template-schema.md — มีสี / เส้นขอบ / หัวตารางเด่น
   ใช้ xlsx-js-style (fork ของ SheetJS) เพื่อใส่สไตล์เซลล์ได้
   ทุกค่า hardcoded (ไม่มีสูตรในเซลล์) ตามมาตรฐาน template
================================================================== */

// opts.customer = ฉบับลูกค้า (เจ้าของสั่ง 2026-11-16): ตัดหมายเหตุที่ระบบเขียนตอนถอด (r.notes ทุกชีต) + "ผลการวิเคราะห์"
//   + หมายเหตุภายในของชีตสัญลักษณ์ · ไม่ส่ง opts = ฉบับเต็ม (admin ตรวจงานถอด · tools/eval)
function sbBomCustomerView(boqData){
  if (!boqData || typeof boqData !== 'object') return boqData;
  // แถวที่ไม่มีปริมาณ ยังต้องบอกเหตุผลให้ลูกค้า (เดิมหมายเหตุถูกตัดหมด → เห็นแค่ 0) — แปลงเป็นข้อความทางการ 2 แบบ
  const custNote = n => {
    const s = String(n||'');
    if (/มีในตารางสัญลักษณ์|ไม่พบในผัง/.test(s)) return 'มีในตารางสัญลักษณ์ของแบบ แต่ไม่พบในผัง — โปรดตรวจแบบและระบุจำนวน';
    if (/ยังไม่มีความยาว|ไม่คิดความยาว|ให้ผู้ใช้กรอก|ไม่ระบุระยะ|ไม่ทราบตำแหน่ง|ไม่พบตำแหน่ง/.test(s)) return 'แบบไม่ระบุปริมาณ — โปรดตรวจแบบและระบุเอง';
    return '';
  };
  const strip = rows => Array.isArray(rows) ? rows.map(r => (r && typeof r==='object') ? { ...r, notes: custNote(r.notes) } : r) : rows;
  const sheets = {};
  Object.keys(boqData.sheets || {}).forEach(k => { sheets[k] = strip(boqData.sheets[k]); });
  const summary = boqData.summary ? { ...boqData.summary, key_findings:'' } : boqData.summary;
  return { ...boqData, sheets, items: strip(boqData.items), summary };
}
function generateBOQExcel(project, boqData, opts) {
  const X = window.XLSX;
  if (!X) { alert('ไลบรารี Excel ยังโหลดไม่เสร็จ'); return; }
  const CUST = !!(opts && opts.customer);
  if (CUST) boqData = sbBomCustomerView(boqData);

  const wb = X.utils.book_new();
  const items = boqData?.items || [];
  const sh    = boqData?.sheets || {};   // structured data from Claude

  // ── helpers ──────────────────────────────────────────────────
  const n2 = v => Math.round((Number(v)||0)*100)/100;
  const today = new Date().toLocaleDateString('th-TH',{year:'numeric',month:'long',day:'numeric'});

  // ── Palette & cell styles ───────────────────────────────────
  const thin = c => ({ style:'thin', color:{ rgb:c } });
  const BORDER = c => ({ top:thin(c), bottom:thin(c), left:thin(c), right:thin(c) });
  const STYLE = {
    title:   { font:{bold:true,sz:14,color:{rgb:'FFFFFF'}}, fill:{fgColor:{rgb:'1F4E79'}}, alignment:{horizontal:'left',vertical:'center',indent:1} },
    sub:     { font:{bold:true,sz:11,color:{rgb:'1F4E79'}}, fill:{fgColor:{rgb:'DDEBF7'}}, alignment:{horizontal:'left',vertical:'center',indent:1} },
    head:    { font:{bold:true,sz:10,color:{rgb:'FFFFFF'}}, fill:{fgColor:{rgb:'2E75B6'}}, alignment:{horizontal:'center',vertical:'center',wrapText:true}, border:BORDER('9DC3E6') },
    cell:    { font:{sz:10,color:{rgb:'1A2A3A'}}, alignment:{vertical:'center'}, border:BORDER('BDD7EE') },
    cellAlt: { font:{sz:10,color:{rgb:'1A2A3A'}}, fill:{fgColor:{rgb:'F2F8FD'}}, alignment:{vertical:'center'}, border:BORDER('BDD7EE') },
    total:   { font:{bold:true,sz:10,color:{rgb:'7A5C00'}}, fill:{fgColor:{rgb:'FFE699'}}, alignment:{vertical:'center'}, border:BORDER('BF9000') },
    kvLabel: { font:{bold:true,sz:10,color:{rgb:'334155'}}, alignment:{vertical:'center'} },
    kvVal:   { font:{sz:10,color:{rgb:'1A2A3A'}}, alignment:{vertical:'center',wrapText:true} },
    note:    { font:{italic:true,sz:9,color:{rgb:'94A3B8'}}, alignment:{vertical:'center'} },
  };
  const RIGHT = { alignment:{horizontal:'right',vertical:'center'} };
  const numFmt = v => Number.isInteger(v) ? '#,##0' : '#,##0.00';

  // ── Row builders (role-tagged) ──────────────────────────────
  const T  = (...c) => ({ r:'title', c });
  const SB = (...c) => ({ r:'sub',   c });
  const H  = (c)    => ({ r:'head',  c });
  const D  = (c)    => ({ r:'data',  c });
  const TT = (c)    => ({ r:'total', c });
  const KV = (k,v)  => ({ r:'kv',    c:[k,v] });
  const NOTE = (...c) => ({ r:'note', c });
  const BL = () => ({ r:'blank', c:[] });
  // ── ซ่อนหมวดที่ลูกค้าไม่ได้เลือก (เจ้าของสั่ง 2026-11-16) — ชีตสรุปเดิมโชว์ทุกบรรทัดของสาย หมวดที่ไม่เลือกขึ้น 0 (ดูเหมือนถอดได้ 0)
  //   TG(หมวด, แถว) = ป้ายหมวดของบรรทัดโครงสร้าง · สถาปัตย์/สุขาฯ/ไฟฟ้า ใช้ชื่อกลุ่มในคอลัมน์แรก ("2. ท่อน้ำดี") เป็นหมวด
  //   selectedCats ไม่มี (โปรเจกต์เก่า) = แสดงทุกบรรทัดเหมือนเดิม · บรรทัดรวม/ไม่มีหมวด = แสดงเสมอ · เลขกลุ่มเรียงใหม่ต่อ section
  const TG = (cat, row) => { row.cat = cat; return row; };
  const SEL_CATS = Array.isArray(boqData?.selectedCats) && boqData.selectedCats.length ? new Set(boqData.selectedCats) : null;
  const KNOWN_CATS = new Set(((window.SCOPE_ITEMS)||[]).map(s => s.cat));
  const GROUP_CAT = { 'สายไฟ':'สายไฟ-ท่อร้อยสาย', 'ท่อร้อยสาย':'สายไฟ-ท่อร้อยสาย' };
  const selRows = (rows) => {
    if (!SEL_CATS) return rows;
    const out = []; let g = '', n = 0, seen = {};
    rows.forEach(row => {
      if (row.r === 'sub') { g = ''; n = 0; seen = {}; out.push(row); return; }
      if (row.r !== 'data') { out.push(row); return; }
      const lbl = String(row.c[0]||'').trim(); if (lbl) g = lbl;
      const gName = g.replace(/^\d+\.\s*/, '');
      const cat = row.cat || GROUP_CAT[gName] || gName;
      if (cat && KNOWN_CATS.has(cat) && !SEL_CATS.has(cat)) return;
      const c = row.c.slice();
      if (g && !seen[g]) { seen[g] = 1; n++; c[0] = /^\d+\./.test(g) ? n + '. ' + gName : g; } else c[0] = '';
      out.push({ ...row, c });
    });
    return out;
  };

  // แถวสรุปงานระบบจาก base = [หมวด, รายการ, ปริมาณสุทธิ, หน่วย, wastage%, หมายเหตุ]
  //  · qtyRow   → 5 คอลัมน์ (ใช้ในชีต master สรุปรวมทุกสาย — เชิงปริมาณ)
  //  · orderRow → 7 คอลัมน์ (ใช้ในชีตสรุปแต่ละสาย — เพิ่ม Wastage + ปริมาณสั่งซื้อ)
  const qtyRow   = (b) => D([b[0], b[1], b[2], b[3], b[5]]);
  const orderRow = (b) => D([b[0], b[1], b[2], b[3], b[4] ? b[4]+'%' : '-',
                             b[4] ? n2(b[2]*(1+b[4]/100)) : b[2], b[5]]);
  const MAT_HEAD = ['หมวด','รายการ','ปริมาณ (สุทธิ)','หน่วย','Wastage','ปริมาณสั่งซื้อ','หมายเหตุ'];
  const MAT_COLS = [18,30,11,8,9,13,20];

  // ── น้ำหนักปลอก จากเรขาคณิตจริง (mirror sbTiesKg ใน screen_results.jsx) ──
  // n = ceil(L/@) · ยาว/ตัว = เส้นรอบรูปหักระยะหุ้ม + งอ 135° 2 ข้าง (2×12d) · W = d²/162
  const R = (window.REBAR || { cover:0.025, hook:12, hookN:2, lap:40 });
  // เหล็กเส้นมาตรฐานไทย 10 ม. (ทั่วไป) / 12 ม. (เส้นใหญ่) — ผู้ใช้ตั้งรายขนาดได้ที่ "ตารางเหล็ก" ใน sidebar
  // ‼️ ใช้แค่แปลง เมตร→จำนวนเส้น ตอนสั่งของ · ไม่แตะ เมตร/กก. · ไม่มีค่าตั้ง = 10 (เท่าพฤติกรรมเดิม)
  const barLenOf = (t, d) => (window.sbBarLen ? window.sbBarLen(t, d) : 10);

  // ── ตัวสะสมเหล็กแยกตามขนาด: { 'DB16': {t,d,len,kg}, ... } ──
  // ‼️ ต้องแยกขนาดถึงจะสั่งของได้จริง (DB12 กับ DB16 คนละของ คนละราคา)
  // และ กก. ของหลายขนาดรวมกัน ย้อนกลับเป็นเมตรไม่ได้ → เก็บความยาวแยกไว้ตั้งแต่ต้น
  const steel = {};
  const steelAdd = (t, d, len) => {
    if(!(len > 0) || !(d > 0)) return;
    // Ø = เหล็กขนาดเดียวกับ DB/RB (≥10 มม. = DB ข้ออ้อย · <10 = RB กลม — กติกาเดียวกับ addSteelType/price-match sizeTokens)
    //   เดิมแยกบรรทัด "Ø9" กับ "RB9" → ใบสั่งซื้อแตกของชิ้นเดียวกันเป็น 2 บรรทัด ไม่ตรง BOQ
    if(/^[Øøφϕ]$/.test(String(t))) t = d >= 10 ? 'DB' : 'RB';
    const k = t + d;
    if(!steel[k]) steel[k] = { t, d, len:0, kg:0 };
    steel[k].len += len;
    steel[k].kg  += len * (d*d/162);
  };
  // ── ตัวสะสมเหล็กแยกบทบาท (สะสมเฉพาะแถวที่อ่านสเปกได้ · ไม่กระทบยอดรวม — ใช้กางในชีตสรุปเท่านั้น) ──
  const beamRoleKg  = { top:0, top_add:0, top_sup:0, bot:0, bot_mid:0 };
  const stairRoleKg = { main:0, dist:0, top:0, step:0 };

  const parseTies = (s) => {
    const t = String(s||'');
    const d = t.match(/(Ø|DB|RB)\s*(\d+(?:\.\d+)?)/i), sp = t.match(/@\s*(\d+(?:\.\d+)?)/);
    if(!d || !sp) return null;
    const dia = Number(d[2]), spc = Number(sp[1]);
    return (dia>0 && spc>0) ? { d:dia, sp:spc, t:d[1].toUpperCase() } : null;
  };
  // ปลอก → {kg, len} + สะสมลง steel · null = parse ไม่ได้
  // sets = ชุดปลอกซ้อน/ตัว (เบิ้ลปลอก 2 ชั้น = 2) · ว่าง/1 = ปกติ → คูณความยาวรวม (กระทบ นน./steelAdd)
  const tiesCalc = (section, L, ties, count, sets) => {
    const t = parseTies(ties); if(!t) return null;
    const sec = String(section||'0.3×0.4').split(/[×x]/);
    const B = Number(sec[0])||0, Dd = Number(sec[1])||0;
    const peri = 2*((B-2*R.cover) + (Dd-2*R.cover));
    if(!(peri>0) || !(Number(L)>0)) return { kg:0, len:0 };
    const s = Math.max(1, Number(sets)||1);
    const lenEach = peri + R.hookN*R.hook*t.d/1000;
    const totLen = Math.ceil(Number(L)/t.sp) * lenEach * (Number(count)||1) * s;
    steelAdd(t.t, t.d, totLen);
    return { kg:n2(totLen*(t.d*t.d/162)), len:n2(totLen) };
  };
  // เหล็กหลัก — mirror sbBars/sbMainKg: n เส้น × (ความยาว + ทาบ 40d + งอ 12d) × d²/162 × จำนวนสมาชิก
  const parseBars = (s) => {
    const m = String(s||'').trim().match(/^\s*(\d+(?:\s*\+\s*\d+)*)\s*[-–]?\s*(Ø|DB|RB)\s*(\d+(?:\.\d+)?)/i);
    if(!m) return null;
    const n = m[1].split('+').reduce((a,x)=>a+(Number(x.trim())||0),0), d = Number(m[3]);
    return (n>0 && d>0) ? { n, d, t:m[2].toUpperCase() } : null;
  };
  const mainCalc = (specs, L, count, addD = R.lap + R.hook) => {
    const len = Number(L)||0; if(!(len>0)) return null;
    let kg = 0, tot = 0, ok = false;
    (specs||[]).forEach(s => { const b = parseBars(s); if(!b) return;
      const barLen = b.n * (len + addD*b.d/1000) * (Number(count)||1);
      steelAdd(b.t, b.d, barLen);
      tot += barLen; kg += barLen * (b.d*b.d/162); ok = true; });
    return ok ? { kg:n2(kg), len:n2(tot) } : null;
  };
  // เหล็กหลักคาน คิดตามบทบาท — mirror sbBeamMainCalc ใน screen_results.jsx
  const beamMainCalc = (r, L, count) => {
    const len = Number(L)||0; if(!(len>0)) return null;
    const n = Number(count)||1;
    let kg = 0, tot = 0, ok = false;
    const add = (spec, lenOf, role) => { const b = parseBars(spec); if(!b) return;
      const barLen = b.n * lenOf(b.d) * n; steelAdd(b.t, b.d, barLen);
      const kk = barLen * (b.d*b.d/162);
      tot += barLen; kg += kk; ok = true;
      if(role) beamRoleKg[role] += kk; };   // สะสมแยกบทบาท (ไม่กระทบ kg/len ที่คืน)
    const through = (d)=> len + ((Number(R.beamLap)||0) + (R.hookN||2)*R.hook)*d/1000;   // L + งอ 2×12d (+ทาบ beamLap=0 · เจ้าของเลือก 2026-10-16)
    add(r.rebar_top||r.rebar, through, 'top');   // บนหลัก
    add(r.rebar_top_add,      through, 'top_add');   // บนเสริม (แถวเดียวกับบน)
    add(r.rebar_bot,          through, 'bot');   // ล่างหลัก
    add(r.rebar_top_sup, (d)=> 0.50*len + 2*R.hook*d/1000, 'top_sup');   // บนเสริมหัวเสา
    add(r.rebar_bot_mid, (d)=> 0.80*len + 2*R.hook*d/1000, 'bot_mid');   // ล่างเสริมกลางช่วง
    return ok ? { kg:n2(kg), len:n2(tot) } : null;
  };
  // แยกความยาว/นน. บน (top+add+sup) vs ล่าง (bot+mid) — display เท่านั้น (ไม่ steelAdd ซ้ำ · beamMainCalc สะสมแล้ว)
  const beamSplit = (r, L, count) => {
    const len=Number(L)||0; if(!(len>0)) return null;
    const n=Number(count)||1, through=(d)=> len + ((Number(R.beamLap)||0) + (R.hookN||2)*R.hook)*d/1000;
    let ok=false;
    const grp=(items)=>{ let kg=0,tot=0; items.forEach(([spec,lenOf])=>{ const b=parseBars(spec); if(!b) return;
      const bl=b.n*lenOf(b.d)*n; tot+=bl; kg+=bl*(b.d*b.d/162); ok=true; }); return { kg:n2(kg), len:n2(tot) }; };
    const top=grp([[r.rebar_top||r.rebar,through],[r.rebar_top_add,through],[r.rebar_top_sup,(d)=>0.50*len+2*R.hook*d/1000]]);
    const bot=grp([[r.rebar_bot,through],[r.rebar_bot_mid,(d)=>0.80*len+2*R.hook*d/1000]]);
    return ok ? { top, bot } : null;
  };
  // เหล็กพื้น (ตะแกรง 2 ทิศ) — mirror sbSlabRebarKg: n=floor(ช่วงตั้งฉาก/@)+1 · ยาว = span−2c + 2×12d
  const slabCalc = (B, L, rebarShort, rebarLong, count) => {
    const b = Number(B)||0, l = Number(L)||0;
    if(!(b>0) || !(l>0)) return null;
    const shortS = Math.min(b,l), longS = Math.max(b,l), cnt = Number(count)||1;
    let kg = 0, tot = 0, ok = false;
    const dir = (spec, spanLen, alongLen) => {
      const t = parseTies(spec); if(!t) return;
      const lenEach = (spanLen - 2*R.cover) + R.hookN*R.hook*t.d/1000;
      if(!(lenEach > 0)) { ok = true; return; }
      const barLen = (sbFloor(alongLen/t.sp) + 1) * lenEach * cnt;
      steelAdd(t.t, t.d, barLen);
      tot += barLen; kg += barLen * (t.d*t.d/162); ok = true;
    };
    dir(rebarShort, shortS, longS);   // ขนานด้านสั้น → ยาว=ด้านสั้น เรียงตามด้านยาว
    dir(rebarLong,  longS,  shortS);  // ขนานด้านยาว → ยาว=ด้านยาว เรียงตามด้านสั้น
    return ok ? { kg:n2(kg), len:n2(tot) } : null;
  };
  // เหล็กบนหัวคาน (แถบริมคาน 2 ขอบ/ทิศ) — mirror sbSlabSupCalc ใน screen_results.jsx
  //  เหล็กหลัก floor(ขอบ/@)+1 × (ยื่น + 12d) · เหล็กกระจายในแถบ ceil(ยื่น/@) × (ขอบ − 2c) · ยื่นว่าง = ¼ ช่วง
  const slabSupCalc = (B, L, specS, extS, specL, extL, count) => {
    const b = Number(B)||0, l = Number(L)||0;
    if(!(b>0) || !(l>0)) return null;
    const shortS = Math.min(b,l), longS = Math.max(b,l), cnt = Number(count)||1;
    let kg = 0, tot = 0, ok = false;
    const strip = (spec, ext, span, edgeLen) => {
      const t = parseTies(spec); if(!t) return;
      const e = (Number(ext)>0) ? Number(ext) : span/4;
      const main = (sbFloor(edgeLen/t.sp) + 1) * (e + R.hook*t.d/1000);
      const dist = sbCeil(e/t.sp) * Math.max(edgeLen - 2*R.cover, 0);
      const barLen = 2 * (main + dist) * cnt;
      steelAdd(t.t, t.d, barLen);
      tot += barLen; kg += barLen * (t.d*t.d/162); ok = true;
    };
    strip(specS, extS, shortS, longS);
    strip(specL, extL, longS, shortS);
    return ok ? { kg:n2(kg), len:n2(tot) } : null;
  };

  // ── เหล็กล่างฐานราก (ตะแกรง 2 ทิศ) — mirror sbFootRebarCalc ใน screen_results.jsx ──
  // ‼️ ระบุแกนตรง ๆ ไม่ใช้ min/max แบบ slabCalc: rebar_x = เหล็กขนานแกน X → ยาว = B เรียงตามด้าน L
  //    (ถ้าใช้ short/long แบบพื้น พอ B>L จะสลับทิศเงียบ ๆ)
  // ‼️ ระยะหุ้มใช้ footCover 5 ซม. (ฐานรากหล่อบน lean) ไม่ใช่ 2.5 ซม. ของเสา/คาน
  // ‼️ สเปกรองรับ 2 แบบ: ระยะเรียง "DB16mm@0.15" (parseTies) · นับเส้น "8Ø12mm" (parseBars) · "5+5-DB12mm" = ตะแกรง 5 เส้น/ทิศ (footMesh)
  // ‼️ มีสเปกแต่ parse ไม่ได้แม้ทิศเดียว → คืน null ทั้งก้อน ใช้ค่า AI แทน — ไม่คิดครึ่ง ๆ กลาง ๆ ให้เหล็กขาด
  const hasSpec = (s) => { const t = String(s == null ? '' : s).trim(); return !!t && t !== '-'; };
  // ตะแกรงบน (top · สเปกเดียว 2 ทิศ) — topU = ตัว U คว่ำ ขาลงข้างฐาน +2×(T−2c)/เส้น · คืน top แยก (null = ไม่มีสเปกบน)
  // ตะแกรง "a+bØd #" = a เส้นแกน X + b เส้นแกน Y (ไม่ใช่ a+b เส้นทุกทิศ) — mirror sbFootMesh ใน screen_results.jsx
  const FOOT_PAIR = /^(\s*)(\d+)\s*\+\s*(\d+)(?=\s*[-–]?\s*(?:Ø|DB|RB)\s*\d)/i;
  const footMesh = (rx, ry, top) => {
    const pick = (s, i) => String(s).replace(FOOT_PAIR, (m, sp, a, b) => sp + (i ? b : a));
    const isPair = (s) => FOOT_PAIR.test(String(s||''));
    const y = hasSpec(ry) ? ry : (isPair(rx) ? rx : ry);
    return { x: isPair(rx) ? pick(rx, 0) : rx, y: isPair(y) ? pick(y, 1) : y,
      topX: isPair(top) ? pick(top, 0) : top, topY: isPair(top) ? pick(top, 1) : top };
  };
  const footRebarCalc = (B, L, T, rx, ry, count, top, topU) => {
    const mesh = footMesh(rx, ry, top);
    const b = Number(B)||0, l = Number(L)||0, cnt = Number(count)||1;
    if(!(b>0) || !(l>0)) return null;
    const c = (R.footCover != null ? R.footCover : 0.05);
    const leg = topU ? 2*Math.max(0, (Number(T)||0) - 2*c) : 0;
    // ยาว/เส้น = (span−2c) + งอปลาย 2×12d — mirror sbFootRebarCalc
    const pend = [];            // พักไว้ก่อน — flush เข้า steel{} ต่อเมื่อ parse ครบทุกสเปกที่มีค่า
    let ok = 0, bad = 0;
    const dir = (spec, spanLen, alongLen, isTop) => {
      if(!hasSpec(spec)) return;              // ไม่ได้ระบุทิศนี้ = ข้าม ไม่ใช่ความล้มเหลว
      let n = 0, d = 0, ty = '';
      const t = parseTies(spec);
      if(t){ n = sbFloor(alongLen/t.sp) + 1; d = t.d; ty = t.t; }
      else {
        const bar = parseBars(spec);
        if(!bar){ bad++; return; }
        n = bar.n; d = bar.d; ty = bar.t;
      }
      const lenEach = (spanLen - 2*c) + (isTop ? leg : 0) + R.hookN*R.hook*d/1000;
      if(!(n>0) || !(lenEach>0)){ bad++; return; }
      pend.push({ ty, d, len: n*lenEach*cnt, isTop });
      ok++;
    };
    dir(mesh.x, b, l);   // เหล็กแกน X: ยาว = B เรียงตามด้าน L
    dir(mesh.y, l, b);   // เหล็กแกน Y: ยาว = L เรียงตามด้าน B
    dir(mesh.topX, b, l, 1); dir(mesh.topY, l, b, 1);   // ตะแกรงบน 2 ทิศ
    if(bad > 0 || ok === 0) return null;
    const bot = { kg:0, len:0 }, tp = { kg:0, len:0 };
    pend.forEach(p => { steelAdd(p.ty, p.d, p.len); const g = p.isTop ? tp : bot; g.len += p.len; g.kg += p.len*(p.d*p.d/162); });
    return { kg:n2(bot.kg+tp.kg), len:n2(bot.len+tp.len),
      bot:{ kg:n2(bot.kg), len:n2(bot.len) }, top: hasSpec(top) ? { kg:n2(tp.kg), len:n2(tp.len) } : null };
  };
  // เหล็กรัดฐานราก — mirror sbFootTiesCalc: "@" = ปลอกรอบหน้าตัด B×T เรียงตาม L (tiesCalc) · "4-RB9" = n วงรัดรอบแปลน 2((B−2c)+(L−2c)) + 2×12d
  const footTiesCalc = (B, L, T, ties, count) => {
    const b = Number(B)||0, l = Number(L)||0;
    if(parseTies(ties)) return tiesCalc(b+'×'+(Number(T)||0), l, ties, count);
    const bar = parseBars(ties); if(!bar) return null;
    const peri = 2*((b-2*R.cover) + (l-2*R.cover));
    if(!(peri>0)) return { kg:0, len:0 };
    const totLen = bar.n * (peri + R.hookN*R.hook*bar.d/1000) * (Number(count)||1);
    steelAdd(bar.t, bar.d, totLen);
    return { kg:n2(totLen*(bar.d*bar.d/162)), len:n2(totLen) };
  };

  // ── core: build worksheet + apply styles ────────────────────
  function setStyle(ws, r, c, style, z) {
    const addr = X.utils.encode_cell({ r, c });
    if (!ws[addr]) ws[addr] = { t:'s', v:'' };
    ws[addr].s = style;
    if (z) ws[addr].z = z;
  }
  function ensureRow(ws, r, ncol) {
    for (let c = 0; c < ncol; c++) {
      const addr = X.utils.encode_cell({ r, c });
      if (!ws[addr]) ws[addr] = { t:'s', v:'' };
    }
    const range = X.utils.decode_range(ws['!ref']);
    if (r > range.e.r) range.e.r = r;
    if (ncol - 1 > range.e.c) range.e.c = ncol - 1;
    ws['!ref'] = X.utils.encode_range(range);
  }

  function buildAndStyle(wb, name, rows, colWidths) {
    const ncol = colWidths.length;
    // ฉบับลูกค้า: หน่วยแบบไทยชุดเดียว (หัวคอลัมน์ "(kg)" → "(กก.)" · ช่องหน่วย "kg"/"ม³" → "กก."/"ลบ.ม.")
    //   ฉบับเต็มคงเดิม — tools/eval อ่านหัวคอลัมน์ตามชื่อเดิม
    if (CUST) rows = rows.map(row => !Array.isArray(row.c) ? row : { ...row, c: row.c.map(v => {
      if (typeof v !== 'string') return v;
      const u = sbUnitTh(v); return u !== v.trim() ? u : sbTxtUnits(v); }) });
    const aoa  = rows.map(row => row.r === 'blank' ? [] : row.c);
    const ws   = X.utils.aoa_to_sheet(aoa);
    // colWidths: number = ความกว้าง · object {w,level,hidden} = คอลัมน์ "วิธีคิด/รายละเอียด" ที่จัดกลุ่มยุบไว้ (กด +/- ใน Excel)
    ws['!cols'] = colWidths.map(cw => {
      if (cw && typeof cw === 'object') {
        const c = { wch: cw.w!=null ? cw.w : 10 };
        if (cw.level)  c.level  = cw.level;
        if (cw.hidden) c.hidden = true;
        return c;
      }
      return { wch: cw };
    });
    if (ws['!cols'].some(c => c.level)) ws['!outline'] = { above:false, left:false };   // ปุ่มสรุปกลุ่มอยู่ขวา

    const merges = [];
    const rowHeights = [];
    let zebra = 0;

    rows.forEach((row, ri) => {
      const role = row.r;
      if (role === 'head') zebra = 0;

      if (role === 'blank') { rowHeights[ri] = { hpt:6 }; return; }

      if (role === 'title') {
        merges.push({ s:{r:ri,c:0}, e:{r:ri,c:ncol-1} });
        rowHeights[ri] = { hpt:26 };
        ensureRow(ws, ri, ncol);
        for (let c=0;c<ncol;c++) setStyle(ws, ri, c, STYLE.title);
      }
      else if (role === 'sub') {
        merges.push({ s:{r:ri,c:0}, e:{r:ri,c:ncol-1} });
        rowHeights[ri] = { hpt:18 };
        ensureRow(ws, ri, ncol);
        for (let c=0;c<ncol;c++) setStyle(ws, ri, c, STYLE.sub);
      }
      else if (role === 'head') {
        rowHeights[ri] = { hpt:30 };
        ensureRow(ws, ri, ncol);
        for (let c=0;c<ncol;c++) setStyle(ws, ri, c, STYLE.head);
      }
      else if (role === 'data') {
        const base = (zebra % 2 === 1) ? STYLE.cellAlt : STYLE.cell;
        zebra++;
        ensureRow(ws, ri, ncol);
        for (let c=0;c<ncol;c++) {
          const v = row.c[c];
          if (typeof v === 'number') setStyle(ws, ri, c, {...base, ...RIGHT}, numFmt(v));
          else setStyle(ws, ri, c, base);
        }
      }
      else if (role === 'total') {
        rowHeights[ri] = { hpt:20 };
        ensureRow(ws, ri, ncol);
        for (let c=0;c<ncol;c++) {
          const v = row.c[c];
          if (typeof v === 'number') setStyle(ws, ri, c, {...STYLE.total, ...RIGHT}, numFmt(v));
          else setStyle(ws, ri, c, STYLE.total);
        }
      }
      else if (role === 'kv') {
        setStyle(ws, ri, 0, STYLE.kvLabel);
        setStyle(ws, ri, 1, STYLE.kvVal);
      }
      else if (role === 'note') {
        merges.push({ s:{r:ri,c:0}, e:{r:ri,c:ncol-1} });
        ensureRow(ws, ri, ncol);
        for (let c=0;c<ncol;c++) setStyle(ws, ri, c, STYLE.note);
      }
    });

    if (merges.length) ws['!merges'] = (ws['!merges']||[]).concat(merges);
    ws['!rows'] = rowHeights;
    X.utils.book_append_sheet(wb, ws, name);
    return ws;
  }

  // G(w): คอลัมน์ "วิธีคิด/รายละเอียด" (ความยาวเหล็ก/นน.แยกส่วน/consumable/ค่าคงที่) — จัดกลุ่มยุบ default · กด + ใน Excel เพื่อกางดู (เก็บ audit trail ครบ หน้าสะอาด)
  const G = w => ({ w, level:1, hidden:true });

  // ── Sheet 01: ข้อมูลโครงการ ───────────────────────────────────
  buildAndStyle(wb, 'ข้อมูลโครงการ', [
    T('ใบถอดปริมาณวัสดุ (BOM)'),
    SB('สร้างโดย SwiftBill'),
    BL(),
    SB('ข้อมูลทั่วไป'),
    KV('ชื่อโครงการ',      project.name || '-'),
    KV('ที่ตั้งโครงการ',   project.location || '-'),
    KV('เจ้าของโครงการ',   '-'),
    KV('ผู้ออกแบบ',        '-'),
    KV('ผู้ควบคุมงาน',     '-'),
    KV('ผู้รับเหมา',       '-'),
    KV('วันที่เริ่มต้น',   '-'),
    KV('วันที่แล้วเสร็จ',  '-'),
    KV('ระยะเวลาก่อสร้าง', '-'),
    KV('เลขที่สัญญา',      '-'),
    BL(),
    SB('ข้อมูลอาคาร'),
    KV('ประเภทอาคาร',  boqData?.summary?.building_type || project.type || '-'),
    KV('จำนวนชั้น',    boqData?.summary?.floors || project.floors || '-'),
    KV('พื้นที่ใช้สอย', (project.area || '-') + (project.area ? ' ตร.ม.' : '')),
    BL(),
    ...(CUST ? [] : [SB('สรุปผลการวิเคราะห์'), KV('ผลการวิเคราะห์', boqData?.summary?.key_findings || '-'), BL()]),
    KV('วันที่สร้างเอกสาร', today),
  ], [24, 52]);

  // ── Sheet 05: ฐานราก ─────────────────────────────────────────
  const footingRows = sh.footings || itemsToSheetRows(items, 'ฐานราก');
  // ‼️ 'แผ่นแบบ' (page_ref) ต่อท้ายเสมอ — ห้ามแทรกกลาง เพราะ index คอลัมน์ผูกกับ sumRow/แถวรวมทุกที่
  const PAGE_COL = 'แผ่นแบบ', PAGE_W = 14;
  const pref = (r) => r.page_ref || '-';
  // ── ของสิ้นเปลือง + ระยะเหล็ก + จำนวนปลอก + แยกหน้าตัด (mirror screen_results sbFillExtras/sbTiesCount/sbSection) ──
  const secBD  = (s) => { const p=String(s||'0.3×0.4').split(/[×x]/); return [n2(Number(p[0])||0), n2(Number(p[1])||0)]; };
  const tiesN  = (ties, Lper, cnt, sets) => { const t=parseTies(ties); return (t && Number(Lper)>0) ? Math.ceil(Number(Lper)/t.sp)*(Number(cnt)||1)*Math.max(1,Number(sets)||1) : '-'; };
  const extras = (steelKg, formworkM2, mainSpec) => {
    const st=Number(steelKg)||0, fm=Number(formworkM2)||0, b=parseBars(mainSpec)||parseTies(mainSpec);
    return { steel_total:n2(st), tie_wire:n2(st*0.01), nail:n2(fm*0.3), spacer:sbCeil(fm*4),
      bend: b?n2(R.hook*b.d/1000):'-', lap: b?n2(R.lap*b.d/1000):'-' };
  };
  const f_header1 = ['รหัส','ประเภท','รูปทรง','B (m)','L (m)','T (m)','จำนวน','ลึกขุด (m)','หนา Lean (m)','หนา ทราย (m)','fc\' (ksc)','เหล็กล่าง X (สเปก)','เหล็กล่าง Y (สเปก)','เหล็กบน (สเปก)','รูปเหล็กบน','ปลอก/รัด (สเปก)','เสาเข็ม/ฐาน (ต้น)','หมายเหตุ',PAGE_COL];
  const f_header2 = ['รหัส','พื้นที่ฐาน (ม²)','คสล./ฐาน (ม³)','คสล.รวม (ม³)','Lean (ม³)','ขุดดิน (ม³)','ทรายอัดแน่น (ม³)','ไม้แบบ (ม²)','เหล็กล่าง (ม.)','เหล็กล่าง (kg)','เหล็กบน (ม.)','เหล็กบน (kg)','เหล็กรัด (kg)','เหล็กรวม (kg)'];
  const footTopU = (s) => /u/i.test(String(s||''));   // mirror sbFootTopU
  const f_data1 = footingRows.map(r => [
    r.code||'-', r.type||'เดี่ยว', r.shape||'สี่เหลี่ยม', r.B||'-', r.L||'-', r.T||'-',
    r.count||r.qty||0, r.depth||'-', r.lean_t||0.05, r.sand_t||0.05, r.fc||240,
    addSteelType(r.rebar_x||r.rebar||'-'), addSteelType(r.rebar_y||'-'),
    addSteelType(r.rebar_top||'-'), hasSpec(r.rebar_top) ? (footTopU(r.top_shape) ? 'ตัว U' : 'ตรง') : '-',
    addSteelType(r.ties||'-'), r.piles||1, r.notes||'', pref(r)
  ]);
  const f_sums = calcFootingSummary(footingRows);
  // เหล็กตะแกรง (ล่าง + บน): คิดจากสเปกก่อน (เข้าตัวสะสม steel{} แยกขนาด) · parse ไม่ได้ → fallback ค่าจาก AI (ลงช่องล่าง)
  const f_rebar = footingRows.map(r => footRebarCalc(r.B, r.L, r.T, r.rebar_x||r.rebar, r.rebar_y, r.count||r.qty||1, r.rebar_top, footTopU(r.top_shape)));
  let footAiKg = 0;      // ส่วนที่ยัง fallback ค่า AI — แยกไว้โชว์ในชีตสรุปวัสดุ (สั่งของแยกขนาดไม่ได้)
  let footTiesKg = 0;    // เหล็กรัดฐานรากรวม (kg) — ใช้ในชีตสรุปรวม
  let footTieAiKg = 0;   // เหล็กรัดที่อ่านสเปกไม่ได้ ใช้ ties_kg ที่มีในแถว (ไม่รู้ขนาด) → เข้าก้อน 'เหล็กฐานราก (อ่านสเปกไม่ได้)' ในชีตสั่งซื้อ
  const f_data2 = f_sums.map((r, i) => {
    const fr = f_rebar[i], fRow = footingRows[i];
    const botKg = fr !== null ? fr.bot.kg : (Number(r.rebar_bot_kg)||0);
    if (fr === null) footAiKg += botKg;
    const top = fr !== null ? fr.top : null;   // null = ไม่มีสเปกตะแกรงบน → '-'
    // เหล็กรัด: "@" = ปลอกรอบหน้าตัด B×T เรียงตาม L · "4-RB9" = n วงรัดรอบแปลน (mirror SB_RECOMPUTE.footings → sbFootTiesCalc) · เข้า steel{} แยกขนาด
    // สเปกว่าง/"-" → '-' (ไม่ใช่ 0 ที่ดูเหมือนคิดแล้วได้ศูนย์) · parse ไม่ได้แต่มี ties_kg → ใช้ค่านั้น (เหมือนเสา/คาน)
    const tk = footTiesCalc(fRow.B, fRow.L, fRow.T, fRow.ties, fRow.count||fRow.qty||1);
    const tieKg = tk !== null ? tk.kg : (fRow.ties_kg!=='' && fRow.ties_kg!=null ? n2(fRow.ties_kg) : '-');
    if (tieKg !== '-') { footTiesKg += Number(tieKg)||0; if (tk === null) footTieAiKg += Number(tieKg)||0; }
    return [
      r.code, r.area_m2, r.concrete_per, r.concrete_m3, r.lean_m3,
      r.excavation_m3, r.sand_m3, r.formwork_m2,
      fr !== null ? fr.bot.len : '-',
      botKg,
      top ? top.len : '-',
      top ? top.kg : '-',
      tieKg,
      n2(botKg + (top ? top.kg : 0) + (Number(tieKg)||0)),   // เหล็กรวม = ล่าง + บน + รัด
    ];
  });
  footTiesKg = n2(footTiesKg);
  // คอลัมน์เหล็กบน (10,11) / เหล็กรัด (12) เข้ายอดรวมเฉพาะเมื่อมีแถวที่คิดได้ — ทั้งหมดเป็น '-' ให้แถวรวมว่าง ไม่ใช่ 0
  const f_hasTop = f_data2.some(d => d[11] !== '-');
  const f_hasTies = f_data2.some(d => d[12] !== '-');
  const f_total = sumRow(f_data2, [1,2,3,4,5,6,7,8,9].concat(f_hasTop ? [10,11] : [], f_hasTies ? [12] : [], [13]));
  const footTopKg = n2(f_hasTop ? Number(f_total[11])||0 : 0);   // ตะแกรงบนรวม — ชีตสรุปรวม
  if (footingRows.length) buildAndStyle(wb, 'ฐานราก', [
    T('ฐานราก'),
    BL(),
    H(f_header1), ...f_data1.map(D),
    BL(),
    SB('สรุปปริมาณ (Summary)'),
    H(f_header2), ...f_data2.map(D),
    // f_total[i] ต้องลงคอลัมน์ i → 'รวม' กิน idx0 แล้ว spread จาก idx1 พอดี
    TT(['รวม',...f_total.slice(1)]),
    BL(),
    SB('หมายเหตุ'),
    NOTE('เหล็กล่าง: คิดจากสเปกในแบบ (ตะแกรง 2 ทิศ · ระยะหุ้มฐานราก '+n2((R.footCover!=null?R.footCover:0.05)*100)+' ซม. · +งอ '+R.hook+'d) — แถวที่ขึ้น "-" ในคอลัมน์ (ม.) คือสเปกอ่านไม่ได้ จึงใช้น้ำหนักประมาณ'),
    NOTE('เหล็กบน: ตะแกรงบน 2 ทิศ (สเปกเดียว) ยาว/เส้น = ช่วง−หุ้ม + งอ '+(R.hookN||2)+'×'+R.hook+'d · รูป "ตัว U" = ขาลงข้างฐานเต็มความหนา +2×(T−หุ้ม) · "-" = แบบไม่มีตะแกรงบน'),
    NOTE('เหล็กรัด: "@" = ปลอกปิดรอบหน้าตัด B×T เรียงตามความยาว L — n=ceil(L/@) · "จำนวนวง" (เช่น 4-RB9) = วงรัดรอบแปลนฐาน — ยาว/วง = เส้นรอบรูป−หุ้ม '+n2(R.cover*100)+' ซม. + '+(R.hookN||2)+'×'+R.hook+'d · "-" = ไม่มีสเปก/อ่านสเปกไม่ได้ · เหล็กรวม = ล่าง + บน + รัด'),
    NOTE('แผ่นแบบ: รหัสแผ่นจาก title block ที่ SwiftBill อ่านข้อมูลแถวนั้นมา — "-" = อ่านไม่ได้/เป็นแถวที่เติมจากการกระทบยอดผัง'),
  ], [8,10,15,6,6,6,7,8,8,8,7,14,14,14,8,12,10,20,PAGE_W]);

  // ── Sheet 03: เสา ────────────────────────────────────────────
  const colRows = sh.columns || itemsToSheetRows(items, 'เสา');
  const colFootT = Math.max(0, ...(Array.isArray(sh.footings) ? sh.footings : []).map(r => +(r && r.T) || 0));   // = sbFootTref
  const c_header = ['รหัส','ชั้น/ช่วง','ตำแหน่ง (กริด)','B (m)','D (m)','หน้าตัด B×D (m)','สูง (m)','จำนวน','fc\' (kg/cm²)',
    'เหล็กยืน (สเปก)','ความยาวเหล็กยืน (m)','นน.เหล็กยืน (kg)',
    'ปลอก (สเปก)','จำนวนปลอก','ความยาวเหล็กปลอก (m)','นน.เหล็กปลอก (kg)',
    'ปริมาตร/ตัว (ม³)','ปริมาตรคอนกรีต (ม³)','ไม้แบบรวม (ม²)',
    'ลูกปูน','ตะปู (kg)','น.น.เหล็กรวม (kg)','ลวดผูกเหล็ก (kg)','ระยะเหล็กงอ (m)','ระยะเหล็กทาบ (m)',PAGE_COL];
  const c_data = colRows.map(r => {
    const cnt = r.count||r.qty||1;
    const [B,D] = secBD(r.section);
    const cSets = Math.max(1, Number(r.ties_sets)||1);
    const tk = tiesCalc(r.section, r.height, r.ties, cnt, cSets);
    // เหล็กยืนเสา = สูงเสา (colMainAdd) · ตอม่อ = + หยั่งถึงตะแกรงล่างฐาน (T ฐานมากสุด − หุ้มฐาน) + งอฉาก 12d — mirror sbColMainLen/sbColMainAdd
    //   คิดจากสเปกก่อน — parse ไม่ได้ค่อยใช้ค่า AI
    const pier = /ตอม่อ/.test(String(r.floor||''));
    const mLen = (Number(r.height)||0) + (pier ? Math.max(0, colFootT - (R.footCover != null ? R.footCover : 0.05)) : 0);
    const mk = mainCalc([r.rebar_main||r.rebar], mLen, cnt, (+R.colMainAdd||0) + (pier ? R.hook : 0));
    const mkKg = mk!==null ? mk.kg : (Number(r.rebar_kg)||0);
    const tkKg = tk!==null ? tk.kg : (Number(r.ties_kg)||0);
    // ‼️ calcColVol/Form คืน "รวม" (คูณ count ไว้แล้ว) — ห้ามคูณ count ซ้ำ
    const cform = n2(r.formwork_m2 || calcColForm(r));
    const ex = extras(mkKg+tkKg, cform, r.rebar_main||r.rebar);
    return [
      r.code||'-', r.floor||'-', r.grid||r.gridline||'-', B||'-', D||'-', r.section||'-', n2(r.height)||'-', r.count||r.qty||0, r.fc||240,
      addSteelType(r.rebar_main||r.rebar||'-'), mk===null?'-':mk.len, n2(mkKg),
      addSteelType(r.ties||'-') + (cSets>1?` ×${cSets} ชุด`:''), tiesN(r.ties, r.height, cnt, cSets), tk===null?'-':tk.len,
      tk===null ? (r.ties_kg!=='' && r.ties_kg!=null ? n2(r.ties_kg) : '-') : tk.kg,
      n2(r.concrete_per || calcColVol(r)/(Number(r.count||r.qty)||1)),
      n2(r.concrete_m3 || calcColVol(r)), cform,
      ex.spacer, ex.nail, ex.steel_total, ex.tie_wire, ex.bend, ex.lap,
      pref(r)
    ];
  });
  const c_total = sumRow(c_data, [10,11,13,14,15,17,18,19,20,21,22]);
  if (colRows.length) buildAndStyle(wb, 'เสา', [
    T('เสา'),
    BL(),
    H(c_header), ...c_data.map(D),
    TT(['รวม', ...c_total.slice(1)]),
  ], [9,9,11, G(6),G(6), 13,7,6,8, 13, G(10),G(10), 13, G(8),G(11),G(10),G(11), 13,11, G(8),G(9), 12, G(11), G(10),G(10), PAGE_W]);
  // ยุบซ่อน (level 1): B,D ซ้ำ(3,4) · ความยาว/นน.เหล็กยืน-ปลอก+จำนวนปลอก(10,11,13,14,15) · ปริมาตร/ตัว(16) · ลูกปูน/ตะปู/ลวดผูก(19,20,22) · ระยะงอ/ทาบ(23,24)

  // ── Sheet 03b: เสาเหล็ก (เหล็กรูปพรรณ) ───────────────────────
  // ‼️ ยอด weight_kg เติมจาก SB_RECOMPUTE (สูง×จำนวน×น.น./ม.) — fallback คิดซ้ำจาก unit_weight ที่กรอกมือ
  const steelColRows = sh.steel_columns || [];
  const scol_header = ['รหัส','ชั้น/ช่วง','หน้าตัด','น.น./ม. (กก./ม.)','สูง/ท่อน (m)','จำนวน','ความยาวรวม (m)','น้ำหนักรวม (kg)','หมายเหตุ',PAGE_COL];
  const scol_data = steelColRows.map(m => {
    const uw = Number(m.unit_weight)||0;
    const totLen = Number(m.total_length_m) || (Number(m.height||0) * Number(m.count||0));
    const totWt = Number(m.weight_kg) || (totLen * uw);
    return [
      m.code||'-', m.floor||'-', m.section||'-', n2(uw),
      n2(m.height||0), m.count||0,
      n2(totLen), n2(totWt), m.notes||'', pref(m)
    ];
  });
  const scol_total = sumRow(scol_data, [6,7]);
  if (steelColRows.length) buildAndStyle(wb, 'เสาเหล็ก', [
    T('เสาเหล็ก (เหล็กรูปพรรณ)'),
    BL(),
    H(scol_header), ...scol_data.map(D),
    TT(['รวม','','','','','',n2(scol_total[6]),n2(scol_total[7]),'']),
  ], [8,10,20,14,10,7,12,12,20,PAGE_W]);

  // ── Sheet 03c: อุปกรณ์ประกอบเสาเหล็ก (base plate + anchor bolt) ───────
  // ‼️ น.น.เพลต + bolt รวม เติมจาก SB_RECOMPUTE — fallback คิดซ้ำจาก plate_size/bolt_per
  const fittingRows = sh.steel_col_fittings || [];
  const plateKg = (m) => { const dm=String(m.plate_size||'').match(/\d+(?:\.\d+)?/g); const n=Number(m.count||m.qty)||0;
    return Number(m.plate_kg) || (dm && dm.length>=3 && n ? (dm[0]/1000)*(dm[1]/1000)*(dm[2]/1000)*7850*n : 0); };
  const fit_header = ['รหัสเสา','เพลท B×L×t (mm)','จำนวนแผ่น','น.น.เพลตรวม (kg)','Anchor bolt','ตัว/แผ่น','bolt รวม (ตัว)','หมายเหตุ',PAGE_COL];
  const fit_data = fittingRows.map(m => {
    const n = Number(m.count||m.qty)||0;
    const bt = Number(m.bolt_total) || (Number(m.bolt_per||0) * n);
    return [ m.code||'-', m.plate_size||'-', n, n2(plateKg(m)), m.bolt_size||'-', m.bolt_per||0, Math.round(bt||0), m.notes||'', pref(m) ];
  });
  const fit_total = sumRow(fit_data, [3,6]);
  if (fittingRows.length) buildAndStyle(wb, 'อุปกรณ์เสาเหล็ก', [
    T('อุปกรณ์ประกอบเสาเหล็ก (Base plate + Anchor bolt)'),
    BL(),
    H(fit_header), ...fit_data.map(D),
    TT(['รวม','','',n2(fit_total[3]),'','',Math.round(fit_total[6]||0),'']),
  ], [8,18,10,14,14,9,12,20,PAGE_W]);

  // ── Sheet 04: คาน ────────────────────────────────────────────
  const beamRows = sh.beams || itemsToSheetRows(items, 'คาน');
  const BEAM_TYPE_TH = { simple:'ช่วงเดียว', continuous:'ต่อเนื่อง', cantilever:'ยื่น' };
  const b_header = ['รหัส','B (m)','D (m)','หน้าตัด B×D (m)','ตำแหน่ง (กริด)','ยาว (m)','จำนวน','ชนิดคาน',
    'เหล็กบน (สเปก)','เหล็กบนเสริม (สเปก)','เหล็กบนหัวเสา (สเปก)','ความยาวเหล็กบน (m)','นน.เหล็กบน (kg)',
    'เหล็กล่าง (สเปก)','เหล็กล่างกลางช่วง (สเปก)','ความยาวเหล็กล่าง (m)','นน.เหล็กล่าง (kg)',
    'ปลอก (สเปก)','จำนวนปลอก','ความยาวเหล็กปลอก (m)','นน.เหล็กปลอก (kg)',
    'ปริมาตรรวม (ม³)','ไม้แบบรวม (ม²)','ลูกปูน','ตะปู (kg)','น.น.เหล็กรวม (kg)','ลวดผูกเหล็ก (kg)','ระยะเหล็กงอ (m)','ระยะเหล็กทาบ (m)','หมายเหตุ',PAGE_COL];
  const b_data = beamRows.map(r => {
    const cnt = r.count||r.qty||1;
    const [B,D] = secBD(r.section);
    const bSets = Math.max(1, Number(r.ties_sets)||1);
    const tk = tiesCalc(r.section, r.length, r.ties, cnt, bSets);
    const mk = beamMainCalc(r, r.length, cnt);   // total (สะสม steelAdd ในตัว)
    const sp = beamSplit(r, r.length, cnt);      // แยกบน/ล่าง (display)
    const tkKg = tk!==null ? tk.kg : (Number(r.ties_kg)||0);
    const cform = n2(r.formwork_m2||0);
    const totKg = (mk!==null ? mk.kg : (Number(r.rebar_kg)||0)) + tkKg;
    const ex = extras(totKg, cform, r.rebar_top||r.rebar_bot||r.rebar);
    return [
      r.code||'-', B||'-', D||'-', r.section||'-', r.grid||r.gridline||r.location||'-', n2(r.length)||'-', r.count||r.qty||0, BEAM_TYPE_TH[r.beam_type]||'-',
      addSteelType(r.rebar_top||r.rebar||'-'), addSteelType(r.rebar_top_add||'-'), addSteelType(r.rebar_top_sup||'-'),
      sp?sp.top.len:'-', sp?sp.top.kg:'-',
      addSteelType(r.rebar_bot||'-'), addSteelType(r.rebar_bot_mid||'-'),
      sp?sp.bot.len:'-', sp?sp.bot.kg:'-',
      addSteelType(r.ties||'-') + (bSets>1?` ×${bSets} ชุด`:''), tiesN(r.ties, r.length, cnt, bSets), tk===null?'-':tk.len,
      tk===null ? (r.ties_kg!=='' && r.ties_kg!=null ? n2(r.ties_kg) : '-') : tk.kg,
      n2(r.concrete_m3||r.volume||0), cform,
      ex.spacer, ex.nail, ex.steel_total, ex.tie_wire, ex.bend, ex.lap,
      r.notes||'', pref(r)
    ];
  });
  const b_total = sumRow(b_data, [11,12,15,16,18,19,20,21,22,23,24,25,26]);
  const b_tt = Array(b_header.length).fill('');
  b_tt[0]='รวม'; [11,12,15,16,18,19,20,21,22,23,24,25,26].forEach(i=> b_tt[i]=b_total[i]);
  if (beamRows.length) buildAndStyle(wb, 'คาน', [
    T('คาน'),
    BL(),
    H(b_header), ...b_data.map(D),
    TT(b_tt),
  ], [9, G(6),G(6), 13,12,7,6,10, 13,13,13, G(11),G(10), 13,13, G(11),G(10), 13, G(8),G(11),G(10), 11,11, G(8),G(9), 12, G(11), G(10),G(10), 20, PAGE_W]);
  // ยุบซ่อน (level 1 · กด +/- ใน Excel): B,D ซ้ำ(1,2) · ความยาว/นน.เหล็กบน-ล่าง-ปลอก+จำนวนปลอก(11,12,15,16,18,19,20) · ลูกปูน/ตะปู/ลวดผูก(23,24,26) · ระยะงอ/ทาบ(27,28) — เก็บคอลัมน์ครบ audit trail

  // ── Sheet 07: หลังคา ─────────────────────────────────────────
  const roofRows = sh.roof || itemsToSheetRows(items, 'หลังคา');
  // ‼️ ฉนวน/แผ่นรองใต้วัสดุมุง = อยู่หมวด "วัสดุมุงหลังคา" (arch, roof_covering) ที่เดียว — ตัดออกจากที่นี่
  //    เดิม excel มีคอลัมน์ "ฉนวน (ม²)" auto = พื้นที่จริงทุกแถว (เดา+ซ้ำกับ underlay ของ roof_covering)
  // ‼️ เหล็กโครง (จันทัน/แป/อกไก่/อะเส/ขื่อ) ย้ายไปตาราง "รายละเอียดสมาชิกโครงหลังคา" ทั้งหมด — แถวหลักคิดเฉพาะพื้นที่
  //    พื้นที่ฉายราบ = กว้าง×ยาว×จำนวน (fallback ถ้า flat_area ว่าง) · พื้นที่จริง = ฉายราบ ÷ cos(มุมลาด)
  // รูปทรง (2026-10-19): สามเหลี่ยม = กว้าง×ยาว÷2 · คางหมู = (กว้าง+ฐานบน)/2×ยาว — mirror sbRoofFlat (SB_RECOMPUTE คิด flat_area ให้แล้ว)
  const r_header = ['รหัส','ตำแหน่ง/อาคาร','กว้าง (m)','ยาว (m)','รูปทรง','ฐานบน (m)','มุมลาด (°)','จำนวน','พื้นที่ฉายราบ (ม²)','พื้นที่จริง (ม²)','หมายเหตุ',PAGE_COL];
  const roofShapeK = (r) => { const s=String(r.shape||'').trim().toLowerCase(); return (s==='สามเหลี่ยม'||s==='triangle') ? 'สามเหลี่ยม' : (s==='คางหมู'||s==='trapezoid') ? 'คางหมู' : 'สี่เหลี่ยม'; };
  const roofFlat1 = (r) => { const W=Number(r.width)||0, L=Number(r.length)||0; if(!(W>0&&L>0)) return 0; const k=roofShapeK(r); return k==='สามเหลี่ยม' ? W*L/2 : k==='คางหมู' ? (W+Math.max(Number(r.width_top)||0,0))/2*L : W*L; };
  const r_data = roofRows.map(r => {
    const angle = r.angle_deg || 30;
    const cnt = Number(r.count||r.qty)||1;
    const flat = Number(r.flat_area||r.volume||0) || (roofFlat1(r)*cnt);
    const actualArea = r.actual_area || n2(flat / Math.cos(angle*Math.PI/180));
    return [
      r.code||'-', r.location||r.name||'-',
      n2(r.width||0), n2(r.length||0), roofShapeK(r), roofShapeK(r)==='คางหมู' ? n2(r.width_top||0) : '-', angle, cnt,
      n2(flat), n2(actualArea), r.notes||'', pref(r)
    ];
  });
  const r_total = sumRow(r_data, [8,9]);
  // member breakdown (อกไก่/อะเส/จันทัน/ขื่อ/แป)
  const memberRows = sh.roof_members || [];
  const rm_header = ['ชนิดสมาชิก','หน้าตัด','น.น./ม. (กก./ม.)','ยาวต่อท่อน (m)','จำนวน (ท่อน/แนว)','ความยาวรวม (m)','น้ำหนักรวม (kg)','หมายเหตุ',PAGE_COL];
  const rm_data = memberRows.map(m => {
    const uw = Number(m.unit_weight)||0;
    const totLen = Number(m.total_length_m) || (Number(m.length_each_m||0) * Number(m.count||0));
    const totWt = Number(m.total_weight_kg) || (totLen * uw);
    // เรียง @ คลุมผืน (SB_RECOMPUTE: ความยาว = พื้นที่ผืนที่คลุม ÷ @) → ไม่มียาว/ท่อน·จำนวน · บอกที่มาในหมายเหตุ
    const byArea = Number(m.spacing_m) > 0 && String(m.covers||'').trim() !== '';
    const note = byArea ? [`พื้นที่ผืน ${m.covers} ${n2(m.covers_area_m2)} ม² ÷ @${m.spacing_m}`, m.notes].filter(Boolean).join(' · ') : (m.notes||'');
    return [
      m.type||'-', m.section||'-', n2(uw),
      byArea ? '-' : n2(m.length_each_m||0), byArea ? '-' : (m.count||0),
      n2(totLen), n2(totWt), note, pref(m)
    ];
  });
  const rm_total = sumRow(rm_data, [5,6]);
  // น้ำหนักโครงหลังคารวม = ผลรวมจากสมาชิก (จันทัน/แป/อกไก่/อะเส/ขื่อ) เท่านั้น — แถวหลักไม่ถือน้ำหนักแล้ว
  const roofSteelKg = n2(Number(rm_total[6])||0);
  const roofLayout = [
    T('หลังคา (ผืนหลังคา)'),
    BL(),
    H(r_header), ...r_data.map(D),
    TT(['รวม','','','','','','','',r_total[8],r_total[9],'','']),
  ];
  if (rm_data.length > 0) {
    roofLayout.push(
      BL(),
      T('รายละเอียดสมาชิกโครงหลังคา (คำนวณความยาวจริงตามแบบ)'),
      H(rm_header), ...rm_data.map(D),
      TT(['รวม','','','','',n2(rm_total[5]),n2(rm_total[6]),''])
    );
  }
  if (roofRows.length || rm_data.length) buildAndStyle(wb, 'หลังคา', roofLayout, [8,20,9,9,11,9,8,7,13,13,20,PAGE_W]);

  // ── Sheet 08: พื้นสำเร็จ ─────────────────────────────────────
  const precastRows = sh.slabs_precast || itemsToSheetRows(items, 'พื้นโครงสร้าง', 'สำเร็จ');
  // label เหล็กเสริม topping จากข้อมูลจริง
  const sp_rebarLabel = (() => {
    const labels = precastRows.map(r => r.topping_rebar||r.wiremesh||'').filter(Boolean);
    return labels.length ? [...new Set(labels)].join(', ') : 'Wire Mesh #4@0.20';
  })();
  const sp_header = ['รหัส','ตำแหน่ง','ตำแหน่ง (กริด)','B (m)','L (m)','จำนวนช่วง','หนาแผ่น (m)','หนา Topping (m)',
    'เหล็ก Topping (สเปก)','เหล็กเสริม Topping','จำนวนเหล็กเสริม','ความยาวเหล็กเสริม (m)','นน.เหล็กเสริม (kg)',
    'fc\' Topping (ksc)','น้ำหนักบรรทุก (กก./ม²)','น.น.เหล็กรวม (kg)','ลวดผูกเหล็ก (kg)',
    'พื้นที่รวม (ม²)','ลูกปูน','คอนกรีต (m3)','ไม้แบบ (ม²)','ระยะเหล็กงอ (m)','หมายเหตุ',PAGE_COL];
  const sp_data = precastRows.map(r => {
    const B=n2(r.B||0), L=n2(r.L||0), n=r.count||r.qty||1;
    const area=n2(r.area_m2||r.volume||(B*L*n));
    const cform=n2(r.formwork_m2 || 2*(B+L)*(Number(r.topping_t)||0.05)*n);   // ขอบ topping อย่างเดียว (mirror SB_RECOMPUTE)
    const sk=Number(r.topping_rebar_kg)||0;   // เหล็ก topping = ตะแกรง (SB_RECOMPUTE คิดจากสเปก / กรอกมือ)
    return [
      r.code||'-', r.location||r.name||'-', r.grid||r.gridline||'-', B, L, n,
      r.plank_t||0.05, r.topping_t||0.05,
      addSteelType(r.topping_rebar||r.wiremesh||'-'), r.topping_rebar2||'-', r.topping_rebar_n||'-',
      (r.topping_rebar_m!=null&&r.topping_rebar_m!=='')?n2(r.topping_rebar_m):'-', sk?n2(sk):'-',
      r.fc||210, r.load_kg_m2||'-',
      n2(sk), n2(sk*0.01),
      area, sbCeil(cform*4), n2(area*(Number(r.topping_t)||0.05)), cform,
      '-', r.notes||'', pref(r)
    ];
  });
  const sp_totalArea = sp_data.reduce((s,r)=>s+(Number(r[17])||0),0);
  const sp_totalForm = sp_data.reduce((s,r)=>s+(Number(r[20])||0),0);
  const sp_toppingT = (precastRows[0] && precastRows[0].topping_t) || 0.05;

  // ── พื้นหล่อในที่ (CIP) — สร้างชีตรวมกับพื้นสำเร็จด้านล่าง ────
  const cipRows = sh.slabs_cip || itemsToSheetRows(items, 'พื้นโครงสร้าง', 'หล่อ');
  const sc_header = ['รหัส','ตำแหน่ง','ตำแหน่ง (กริด)','B (m)','L (m)','T (m)','จำนวนช่วง',
    'ชนิดพื้น','fc\' (ksc)','หักช่องเปิด (ม²)',
    'เหล็กล่างด้านสั้น','เหล็กล่างด้านยาว','เหล็กบน (เต็มผืน)',
    'เหล็กบนหัวคาน ด้านสั้น','ยื่นจากขอบ ด้านสั้น (m)','เหล็กบนหัวคาน ด้านยาว','ยื่นจากขอบ ด้านยาว (m)','ตะแกรงลวด',
    'ความยาวเหล็กเสริม (m)','นน.เหล็กล่าง (kg)','นน.เหล็กบน (kg)','นน.เหล็กบนหัวคาน (kg)','นน.ตะแกรง (kg)',
    'คอนกรีต (ม³)','ไม้แบบ (ม²)','ทรายรองพื้น (ม³)','พลาสติกปูรอง (ม²)',
    'ลูกปูน','น.น.เหล็กรวม (kg)','ลวดผูกเหล็ก (kg)','ระยะเหล็กงอ (m)','หมายเหตุ',PAGE_COL];
  // ‼️ ดัชนีคอลัมน์ตัวเลข (ใช้รวม/สรุป) — เพิ่มเหล็กบนหัวคาน 2026-10-19 · หาจากชื่อหัว กันชี้ผิดเมื่อเพิ่มคอลัมน์อีก
  const SCI = (h) => sc_header.indexOf(h);
  const SC_SUM_IDX = ['ความยาวเหล็กเสริม (m)','นน.เหล็กล่าง (kg)','นน.เหล็กบน (kg)','นน.เหล็กบนหัวคาน (kg)','นน.ตะแกรง (kg)',
    'คอนกรีต (ม³)','ไม้แบบ (ม²)','ทรายรองพื้น (ม³)','พลาสติกปูรอง (ม²)','ลูกปูน','น.น.เหล็กรวม (kg)','ลวดผูกเหล็ก (kg)'].map(SCI);
  const sc_data = cipRows.map(r => {
    const B=n2(r.B||0), L=n2(r.L||0), Tt=n2(r.T||0), n=r.count||r.qty||1;
    const ground = (r.slab_support==='บนดิน');
    const grossA=B*L*n, openA=Math.max(Number(r.openings_m2)||0,0), netA=Math.max(grossA-openA,0);
    // เหล็กล่างจากสเปกก่อน (ตรงกับ SB_RECOMPUTE) — parse ไม่ได้ค่อย fallback ค่าที่กรอกมือ
    const sc = slabCalc(B, L, r.rebar_short, r.rebar_long, n);
    const rkFb = (r.rebar_kg != null && r.rebar_kg !== '') ? n2(r.rebar_kg) : null;
    const rkKg = sc!==null ? sc.kg : (rkFb===null ? 0 : rkFb);
    // เหล็กบน (เต็มผืน 2 ทิศ สเปกเดียว) opt-in · ตะแกรงลวด = kg กรอกมือ/AI
    const topSpec = String(r.rebar_top==null?'':r.rebar_top).trim();
    const scTop = (topSpec && topSpec!=='-') ? slabCalc(B,L,r.rebar_top,r.rebar_top,n) : null;
    const topKg = scTop!==null ? scTop.kg : (n2(r.rebar_top_kg)||0);
    // เหล็กบนหัวคาน (แถบริมคาน) — ว่าง = 0
    const scSup = slabSupCalc(B, L, r.top_sup_short, r.top_sup_short_m, r.top_sup_long, r.top_sup_long_m, n);
    const supKg = scSup!==null ? scSup.kg : 0;
    const wmKg = Math.max(n2(r.wiremesh_kg)||0, 0);
    // คอนกรีต/ไม้แบบ/ทราย/พลาสติก: ใช้ค่าที่ SB_RECOMPUTE คิดไว้ก่อน (มีตรรกะบนดิน/หักช่องเปิด) fallback คิดเอง
    const conc = (r.concrete_m3!=null && r.concrete_m3!=='') ? n2(r.concrete_m3) : n2(netA*Tt);
    const cform = (r.formwork_m2!=null && r.formwork_m2!=='') ? n2(r.formwork_m2) : n2((ground?0:netA) + 2*(B+L)*Tt*n);
    const sandM3 = ground ? ((r.sand_m3!=null&&r.sand_m3!=='')?n2(r.sand_m3):n2(netA*(Number(r.sand_t)||0.05))) : 0;
    const polyM2 = ground ? ((r.poly_m2!=null&&r.poly_m2!=='')?n2(r.poly_m2):n2(netA)) : 0;
    const ex = extras(rkKg+topKg+supKg+wmKg, cform, r.rebar_short||r.rebar_long||r.rebar_top);
    const supExt = (spec, ext) => (String(spec||'').trim() && String(spec).trim()!=='-') && Number(ext)>0 ? n2(ext) : '-';   // ว่าง = ¼ ช่วง (โค้ดคิดเอง)
    return [
      r.code||'-', r.location||r.name||'-', r.grid||r.gridline||'-', B, L, Tt, n,
      r.slab_support||'บนคาน', (r.fc!=null&&r.fc!=='')?r.fc:'-', n2(openA),
      addSteelType(r.rebar_short||r.rebar||'-'), addSteelType(r.rebar_long||r.rebar||'-'),
      addSteelType(topSpec||'-'),
      addSteelType(r.top_sup_short||'-'), supExt(r.top_sup_short, r.top_sup_short_m),
      addSteelType(r.top_sup_long||'-'),  supExt(r.top_sup_long,  r.top_sup_long_m),
      r.wiremesh||'-',
      sc === null ? '-' : sc.len, sc !== null ? sc.kg : (rkFb === null ? '-' : rkFb), n2(topKg), n2(supKg), n2(wmKg),
      conc, cform, n2(sandM3), n2(polyM2),
      ex.spacer, ex.steel_total, ex.tie_wire, ex.bend,
      r.notes||'', pref(r)
    ];
  });
  const sc_sum = sumRow(sc_data, SC_SUM_IDX);

  // ── ชีต "พื้นโครงสร้าง" — รวม 2 section (สำเร็จรูป + หล่อในที่) ในชีตเดียว ──
  // คอลัมน์ 0-4 ตรงกัน (รหัส/ตำแหน่ง/กริด/B/L) หลังจากนั้นแต่ละ section มีหัวตารางของตัวเอง
  const slabLayout = [ T('พื้นโครงสร้าง'), BL() ];
  if (precastRows.length) {
    const sp_tt = Array(sp_header.length).fill(''); sp_tt[0]='รวม';
    const sumAt = (i)=> n2(sp_data.reduce((s,r)=>s+(Number(r[i])||0),0));
    sp_tt[15]=sumAt(15); sp_tt[16]=sumAt(16); sp_tt[17]=n2(sp_totalArea);
    sp_tt[18]=sp_data.reduce((s,r)=>s+(Number(r[18])||0),0); sp_tt[19]=sumAt(19); sp_tt[20]=n2(sp_totalForm);
    slabLayout.push(
      SB('1. พื้นสำเร็จรูป (Solid Plank)'),
      H(sp_header), ...sp_data.map(D), TT(sp_tt),
      KV('คอนกรีตทับหน้า (Topping) หนา '+n2(sp_toppingT)+' ม.', n2(sp_totalArea*sp_toppingT)+' ม³'),
      BL()
    );
  }
  if (cipRows.length) {
    const sc_tt = Array(sc_header.length).fill(''); sc_tt[0]='รวม';
    SC_SUM_IDX.forEach(i=> sc_tt[i]=sc_sum[i]);
    slabLayout.push(SB('2. พื้นหล่อในที่ (CIP)'), H(sc_header), ...sc_data.map(D), TT(sc_tt));
  }
  if (precastRows.length || cipRows.length)
    buildAndStyle(wb, 'พื้นโครงสร้าง', slabLayout, [9,16,12,7,7,7,10,13,8,11,15,15,15,15,10,15,10,15,11,11,11,11,11,10,10,11,12,8,11,11,10,18,PAGE_W]);

  // ── บันได (ค.ส.ล.) — ท้องบันได + ลูกขั้น + ชานพัก ─────────────
  const stairRows = sh.stairs || [];
  // ── เรขาคณิตบันได — mirror sbStairGeo ใน screen_results.jsx ──
  // ‼️ ลูกนอนมี steps−1 (ขั้นบนสุด = ระดับชานพัก) · slope = √(rise²+run²) ของทั้งช่วง ไม่ใช่ผลรวมทีละขั้น
  // ‼️ ชานพักอนุมานว่ากว้างเท่าบันได → landing_L ใช้หาความยาวเหล็กที่วิ่งต่อเข้าชานพัก
  const st_geo = (r) => {
    const W=+r.width||0, ns=+r.steps||0, ri=+r.riser||0, td=+r.tread||0;
    const wt=+r.waist_t||0, n=+(r.count||r.qty)||1;
    const lt=+r.landing_t||wt;
    const lL=+r.landing_L||0, lW=+r.landing_W||0;
    const la = (lL>0 && lW>0) ? lL*lW : (+r.landing_area||0);   // มีมิติชานพัก → ใช้ตรง ๆ · ไม่มี → ค่า ม² ที่ให้มา
    const rise=ns*ri, run=Math.max(ns-1,0)*td, slope=Math.sqrt(rise*rise+run*run);
    const sides=+r.handrail_sides||0;
    // แตกส่วน: คอนกรีต แม่บันได(ท้องเอียง)/ขั้น(ปริซึม steps−1)/ชานพัก · ไม้แบบ ท้อง(เอียง+หน้าลูกตั้ง)/ข้าง(แม่ 2 ข้าง)/ชานพัก
    const cW=slope*W*wt, cSt=0.5*ri*td*W*Math.max(ns-1,0), cLa=la*lt;
    const fSo=slope*W + ri*W*ns, fSi=2*slope*wt, fLa=la;
    return { W, ns, ri, td, wt, la, lt, n, slope, rise, sides,
      landing_L: lL>0 ? lL : (W>0 ? la/W : 0),
      // ราวกันตก = ตามลาด × จำนวนข้าง (ไม่รวมขอบชานพัก — mirror screen_results) · ไม่ระบุข้าง = ไม่คิด
      hr: sides>0 ? n2(slope*sides*n) : 0,
      cW:n2(cW*n), cSt:n2(cSt*n), cLa:n2(cLa*n), c:n2((cW+cSt+cLa)*n),
      fSo:n2(fSo*n), fSi:n2(fSi*n), fLa:n2(fLa*n), f:n2((fSo+fSi+fLa)*n) };
  };
  // เหล็กบันได — mirror sbStairRebarCalc · เข้าตัวสะสม steel{} แยกขนาด (สั่งของได้) · null = ใช้ค่า AI
  const noseSpec = (s) => { const t = String(s==null?'':s).trim(); return /^(Ø|DB|RB)\s*\d/i.test(t) && !/@/.test(t) ? '1-'+t : t; };   // mirror sbNoseSpec
  const stairRebarCalc = (r) => {
    const g = st_geo(r);
    if(!(g.W>0) || !(g.slope>0)) return null;
    const c = R.cover, runLen = g.slope + g.landing_L;
    const pend = []; let ok = 0, bad = 0;
    const dir = (spec, alongLen, lenOf, role, mult = 1) => {
      if(!hasSpec(spec)) return;
      let n = 0, d = 0, ty = '';
      const t = parseTies(spec);
      if(t){ n = sbFloor(alongLen/t.sp) + 1; d = t.d; ty = t.t; }
      else { const b = parseBars(spec); if(!b){ bad++; return; } n = b.n; d = b.d; ty = b.t; }
      const lenEach = lenOf(d);
      if(!(n>0) || !(lenEach>0) || !(mult>0)){ bad++; return; }
      pend.push({ ty, d, len: n*lenEach*mult*g.n, role }); ok++;
    };
    dir(r.rebar_main||r.rebar, g.W,    (d)=> runLen + (R.lap + R.hook)*d/1000, 'main');
    dir(r.rebar_dist,          runLen, (d)=> (g.W - 2*c) + R.hookN*R.hook*d/1000, 'dist');
    // เหล็กบน 2 ปลาย — แบบไม่บอกความยาว → ¼ ของลาด (R.stairTopFrac · mirror screen_results)
    const topLen = (+r.top_len_m||0) || (+R.stairTopFrac||0)*g.slope;
    const topSkipped = hasSpec(r.rebar_top) && !(topLen>0);
    if(hasSpec(r.rebar_top) && topLen>0)
      dir(r.rebar_top, g.W, (d)=> 2*(topLen + R.hook*d/1000), 'top');
    // เหล็กขั้น (งอตามรูปขั้น) + เหล็กจมูกขั้น × (steps−1) ขั้น — mirror sbStairRebarCalc
    const nStep = Math.max(g.ns-1, 0);
    dir(r.rebar_step, g.W, (d)=> g.ri + g.td + 2*R.hook*d/1000, 'step', nStep);
    dir(noseSpec(r.rebar_nose), g.W, ()=> g.W - 2*c, 'step', nStep);
    if(bad > 0 || ok === 0) return null;
    let kg = 0, tot = 0; const byDia = {};
    pend.forEach(p => { steelAdd(p.ty, p.d, p.len); const kk=p.len*(p.d*p.d/162); tot += p.len; kg += kk;
      byDia[p.d]=n2((byDia[p.d]||0)+p.len); if(p.role) stairRoleKg[p.role] += kk; });
    return { kg:n2(kg), len:n2(tot), topSkipped, byDia, topLen:n2(topLen) };
  };
  // เตือนในหมายเหตุเมื่อระดับที่แบบระบุไม่ตรงกับ steps×riser (จับ steps/riser ที่อ่านพลาด) — เกิน 2 ซม. ถือว่าผิด
  const st_notes = (r, g, rk) => {
    const w = [];
    const lb=+r.level_bottom||0, lt2=+r.level_top||0;
    if(lb!==0 || lt2!==0){
      const diff = Math.abs(g.rise - Math.abs(lt2-lb));
      if(diff > 0.02) w.push(`ควรตรวจสอบ: สูงรวม ${n2(g.rise)} ม. ไม่ตรงกับระดับบน−ล่าง ${n2(Math.abs(lt2-lb))} ม. — ตรวจจำนวนและความสูงลูกตั้ง`);
    }
    if(rk && rk.topSkipped) w.push('ยังไม่รวมเหล็กบน — แบบไม่ระบุความยาว (กรอกช่อง "ยาวเหล็กบน/ปลาย")');
    return [r.notes||'', ...w].filter(Boolean).join(' · ');
  };
  const st_header = ['รหัส','ตำแหน่ง/ชั้น','กว้าง (m)','จำนวนลูกตั้ง','ลูกตั้ง (m)','ลูกนอน (m)','ท้องบันได (m)','ความลาดเอียง (m)',
    'ระดับล่าง (m)','ระดับบน (m)','สูงรวม (m)',
    'คอนกรีตแม่บันได (m3)','คอนกรีตขั้นบันได (m3)','ไม้แบบท้องบันได (m2)','ไม้แบบข้างบันได (m2)','ปริมาณตะปูบันได (kg)',
    'เหล็กหลัก (สเปก)','เหล็กบน (สเปก)','ยาวเหล็กบน/ปลาย (m)','เหล็กเสริมกันร้าว (สเปก)',
    'เหล็กเสริมบันได RB6 (m)','เหล็กเสริมบันได RB9 (m)','เหล็กเสริมบันได DB (m)','ความยาวเหล็กรวม (m)','น.น.เหล็กบันได (kg)',
    'ชานพัก ยาว (m)','ชานพัก กว้าง (m)','ชานพัก (ม²)','หนาชานพัก (m)','คอนกรีตชานพัก (m³)','ไม้แบบชานพัก (m²)',
    'จำนวน',"fc' (ksc)",'คอนกรีตรวม (m3)','ไม้แบบรวม (m2)','ลูกปูน','ตะปูรวม (kg)','น.น.เหล็กรวม (kg)','ลวดผูกเหล็ก (kg)',
    'ราวกันตก (m)','ชนิดราวกันตก','เหล็กขั้นบันได (สเปก)','เหล็กจมูกขั้น (สเปก)','หมายเหตุ',PAGE_COL];
  let stairAiKg = 0;     // ส่วนที่ยัง fallback ค่า AI — แยกไว้โชว์ในชีตสรุปวัสดุ (สั่งของแยกขนาดไม่ได้)
  const st_data = stairRows.map(r => { const g = st_geo(r); const rk = stairRebarCalc(r);
    if(rk === null) stairAiKg += Number(r.rebar_kg)||0;
    const bd = rk ? rk.byDia : {}; let db=0; for(const d in bd){ if(+d>=10) db+=bd[d]; }
    const steelKg = rk!==null ? rk.kg : (Number(r.rebar_kg)||0);
    const ex = extras(steelKg, g.f, r.rebar_main||r.rebar_dist);
    return [ r.code||'-', r.location||r.name||'-', n2(r.width||0), r.steps||0,
      n2(r.riser||0), n2(r.tread||0), n2(r.waist_t||0), n2(g.slope),
      r.level_bottom!=null && r.level_bottom!=='' ? n2(r.level_bottom) : '-',
      r.level_top!=null && r.level_top!=='' ? n2(r.level_top) : '-', n2(g.rise),
      g.cW, g.cSt, g.fSo, g.fSi, n2((g.fSo+g.fSi)*0.3),
      addSteelType(r.rebar_main||r.rebar||'-'), addSteelType(r.rebar_top||'-'),
      hasSpec(r.rebar_top) && rk && rk.topLen>0 ? rk.topLen : '-', addSteelType(r.rebar_dist||'-'),
      bd[6]||'-', bd[9]||'-', db>0?n2(db):'-', rk===null?'-':rk.len, n2(steelKg),
      r.landing_L ? n2(r.landing_L) : '-', r.landing_W ? n2(r.landing_W) : '-', n2(g.la), n2(g.lt), g.cLa, g.fLa,
      r.count||r.qty||1, r.fc||240, n2(r.concrete_m3||g.c), n2(r.formwork_m2||g.f),
      ex.spacer, ex.nail, ex.steel_total, ex.tie_wire,
      g.hr || '-', r.handrail_type||'-', addSteelType(r.rebar_step||'-'), addSteelType(r.rebar_nose||'-'), st_notes(r, g, rk), pref(r) ]; });
  const st_sum = sumRow(st_data, [11,12,13,14,15,20,21,22,23,24,29,30,33,34,35,36,37,38,39]);
  // ยอดรวมที่ชีตสรุปวัสดุอ้างถึง (คอนกรีตรวม/ไม้แบบรวม/นน.เหล็ก/ราวกันตก)
  const st_cTotal = n2(st_sum[33]), st_fTotal = n2(st_sum[34]), st_rTotal = n2(st_sum[24]), st_hrTotal = n2(st_sum[39]);
  const st_tt = Array(st_header.length).fill(''); st_tt[0]='รวม';
  [11,12,13,14,15,20,21,22,23,24,29,30,33,34,35,36,37,38,39].forEach(i=> st_tt[i]=st_sum[i]);
  if (stairRows.length) buildAndStyle(wb, 'บันได', [
    T('บันได (คอนกรีตเสริมเหล็ก)'),
    BL(),
    H(st_header), ...st_data.map(D),
    TT(st_tt),
  ], [9,16,8,9,9,9,10,10, G(11),G(11), 10, G(12),G(12),G(12),G(12),G(11), 13,13,G(13),13, G(11),G(11),G(11),G(11), 11, G(11),G(11),G(10),G(10),G(12),G(11), 7,6,12,11, G(8),G(10), 12, G(11), 11,13,24, PAGE_W]);
  // ยุบซ่อน (level 1): ระดับล่าง/บน(8,9) · คอนกรีต-ไม้แบบแยกส่วน+ตะปูบันได(11-15) · ยาวเหล็กบน(18) · เหล็กเสริมแยกขนาด+ความยาวรวม(20-23) · ชานพักแยกส่วน(25-30) · ลูกปูน/ตะปู/ลวดผูก(35,36,38)

  // ── บันไดไม้ (เรือนไทย/ยกใต้ถุน) — ปริมาตรไม้ (ลบ.ฟ.) แยกตามสมาชิก · mirror sbWoodStair* ──
  const woodStairRows = sh.wood_stairs || [];
  const WD_IN = 0.0254, WD_CUFT = 35.3147;
  const wd_geo = (r) => {
    const W=+r.width||0, ns=+r.steps||0, ri=+r.riser||0, td=+r.tread||0, n=+(r.count||r.qty)||1;
    const rise=ns*ri, run=Math.max(ns-1,0)*td, slope=Math.sqrt(rise*rise+run*run);
    const treads = +r.treads>0 ? +r.treads : Math.max(ns-1,0);
    return { W, ns, ri, td, n, rise, run, slope, treads };
  };
  const parseWood = (s) => {
    const m = String(s==null?'':s).match(/(\d+(?:\.\d+)?)\s*(?:["″”]|นิ้ว|in)?\s*[x×X*]\s*(\d+(?:\.\d+)?)/);
    if(!m) return null; const w=Number(m[1])||0, t=Number(m[2])||0;
    return (w>0 && t>0) ? { w, t } : null;
  };
  // คืน [{role,size,cnt,L,v_each_m3}] ต่อบันได 1 ช่วง + bad (สเปกอ่านไม่ได้) — ยังไม่คูณจำนวนช่วง
  const woodMembers = (r) => {
    const g = wd_geo(r); if(!(g.W>0) || !(g.slope>0)) return null;
    const rows = []; let bad = 0;
    const add = (spec, cnt, L, role) => {
      if(!hasSpec(spec)) return; const s=parseWood(spec); if(!s){ bad++; return; }
      if(!(cnt>0)||!(L>0)) return;
      rows.push({ role, size:`${s.w}"×${s.t}"`, cnt, L:n2(L), v:s.w*WD_IN*s.t*WD_IN*L*cnt });
    };
    add(r.stringer_size, +r.stringer_count||2, g.slope, 'แม่บันได');
    add(r.tread_size,    g.treads,             g.W,     'ลูกนอน');
    add(r.riser_board_size, g.treads,          g.W,     'ลูกตั้ง');
    add(r.post_size,     +r.post_count||0,     +r.post_h||0, 'เสาบันได');
    add(r.handrail_size, +r.handrail_sides||0, g.slope, 'ราวจับ');
    const sp=+r.baluster_spacing||0, sides=+r.handrail_sides||0, rh=+r.rail_h||0.90;
    if(hasSpec(r.baluster_size) && sp>0 && sides>0)
      add(r.baluster_size, (sbFloor(g.slope/sp)+1)*sides, rh, 'ลูกกรง');
    return { rows, bad, n:g.n };
  };
  if (woodStairRows.length) {
    const wd_header = ['รหัสบันได','สมาชิก','ขนาด (นิ้ว)','จำนวน/ช่วง','ยาว/ท่อน (m)','จำนวนช่วง','ปริมาตร (ม³)','ปริมาตร (ลบ.ฟ.)','หมายเหตุ',PAGE_COL];
    const wd_data = []; let wd_totM3 = 0;
    woodStairRows.forEach(r => {
      const g = wd_geo(r), mm = woodMembers(r);
      const code = r.code||'-', pr = pref(r);
      const note0 = [r.location||r.name||'', mm && mm.bad>0 ? 'สเปกไม้อ่านไม่ได้ '+mm.bad+' รายการ — ยังไม่รวมในยอด' : ''].filter(Boolean).join(' · ');
      if (!mm || !mm.rows.length) {
        wd_data.push(D([code, '(ไม่มีสมาชิกที่คิดได้)', '-', '-', '-', g.n, 0, 0, note0||'อ่านสเปกไม้ไม่ได้', pr]));
        return;
      }
      mm.rows.forEach((p, i) => {
        const vM3 = p.v * mm.n;
        wd_totM3 += vM3;
        wd_data.push(D([ i===0?code:'', p.role, p.size, p.cnt, p.L, mm.n,
          n2(vM3), n2(vM3*WD_CUFT), i===0?note0:'', i===0?pr:'' ]));
      });
    });
    const wd_tt = Array(wd_header.length).fill('');
    wd_tt[0]='รวม'; wd_tt[6]=n2(wd_totM3); wd_tt[7]=n2(wd_totM3*WD_CUFT);
    buildAndStyle(wb, 'บันไดไม้', [
      T('บันไดไม้ (ปริมาตรไม้ — ไม้ไทยคิดเป็นลูกบาศก์ฟุต)'),
      BL(),
      H(wd_header), ...wd_data,
      TT(wd_tt),
    ], [10,14,12,11,12,10,12,13,26,PAGE_W]);
  }

  // ── บันไดเหล็ก (โครงเหล็กรูปพรรณ) — น้ำหนัก kg + แผ่นพื้น ม² · mirror sbSteelStairCalc ──
  const steelStairRows = sh.steel_stairs || [];
  const SS_DEN = 7850;   // กก./ม³ (เหล็ก)
  const ss_geo = (r) => {
    const W=+r.width||0, ns=+r.steps||0, ri=+r.riser||0, td=+r.tread||0, n=+(r.count||r.qty)||1;
    const rise=ns*ri, run=Math.max(ns-1,0)*td, slope=Math.sqrt(rise*rise+run*run);
    const treads = +r.treads>0 ? +r.treads : Math.max(ns-1,0);
    return { W, ns, ri, td, n, rise, run, slope, treads };
  };
  // คืน [{role,size,uw,cnt,L,len,kg,m2}] ต่อบันได 1 ช่วง + bad — ยังไม่คูณจำนวนช่วง (mirror sbSteelStairCalc)
  const steelStairMembers = (r) => {
    const g = ss_geo(r); if(!(g.W>0) || !(g.slope>0)) return null;
    const rows = []; let bad = 0;
    const add = (section, cnt, L, role) => {
      if(!hasSpec(section)) return;
      const uw = window.steelWeight ? window.steelWeight(section) : null;
      if(!(uw > 0)){ bad++; return; }            // จับคู่ตารางน้ำหนักเหล็กไม่ได้ = ข้าม ไม่เดา
      if(!(cnt>0) || !(L>0)) return;
      const len = L*cnt;
      rows.push({ role, size:String(section).trim(), uw:n2(uw), cnt, L:n2(L), len:n2(len), kg:len*uw, m2:0 });
    };
    const addPlate = (t_mm, area, role) => {
      const t = +t_mm||0;
      if(!(t>0) || !(area>0)) return;
      rows.push({ role, size:'หนา '+n2(t)+' มม.', uw:'-', cnt:'-', L:'-', len:'-', kg:area*(t/1000)*SS_DEN, m2:area });
    };
    add(r.stringer_section, +r.stringer_count||2, g.slope, 'แม่บันได');
    add(r.tread_section,    g.treads,             g.W,     'โครงลูกนอน');
    add(r.riser_section,    g.treads,             g.W,     'ลูกตั้ง');
    add(r.handrail_section, +r.handrail_sides||0, g.slope, 'ราวจับ/ราวกันตก');
    add(r.post_section,     +r.post_count||0,     +r.post_h||0, 'เสาราว');
    addPlate(r.tread_plate_t, g.W*g.td*g.treads, 'แผ่นลูกนอน');
    const lL=+r.landing_L||0, lW=+r.landing_W||0;
    addPlate((+r.landing_plate_t||0) || r.tread_plate_t, lL*lW, 'แผ่นชานพัก');
    return { rows, bad, n:g.n };
  };
  let ss_kgTotal = 0;
  if (steelStairRows.length) {
    const ss_header = ['รหัสบันได','สมาชิก','หน้าตัด/ความหนา','น.น./ม. (กก./ม.)','จำนวน','ยาว/ท่อน (m)','ความยาวรวม (m)','พื้นที่ (ม²)','น้ำหนัก (kg)','จำนวนช่วง','หมายเหตุ',PAGE_COL];
    const ss_data = []; let ss_m2Total = 0;
    steelStairRows.forEach(r => {
      const g = ss_geo(r), mm = steelStairMembers(r);
      const code = r.code||'-', pr = pref(r);
      const note0 = [r.location||r.name||'', mm && mm.bad>0 ? 'หน้าตัดไม่มีในตารางน้ำหนักเหล็ก '+mm.bad+' รายการ — ยังไม่รวมในยอด' : ''].filter(Boolean).join(' · ');
      if (!mm || !mm.rows.length) {
        // อ่านสเปกไม่ได้เลย → ใช้ค่าที่ AI/ผู้ใช้กรอกไว้ (ไม่ทิ้งแถวเงียบ)
        const aiKg = Number(r.steel_kg||r.weight_kg)||0;
        ss_kgTotal += aiKg; ss_m2Total += Number(r.plate_m2)||0;
        ss_data.push(D([code,'(อ่านหน้าตัดไม่ได้ — ค่าจาก SwiftBill)','-','-','-','-','-',
          n2(r.plate_m2||0), n2(aiKg), g.n, note0||'ตรวจหน้าตัดในตารางเหล็ก', pr]));
        return;
      }
      mm.rows.forEach((p, i) => {
        const kg = p.kg*mm.n, m2 = (p.m2||0)*mm.n;
        ss_kgTotal += kg; ss_m2Total += m2;
        ss_data.push(D([ i===0?code:'', p.role, p.size, p.uw, p.cnt, p.L, p.len,
          m2>0?n2(m2):'-', n2(kg), mm.n, i===0?note0:'', i===0?pr:'' ]));
      });
    });
    const ss_tt = Array(ss_header.length).fill('');
    ss_tt[0]='รวม'; ss_tt[7]=n2(ss_m2Total); ss_tt[8]=n2(ss_kgTotal);
    buildAndStyle(wb, 'บันไดเหล็ก', [
      T('บันไดเหล็ก (โครงเหล็กรูปพรรณ — น้ำหนัก kg · แผ่นพื้น/ตะแกรง ม²)'),
      BL(),
      H(ss_header), ...ss_data,
      TT(ss_tt),
      BL(),
      NOTE('• น้ำหนักแผ่น = พื้นที่ × ความหนา × 7850 กก./ม³ · หน้าตัดที่ไม่มีในตารางน้ำหนักเหล็ก จะไม่ถูกรวม (แก้ได้ที่ "ตารางเหล็ก" ในเมนูด้านซ้าย)'),
    ], [10,16,18,12,9,11,12,10,12,10,26,PAGE_W]);
  }

  // ══════════ งานสถาปัตย์ (Sheet 20-24) ══════════════════════════
  // ── Sheet 20: ผนัง ───────────────────────────────────────────
  const wallRows = sh.walls || itemsToSheetRows(items, 'ผนัง');
  const w_header = ['รหัส','วัสดุ','ตำแหน่ง','ยาว (m)','สูง (m)','จำนวนแนว','พื้นที่รวม (ม²)','หักช่องเปิด (ม²)','สุทธิ (ม²)','ฉาบ (จำนวนด้าน)','ฉาบปูน (ม²)','ทาสี (ม²)','หมายเหตุ',PAGE_COL];
  // ทาสี ≈ พื้นที่ฉาบ (plaster_m2 หักกรุกระเบื้องแล้ว) — คำนวณต่อจากข้อมูลที่ถอดแล้ว ไม่ต้องอ่านแบบเพิ่ม
  const w_data = wallRows.map(r => [
    r.code||'-', r.material||'-', r.location||r.name||'-',
    n2(r.length||0), n2(r.height||0), r.count||r.qty||1,
    n2(r.gross_m2||0), n2(r.openings_m2||0), n2(r.net_m2||r.volume||0),
    r.plaster_sides||2, n2(r.plaster_m2||0), n2(r.plaster_m2||0), r.notes||'', pref(r)
  ]);
  const w_total = sumRow(w_data, [6,7,8,10,11]);
  if (wallRows.length) buildAndStyle(wb, 'ผนัง', [
    T('ผนัง (ก่อ + ฉาบ + ทาสี)'),
    BL(),
    H(w_header), ...w_data.map(D),
    TT(['รวม','','','','','',w_total[6],w_total[7],w_total[8],'',w_total[10],w_total[11],'']),
  ], [10,20,20,7,7,8,11,12,10,8,11,11,20,PAGE_W]);

  // ── Sheet 21: ประตู-หน้าต่าง ─────────────────────────────────
  const doorRows = sh.doors || [];
  const winRows  = sh.windows || [];
  const dw_header = ['รหัส','ชนิด','วัสดุ','กว้าง (m)','สูง (m)','พื้นที่ (ม2)','วงกบ','จำนวน (ชุด)','ตำแหน่ง','หมายเหตุ',PAGE_COL];
  const dwRow = (r) => [
    r.code||'-', r.type||'-', r.material||'-',
    n2(r.W||0), n2(r.H||0), n2(r.area_m2 || (Number(r.W)||0)*(Number(r.H)||0)), r.frame||'-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ];
  const d_data = doorRows.map(dwRow);
  const wn_data = winRows.map(dwRow);
  if (doorRows.length || winRows.length) buildAndStyle(wb, 'ประตูหน้าต่าง', [
    T('ประตูและหน้าต่าง'),
    BL(),
    SB('ประตู'),
    H(dw_header), ...d_data.map(D),
    TT(['รวมประตู','','','','','','',sumRow(d_data,[7])[7]||0,'','']),
    BL(),
    SB('หน้าต่าง'),
    H(dw_header), ...wn_data.map(D),
    TT(['รวมหน้าต่าง','','','','','','',sumRow(wn_data,[7])[7]||0,'','']),
  ], [8,16,20,8,8,10,14,10,20,20,PAGE_W]);

  // ── Sheet 22: พื้นสถาปัตย์ (วัสดุปูพื้น) ──────────────────────────
  const ffRows = sh.floor_finishes || itemsToSheetRows(items, 'พื้นสถาปัตย์');
  const ff_header = ['ห้อง','วัสดุ','B (m)','L (m)','พื้นที่ (ม²)','หักช่องประตู (m)','บัวเชิงผนัง (m)','วัสดุบัว','หมายเหตุ',PAGE_COL];
  const ff_data = ffRows.map(r => {
    const B=n2(r.B||0), L=n2(r.L||0);
    // พื้นที่ = B×L · บัว = เส้นรอบรูป − หักช่องประตู (mirror screen_results SB_RECOMPUTE.floor_finishes)
    // door_open ไม่มี = ถอดกลับจากบัวเดิม (per − skirting) เพื่อคงค่าหักประตู · ไม่มีมิติ = ใช้ค่า AI
    const area = (B>0 && L>0) ? n2(B*L) : n2(r.area_m2||r.volume||0);
    const per = 2*(B+L);
    const doorOpen = (r.door_open_m!=null && r.door_open_m!=='') ? n2(r.door_open_m)
      : ((B>0 && L>0 && Number(r.skirting_m)>0 && Number(r.skirting_m)<=per) ? n2(per-Number(r.skirting_m)) : 0);
    const skirt = (B>0 && L>0) ? n2(Math.max(0, per - doorOpen)) : n2(r.skirting_m||0);
    return [
      r.room||r.code||r.name||'-', r.material||'-',
      B, L, area, doorOpen, skirt, r.skirting_material||'-', r.notes||'', pref(r)
    ];
  });
  const ff_total = sumRow(ff_data, [4,6]);

  // ── Sheet 23: ฝ้าเพดาน ───────────────────────────────────────
  const clRows = sh.ceilings || itemsToSheetRows(items, 'ฝ้าเพดาน');
  const cl_header = ['ห้อง','วัสดุ','ระดับฝ้า (m)','B (m)','L (m)','พื้นที่ (ม²)','บัวฝ้า (m)','หมายเหตุ',PAGE_COL];
  const cl_data = clRows.map(r => {
    const B=n2(r.B||0), L=n2(r.L||0);
    // พื้นที่ฝ้า = พื้นที่ห้อง (B×L) — mirror screen_results SB_RECOMPUTE.ceilings · ไม่มีมิติ = ใช้ค่า AI
    const area = (B>0 && L>0) ? n2(B*L) : n2(r.area_m2||r.volume||0);
    return [
      r.room||r.code||r.name||'-', r.material||'-',
      n2(r.level||0), B, L, area, n2(r.cornice_m||0), r.notes||'', pref(r)
    ];
  });
  const cl_total = sumRow(cl_data, [5,6]);

  // ── กันซึม (พื้นที่เปียก: ห้องน้ำ/ระเบียง/ดาดฟ้า) ─────────────
  const wpRows2 = sh.waterproofing || [];
  const wp2_header = ['รหัส','พื้นที่/ห้อง','ชนิดพื้นที่','ระบบกันซึม','พื้นที่พื้น (ม²)','สูงขอบ (m)','ขอบกันซึม (ม²)','รวม (ม²)','หมายเหตุ',PAGE_COL];
  const wp2_data = wpRows2.map(r => {
    const a = n2(r.area_m2||r.volume||0), u = n2(r.upturn_m2||0);
    return [ r.code||'-', r.location||r.room||'-', r.type||'-', r.material||'-',
      a, n2(r.upturn_h||0), u, n2(r.total_m2 || (a+u)), r.notes||'', pref(r) ];
  });
  const wp2_total = sumRow(wp2_data, [4,6,7]);

  // ── ชีต "งานตกแต่งผิว" — รวม 3 section (พื้นสถาปัตย์ + ฝ้า + กันซึม) ที่ล้วนเป็น finish รายห้อง ──
  const finishLayout = [ T('งานตกแต่งผิว'), BL() ];
  if (ffRows.length) finishLayout.push(
    SB('1. พื้นสถาปัตย์ (วัสดุปูพื้น + บัวเชิงผนัง)'),
    H(ff_header), ...ff_data.map(D),
    TT(['รวม','','','',ff_total[4],'',ff_total[6],'','']),
    BL()
  );
  if (clRows.length) finishLayout.push(
    SB('2. ฝ้าเพดาน'),
    H(cl_header), ...cl_data.map(D),
    TT(['รวม','','','','',cl_total[5],cl_total[6],'','']),
    BL()
  );
  if (wpRows2.length) finishLayout.push(
    SB('3. กันซึม (พื้นที่เปียก)'),
    H(wp2_header), ...wp2_data.map(D),
    TT(['รวม','','','',wp2_total[4],'',wp2_total[6],wp2_total[7],''])
  );
  if (ffRows.length || clRows.length || wpRows2.length)
    buildAndStyle(wb, 'งานตกแต่งผิว', finishLayout, [14,22,12,16,12,14,14,16,20,PAGE_W]);

  // ── Sheet 25: วัสดุมุงหลังคา (สถาปัตย์) — วัสดุมุงบนโครงหลังคา · คนละตัวกับ "หลังคา" โครงสร้าง ──
  const rcRows = sh.roof_covering || itemsToSheetRows(items, 'วัสดุมุงหลังคา');
  const rc_header = ['รหัส','ตำแหน่ง/อาคาร','วัสดุมุง','พื้นที่ฉายราบ (ม²)','มุมลาด (°)','พื้นที่จริงตามลาด (ม²)',
    'แผ่นรอง/ฉนวนกันความร้อน','พื้นที่แผ่นรอง (ม²)','ครอบสัน/ครอบข้าง (m)','เชิงชาย/ปั้นลม (m)','หมายเหตุ',PAGE_COL];
  const rc_data = rcRows.map(r => {
    const fa=n2(r.flat_area||r.volume||0), a=Number(r.angle_deg)||30;
    // พื้นที่จริง = ฉายราบ ÷ cos(มุมลาด) — mirror screen_results SB_RECOMPUTE.roof_covering
    const aa = (r.actual_area!=null && r.actual_area!=='') ? n2(r.actual_area) : n2(fa/Math.cos(a*Math.PI/180));
    const u = String(r.underlay||'').trim();
    const um = (r.underlay_m2!=null && r.underlay_m2!=='') ? n2(r.underlay_m2) : ((u && u!=='-') ? aa : 0);
    return [
      r.code||'-', r.location||r.name||'-', r.material||'-',
      fa, a, aa, u||'-', um, n2(r.ridge_m||0), n2(r.eave_m||0), r.notes||'', pref(r)
    ];
  });
  const rc_total = sumRow(rc_data, [3,5,7,8,9]);
  if (rcRows.length) buildAndStyle(wb, 'วัสดุมุงหลังคา', [
    T('วัสดุมุงหลังคา'),
    BL(),
    H(rc_header), ...rc_data.map(D),
    TT(['รวม','','',rc_total[3],'',rc_total[5],'',rc_total[7],rc_total[8],rc_total[9],'']),
  ], [8,18,22,14,9,16,20,14,14,14,20,PAGE_W]);

  // ── Sheet 24: สรุปงานสถาปัตย์ ────────────────────────────────
  // แถวสรุปงานสถาปัตย์ base = [หมวด, รายการ, ปริมาณสุทธิ, หน่วย, wastage%, หมายเหตุ]
  const archMat = [
    ['1. ผนัง','พื้นที่ก่อสุทธิ (หักช่องเปิดแล้ว)', n2(w_total[8]||0),'ม²', 5, 'อิฐ/บล็อก'],
    ['','ฉาบปูน',                                    n2(w_total[10]||0),'ม²', 5, ''],
    ['','ทาสี (ผนัง)',                               n2(w_total[10]||0),'ม²', 10, 'พื้นที่ทา ≈ พื้นที่ฉาบ'],
    ['2. ประตู-หน้าต่าง','ประตูรวม',                sumRow(d_data,[7])[7]||0,'ชุด', 0, ''],
    ['','หน้าต่างรวม',                               sumRow(wn_data,[7])[7]||0,'ชุด', 0, ''],
    ['3. พื้นสถาปัตย์','วัสดุปูพื้นรวม',                 n2(ff_total[4]||0),'ม²', 10, 'กระเบื้อง'],
    ['','บัวเชิงผนังรวม',                            n2(ff_total[6]||0),'เมตร', 10, ''],
    ['4. ฝ้าเพดาน','พื้นที่ฝ้ารวม',                n2(cl_total[5]||0),'ม²', 5, ''],
    ['','บัวฝ้ารวม',                                 n2(cl_total[6]||0),'เมตร', 5, ''],
    ['5. กันซึม','พื้นที่กันซึมรวม (พื้น+ขอบ)',    n2(wp2_total[7]||0),'ม²', 5, 'ห้องน้ำ/ระเบียง/ดาดฟ้า'],
    ['6. วัสดุมุงหลังคา','วัสดุมุงรวม (พื้นที่จริงตามลาด)', n2(rc_total[5]||0),'ม²', 5, 'เมทัลชีท/กระเบื้อง'],
    ['','แผ่นรอง/ฉนวนกันความร้อน',                  n2(rc_total[7]||0),'ม²', 5, ''],
    ['','ครอบสัน/ครอบข้าง',                          n2(rc_total[8]||0),'เมตร', 5, ''],
    ['','เชิงชาย/ปั้นลม',                            n2(rc_total[9]||0),'เมตร', 5, ''],
  ];
  const archSummaryRows = archMat.map(qtyRow);   // 5 คอลัมน์ สำหรับ master
  const hasArch = wallRows.length || doorRows.length || winRows.length || ffRows.length || clRows.length || wpRows2.length || rcRows.length;
  // ‼️ ชีต "สรุปสถาปัตย์" ถูกยุบเข้า "สรุปวัสดุสั่งซื้อ" (section ข.) — archMat ถูกใช้ที่นั่น

  // ══════════ งานสุขาภิบาล ══════════════════════════════════════
  // ── สุขภัณฑ์ / บ่อ-ถัง / ปั๊ม ใช้หัวตารางร่วมกัน (นับเป็นชุดเหมือนกัน) ──
  // ‼️ จำนวน = index 4 ของทั้ง 3 ชุด (เดิม สุขภัณฑ์/บ่อถัง อยู่ index 3) — saniMat อ้างอิงตามนี้
  const FX_HEAD = ['รหัส','ชนิด','สเปก / วัสดุ / รุ่น','ขนาด / ความจุ','จำนวน (ชุด)','ตำแหน่ง','หมายเหตุ',PAGE_COL];
  const FX_COLS = [10,24,22,14,10,20,20,PAGE_W];

  const swRows = sh.sanitary_ware || itemsToSheetRows(items, 'สุขภัณฑ์');
  const sw_data = swRows.map(r => [
    r.code||'-', r.type||r.name||'-', r.material||'-', '-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ]);

  // ── Sheet 31: ท่อน้ำดี ───────────────────────────────────────
  const wpRows = sh.water_pipes || [];
  const pipe_header = ['รหัส','ระบบ/ชนิด','วัสดุ/ชั้น','ขนาด Ø','ยาว (m)','ที่มา','ตำแหน่ง','หมายเหตุ',PAGE_COL];
  const wp_data = wpRows.map(r => [
    r.code||'-', r.system||'-', r.material||'-', r.dia||'-',
    n2(r.length_m||r.volume||0), r.basis||'-', r.location||'-', r.notes||'', pref(r)
  ]);
  // ── Sheet: ท่อน้ำทิ้ง-โสโครก (รวมชีตกับท่อน้ำดี — หัวตารางเดียวกัน) ──
  const dpRows = sh.drain_pipes || [];
  const dp_data = dpRows.map(r => [
    r.code||'-', r.type||'-', r.material||'-', r.dia||'-',
    n2(r.length_m||r.volume||0), r.basis||'-', r.location||'-', r.notes||'', pref(r)
  ]);

  // ── ชีต "ท่อสุขาภิบาล" — น้ำดี + น้ำทิ้ง/โสโครก ใช้ pipe_header ร่วมกัน ──
  const pipeLayout = [ T('ท่อสุขาภิบาล (แยกตามขนาด Ø · ที่มา: วัด/ประมาณ)'), BL(), H(pipe_header) ];
  if (wpRows.length) pipeLayout.push(
    SB('1. ท่อประปาน้ำดี'),
    ...wp_data.map(D),
    TT(['รวมท่อน้ำดี','','','',sumRow(wp_data,[4])[4]||0,'','',''])
  );
  if (dpRows.length) pipeLayout.push(
    SB('2. ท่อน้ำทิ้ง / โสโครก / อากาศ'),
    ...dp_data.map(D),
    TT(['รวมท่อน้ำทิ้ง-โสโครก','','','',sumRow(dp_data,[4])[4]||0,'','',''])
  );
  if (wpRows.length || dpRows.length)
    buildAndStyle(wb, 'ท่อสุขาภิบาล', pipeLayout, [10,16,18,10,10,9,18,20,PAGE_W]);

  // ── บ่อ-ถังบำบัด (ฝั่งน้ำเสีย) — ใช้ FX_HEAD ร่วม ──
  const stRows = sh.sani_tanks || [];
  const tk_data = stRows.map(r => [
    r.code||'-', r.type||'-', '-', r.size||'-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ]);

  // ── ปั๊ม-ถังน้ำดี (ฝั่งน้ำดี: ปั๊ม/ถังเก็บน้ำ/มิเตอร์/วาล์ว) ──
  const ptRows = sh.pumps_tanks || [];
  const pt_data = ptRows.map(r => [
    r.code||'-', r.type||'-', r.spec||r.material||'-', r.size||'-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ]);

  // ── ชีต "สุขภัณฑ์-ถัง-ปั๊ม" — 3 section นับเป็นชุด ใช้หัวตารางเดียว ──
  const fixLayout = [ T('สุขภัณฑ์ / บ่อ-ถังบำบัด / ปั๊ม-ถังน้ำดี'), BL(), H(FX_HEAD) ];
  if (swRows.length) fixLayout.push(
    SB('1. สุขภัณฑ์ (นับตามผัง)'),
    ...sw_data.map(D),
    TT(['รวมสุขภัณฑ์','','','',sumRow(sw_data,[4])[4]||0,'',''])
  );
  if (stRows.length) fixLayout.push(
    SB('2. บ่อพัก / ถังบำบัด / บ่อดักไขมัน (ฝั่งน้ำเสีย)'),
    ...tk_data.map(D),
    TT(['รวมบ่อ-ถังบำบัด','','','',sumRow(tk_data,[4])[4]||0,'',''])
  );
  if (ptRows.length) fixLayout.push(
    SB('3. ปั๊มน้ำ / ถังเก็บน้ำดี / มิเตอร์-วาล์ว (ฝั่งน้ำดี)'),
    ...pt_data.map(D),
    TT(['รวมปั๊ม-ถังน้ำดี','','','',sumRow(pt_data,[4])[4]||0,'',''])
  );
  if (swRows.length || stRows.length || ptRows.length)
    buildAndStyle(wb, 'สุขภัณฑ์-ถัง-ปั๊ม', fixLayout, FX_COLS);

  // ── Sheet 34: สรุปงานสุขาภิบาล ───────────────────────────────
  // แถวสรุปงานสุขาภิบาล base = [หมวด, รายการ, ปริมาณสุทธิ, หน่วย, wastage%, หมายเหตุ]
  // แตกท่อตามขนาด Ø (รวมความยาวต่อขนาด) · ไม่มีข้อมูล → คืนบรรทัดรวมเดียว
  const pipeSizeRows = (rows, label, wpct) => {
    const agg = {};
    (rows||[]).forEach(r => { const d=String(r.dia||'').trim()||'-'; const L=Number(r.length_m||r.volume||0); if(L>0) agg[d]=(agg[d]||0)+L; });
    const ks = Object.keys(agg);
    if(!ks.length) return [[label,'ความยาวรวม (อ่านขนาดไม่ได้)',0,'เมตร',wpct,'']];
    return ks.map((d,i)=>[ i===0?label:'', 'ท่อ '+d, n2(agg[d]),'เมตร',wpct,'แยกตามขนาด Ø']);
  };
  const saniMat = [
    ['1. สุขภัณฑ์','จำนวนชุดรวม',        sumRow(sw_data,[4])[4]||0,'ชุด', 0, ''],
    ...pipeSizeRows(wpRows,'2. ท่อน้ำดี',5),
    ...pipeSizeRows(dpRows,'3. ท่อน้ำทิ้ง-โสโครก',5),
    ['4. บ่อ-ถังบำบัด','จำนวนรวม',        sumRow(tk_data,[4])[4]||0,'บ่อ/ถัง', 0, ''],
    ['5. ปั๊ม-ถังน้ำดี','จำนวนรวม',       sumRow(pt_data,[4])[4]||0,'ชุด', 0, 'ปั๊ม/ถังเก็บน้ำ/มิเตอร์/วาล์ว'],
  ];
  const saniSummaryRows = saniMat.map(qtyRow);   // 5 คอลัมน์ สำหรับ master
  const hasSani = swRows.length || wpRows.length || dpRows.length || stRows.length || ptRows.length;
  // ‼️ ชีต "สรุปสุขาภิบาล" ถูกยุบเข้า "สรุปวัสดุสั่งซื้อ" (section ค.) — saniMat ถูกใช้ที่นั่น

  // ══════════ งานไฟฟ้า ══════════════════════════════════════════
  // ── ดวงโคม / เต้ารับ-สวิตช์ / ตู้-แผงจ่ายไฟ ใช้หัวตารางร่วมกัน (นับจุด/ชุดเหมือนกัน) ──
  // ‼️ จำนวน = index 4 ของทั้ง 3 ชุด (เดิม เต้ารับ-สวิตช์ อยู่ index 3) — elecMat อ้างอิงตามนี้
  const EL_HEAD = ['รหัส','ชนิด','สเปก / หลอด / พิกัด','การติดตั้ง / ช่อง','จำนวน','ตำแหน่ง','หมายเหตุ',PAGE_COL];
  const EL_COLS = [10,24,18,14,10,20,20,PAGE_W];

  const lumRows = sh.luminaires || itemsToSheetRows(items, 'ดวงโคม');
  const lum_data = lumRows.map(r => [
    r.code||'-', r.type||r.name||'-', r.lamp||'-', r.mount||'-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ]);

  const osRows = sh.outlets_switches || itemsToSheetRows(items, 'เต้ารับ-สวิตช์');
  const os_data = osRows.map(r => [
    r.code||'-', r.type||r.name||'-', r.rating||'-', '-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ]);

  // ── Sheet 42: สายไฟ-ท่อร้อยสาย ───────────────────────────────
  const wireRows = sh.wiring || [];
  // คอลัมน์ตรงกับหน้าเว็บ: รายการ = วงจรแสงสว่าง (L) · วงจรเต้ารับ (RC) · สายเมน · สายดิน · ท่อ (แถวของตัวเอง) — ทุกแถวเป็นเมตร
  // ปริมาณรวม: สาย = ความยาว × เส้น (ยังไม่กรอกเส้น = ความยาว) · ท่อ = ความยาว — ตรงกับหน้าเว็บ
  const wire_header = ['รหัส','รายการ','สายไฟ (สเปก)','ความยาว (ม.)','เส้น','ปริมาณรวม (ม.)','ที่มา','หมายเหตุ',PAGE_COL];
  // wire_calc = ค่าที่ใช้รวมยอด (ชีตสรุป) · wire_data = แถวที่แสดง
  const wire_calc = wireRows.map(r => {
    const isPt = (r.row_type||'')==='point', isCd = (r.row_type||'')==='conduit';
    const route = n2(r.route_m||0), nc = Number(r.n_cond)||0;
    const wireM = (isPt||isCd) ? 0 : n2(nc > 0 ? route*nc : route);
    // ท่อ: แถวท่อ (conduit) = route · แถวสายคิดท่อเฉพาะผลเก่าที่ใส่สเปกท่อในแถวเดียวกัน (ผลใหม่ท่อแยกแถว → กันนับซ้ำ)
    const condM = isPt ? 0 : (isCd || r.conduit || r.conduit_ref) ? n2(r.conduit_m || route) : 0;
    return { isPt, isCd, route, nc, wireM, condM, points: isPt ? (Number(r.points||r.qty)||0) : 0,
      size: String(r.size||'').trim()||'-', conduit: String(r.conduit||r.conduit_ref||'').trim()||'-' };
  });
  const wire_data = wireRows.map((r,i) => { const c = wire_calc[i];
    return [
      r.code||'-', r.circuit||'-',
      c.isCd ? '-' : (r.conductor||r.wire_ref||'-'),
      c.isPt ? '' : c.route,                          // ผลเก่าแบบ "จุด" ไม่มีความยาว
      (c.isPt||c.isCd) ? '' : (c.nc || ''),
      c.isPt ? '' : (c.isCd ? c.route : c.wireM),
      r.basis||'-', r.notes||'', pref(r)
    ]; });
  const wireTotal = n2(wire_calc.reduce((a,c)=>a+c.wireM,0));
  const condTotal = n2(wire_calc.reduce((a,c)=>a+(c.isCd?c.route:0),0));
  if (wireRows.length) buildAndStyle(wb, 'สายไฟท่อร้อยสาย', [
    T('งานเดินสาย (เมตร): วงจรแสงสว่าง · วงจรเต้ารับ · สายเมน · สายดิน · ท่อ'),
    BL(),
    H(wire_header), ...wire_data.map(D),
    TT(['รวมสายไฟ','','','','',wireTotal,'','','']),
    TT(['รวมท่อ','','',condTotal,'','','','','']),
  ], [10,28,24,12,6,12,9,36,PAGE_W]);

  // ── ตู้-แผงจ่ายไฟ — ใช้ EL_HEAD ร่วม ──
  const panRows = sh.panels || [];
  // จำนวนช่อง: แถวที่ไม่ใช่ตัวตู้ (ลูกเบรกเกอร์/หลักดิน/กล่องต่อสาย) = "-" ตรงกับหน้าเว็บ (sbIsPanelRow ใน screen_results.jsx)
  const isPanel = (r) => typeof sbIsPanelRow !== 'function' || sbIsPanelRow(r);
  const pan_data = panRows.map(r => [
    r.code||'-', r.type||'-', r.rating||'-', isPanel(r) ? (r.ways||0) : '-',
    r.count||r.qty||0, r.location||'-', r.notes||'', pref(r)
  ]);

  // ── ชีต "อุปกรณ์ไฟฟ้า" — 3 section นับจุด/ชุด ใช้หัวตารางเดียว ──
  const elLayout = [ T('อุปกรณ์ไฟฟ้า (ดวงโคม / เต้ารับ-สวิตช์ / ตู้-แผงจ่ายไฟ)'), BL(), H(EL_HEAD) ];
  if (lumRows.length) elLayout.push(
    SB('1. ดวงโคม (นับตามผังแสงสว่าง)'),
    ...lum_data.map(D),
    TT(['รวมดวงโคม','','','',sumRow(lum_data,[4])[4]||0,'',''])
  );
  if (osRows.length) elLayout.push(
    SB('2. เต้ารับและสวิตช์ (นับตามผังกำลัง)'),
    ...os_data.map(D),
    TT(['รวมเต้ารับ-สวิตช์','','','',sumRow(os_data,[4])[4]||0,'',''])
  );
  if (panRows.length) elLayout.push(
    SB('3. ตู้/แผงจ่ายไฟ + หลักดิน'),
    ...pan_data.map(D),
    TT(['รวมตู้-แผงจ่ายไฟ','','','',sumRow(pan_data,[4])[4]||0,'',''])
  );
  if (lumRows.length || osRows.length || panRows.length)
    buildAndStyle(wb, 'อุปกรณ์ไฟฟ้า', elLayout, EL_COLS);

  // ── Sheet 44: สรุปงานไฟฟ้า ───────────────────────────────────
  // แถวสรุปงานไฟฟ้า base = [หมวด, รายการ, ปริมาณสุทธิ, หน่วย, wastage%, หมายเหตุ]
  // แตกสาย/ท่อร้อยสายตามขนาด (รวมความยาวต่อขนาด) จาก wire_calc (ทุกแถวที่ไม่ใช่ "จุด")
  const wireAgg = (keyOf, valOf) => {
    const agg = {};
    wire_calc.forEach(c => { if(c.isPt) return; const k=keyOf(c); const v=Number(valOf(c))||0; if(v>0) agg[k]=(agg[k]||0)+v; });
    return Object.entries(agg);
  };
  const wireSz = wireAgg(c=>c.size, c=>c.wireM)       // ขนาดสาย → สายรวม (m) · เรียงเล็ก→ใหญ่ · เลขล้วนเติม "ตร.มม."
    .sort((a,b)=>(parseFloat(a[0])||0)-(parseFloat(b[0])||0))
    .map(([s,v])=>[/^\d+(\.\d+)?$/.test(s) ? s+' ตร.มม.' : s, v]);
  const condSz = wireAgg(c=>c.conduit, c=>c.condM);   // ท่อร้อยสาย → ท่อรวม (m)
  const ptTotal = wire_calc.reduce((a,c)=>a+c.points,0);   // ผลเก่าแบบ "จุด" เท่านั้น
  const elecMat = [
    ['1. ดวงโคม','จำนวนชุดรวม',        sumRow(lum_data,[4])[4]||0,'ชุด', 0, ''],
    ['2. เต้ารับ-สวิตช์','จำนวนจุดรวม', sumRow(os_data,[4])[4]||0,'จุด', 0, ''],
    ...(ptTotal>0 ? [['3. สายไฟ','จุดเดินสายรวม', ptTotal,'จุด', 0, 'วงจรย่อย ไฟ/ปลั๊ก/สวิตช์ (ผลถอดแบบเดิม)']] : []),
    ...(wireSz.length ? wireSz.map(([s,v],i)=>[(i===0&&!(ptTotal>0))?'3. สายไฟ':'', 'สายไฟ '+s, n2(v),'เมตร',10,'แยกตามขนาด'])
                      : [[ptTotal>0?'':'3. สายไฟ','สายไฟรวม', wireTotal,'เมตร',10,'ดูชีตสายไฟท่อร้อยสาย']]),
    ...(condSz.length ? condSz.map(([s,v],i)=>[i===0?'4. ท่อร้อยสาย':'', 'ท่อร้อยสาย '+s, n2(v),'เมตร',5,'แยกตามขนาด'])
                      : [['4. ท่อร้อยสาย','ความยาวรวม', n2(wire_calc.reduce((a,c)=>a+c.condM,0)),'เมตร',5,'']]),
    ['5. ตู้-แผงจ่ายไฟ','จำนวนรวม',    sumRow(pan_data,[4])[4]||0,'ตู้/ชุด', 0, ''],
  ];
  const elecSummaryRows = elecMat.map(qtyRow);   // 5 คอลัมน์ สำหรับ master
  const hasElec = lumRows.length || osRows.length || wireRows.length || panRows.length;
  // ‼️ ชีต "สรุปไฟฟ้า" ถูกยุบเข้า "สรุปวัสดุสั่งซื้อ" (section ง.) — elecMat ถูกใช้ที่นั่น

  // ── Sheet 11: สรุปรวมทุกสาย (แบ่ง section ตามสายงาน — แสดงเฉพาะสายที่มีข้อมูล = ที่ผู้ใช้เลือก) ──
  const hasStructural = footingRows.length || colRows.length || beamRows.length
    || roofRows.length || precastRows.length || cipRows.length || stairRows.length || woodStairRows.length
    || steelStairRows.length;
  const totals = calcTotals(footingRows, colRows, beamRows, roofRows, precastRows, cipRows, items);
  // ‼️ เหล็กฐานราก/เสา/คาน ใช้ยอดจากชีตรายละเอียด (คิดจากสเปกในโค้ด) ไม่ใช่ totals.r_footing/r_column/r_beam
  // ที่รวม rebar_kg ดิบจาก AI — ไม่งั้นสรุปกับตารางไม่ตรงกัน
  const r_foot = n2((Number(f_total[9])||0) + footTopKg);   // เหล็กตะแกรงฐานราก ล่าง+บน (kg) — คิดจากสเปก + fallback AI รายแถว
  const r_col = n2(Number(c_total[11])||0);   // เหล็กยืนเสา (kg) = c_header 'นน.เหล็กยืน (kg)' idx 11 (หลังเพิ่ม 'ชั้น/ช่วง'+'ตำแหน่ง (กริด)') · ‼️ เดิม [12] ชี้ผิดไป 'จำนวนปลอก' (บั๊กจากการจัดเรียง header ใหม่)
  // ‼️ เหล็กหลักคาน (kg) = น.น.เหล็กรวม [25] − นน.เหล็กปลอก [20] (b_header · รวมแถวที่อ่านสเปกไม่ได้ใช้ค่า rebar_kg)
  //    เดิมชี้ [15] = "ความยาวเหล็กล่าง (m)" (เมตรถูกนับเป็น kg · เหล็กบนหาย) และปลอกชี้ [17] = ช่องสเปก (ข้อความ = 0 เสมอ)
  //    → รวมเหล็กเสริมในชีตสรุปต่ำกว่าจริง ไม่ตรงกับยอดแยกขนาด (แก้ 2026-11-16)
  const r_bm  = n2((Number(b_total[25])||0) - (Number(b_total[20])||0));
  // ปลอกเสา+คาน คิดจากเรขาคณิตจริง (แทนการเดา 15% ของเหล็กรวม)
  const r_ties = n2((Number(c_total[15])||0) + (Number(b_total[20])||0) + footTiesKg);   // เสาปลอก c[15] (นน.เหล็กปลอก หลังเพิ่มกริด) + คานปลอก b[20] (นน.เหล็กปลอก) + เหล็กรัดฐานราก
  // ── พื้น: เดิมไม่ถูกนับใน calcTotals เลย (เหล็ก+ไม้แบบหาย) → คิดแยกแล้วบวกกลับ ──
  // ‼️ ดัชนีอัปเดตหลังเพิ่มคอลัมน์ slabs_cip (เฟส A+B) · เดิม [13]/[11]/[9] ชี้ผิด (ลูกปูน/คอนกรีต/ความยาว) = บั๊กเก่า
  const r_slab   = n2(Number(sc_sum[SCI('น.น.เหล็กรวม (kg)')])||0);                                  // เหล็กพื้นหล่อในที่ รวม (kg) = idx23 นน.เหล็กรวม (ล่าง+บน+ตะแกรง)
  const f_slab   = n2((Number(sc_sum[SCI('ไม้แบบ (ม²)')])||0) + sp_totalForm);                 // ไม้แบบพื้น (CIP idx19 + สำเร็จ)
  const a_slabCip = n2(cipRows.reduce((s,r)=> s + (Number(r.B)||0)*(Number(r.L)||0)*(Number(r.count||r.qty)||1), 0));  // พื้นที่พื้นหล่อในที่ = ΣB×L×n
  // ── เหล็กแยกตามขนาด (เรียงขนาดใหญ่→เล็ก) — ครอบคลุม เสา/คาน/พื้น ที่คิดในโค้ด ──
  const steelRows = Object.values(steel).filter(x => x.len > 0).sort((a,b)=> b.d - a.d);
  const steelLen = n2(steelRows.reduce((s,x)=>s+x.len,0));
  const beamRoleSum  = beamRoleKg.top+beamRoleKg.top_add+beamRoleKg.top_sup+beamRoleKg.bot+beamRoleKg.bot_mid;
  const stairRoleSum = stairRoleKg.main+stairRoleKg.dist+stairRoleKg.top+stairRoleKg.step;
  const c_tiesKg = n2(Number(c_total[15])||0), b_tiesKg = n2(Number(b_total[20])||0);
  const beamGap = 'บางรายการอ่านสเปกเหล็กไม่ได้ — ยอดรวมใช้ค่าประมาณ (รายการย่อยด้านล่างไม่ครบ)';
  const BAR_TH = { DB:'ข้ออ้อย', RB:'กลม', 'Ø':'' };
  const s_header = ['หมวด','รายการ','ปริมาณ','หน่วย','หมายเหตุ'];
  // แถวสรุปงานโครงสร้าง (ใช้ใน section ก. ของ Sheet 11)
  const structSummaryRows = [
    TG('ฐานราก', D(['1. งานดิน','ขุดดินฐานราก',                    n2(totals.excavation),'ม³',''])),
    TG('ฐานราก', D(['','ทรายอัดแน่นใต้ Lean',                       n2(totals.sand),      'ม³',''])),
    TG('ฐานราก', D(['2. คอนกรีตหยาบ','Lean Concrete 1:3:5',         n2(totals.lean),      'ม³',''])),
    TG('ฐานราก', D(['3. คอนกรีตโครงสร้าง','ฐานราก',               n2(totals.c_footing), 'ม³',''])),
    TG('เสา', D(['','เสา',                                        n2(totals.c_column),  'ม³',''])),
    TG('คาน', D(['','คาน',                                        n2(totals.c_beam),    'ม³',''])),
    TG('พื้นโครงสร้าง', D(['','พื้นหล่อในที่',                              n2(totals.c_slab_cip),    'ม³',''])),
    TG('บันได', D(['','บันได',                                      n2(st_cTotal),        'ม³',''])),
    TG('พื้นโครงสร้าง', D(['','Topping พื้นสำเร็จ',                        n2(totals.c_slab_topping),'ม³','หนา '+n2((precastRows[0]?.topping_t||0.05)*100)+' ซม.'])),
    TT(['','รวมคอนกรีตทั้งหมด (รวม Topping)',          n2(totals.c_total + st_cTotal), 'ม³','']),
    TG('ฐานราก', D(['4. เหล็กเสริม','ฐานราก (ตะแกรงล่าง+บน)',     n2(r_foot),                'kg',(footTopKg>0?'ตะแกรงบน '+footTopKg+' kg · ':'')+'ตะแกรง 2 ทิศ · หุ้ม '+n2((R.footCover!=null?R.footCover:0.05)*100)+' ซม.'+(footAiKg>0?' · '+n2(footAiKg)+' kg ยังใช้ค่า SwiftBill':'')])),
    TG('เสา', D(['','เสา',                                        n2(r_col + c_tiesKg),      'kg',''])),
    TG('เสา', D(['','  – เหล็กยืน',                               n2(r_col),                 'kg','n×(สูง + 40d + 12d)'])),
    TG('เสา', D(['','  – เหล็กปลอก',                              c_tiesKg,                  'kg','n=ceil(สูง/@) × (เส้นรอบรูป−หุ้ม + 2×12d)'])),
    TG('คาน', D(['','คาน',                                        n2(r_bm + b_tiesKg),       'kg', beamRoleSum < r_bm-0.5 ? beamGap : ''])),
    TG('คาน', D(['','  – เหล็กบน',                                n2(beamRoleKg.top),        'kg','วิ่งตลอด: ยาว + 40d + 12d'])),
    TG('คาน', D(['','  – เหล็กบนเสริม',                           n2(beamRoleKg.top_add),    'kg','วิ่งตลอด'])),
    TG('คาน', D(['','  – เหล็กบนหัวเสา',                          n2(beamRoleKg.top_sup),    'kg','ช่วงลบ 0.50L + 2×12d'])),
    TG('คาน', D(['','  – เหล็กล่าง',                              n2(beamRoleKg.bot),        'kg','วิ่งตลอด: ยาว + 40d + 12d'])),
    TG('คาน', D(['','  – เหล็กล่างกลางช่วง',                      n2(beamRoleKg.bot_mid),    'kg','0.80L + 2×12d'])),
    TG('คาน', D(['','  – เหล็กปลอก',                              b_tiesKg,                  'kg','n=ceil(ยาว/@) × (เส้นรอบรูป−หุ้ม + 2×12d)'])),
    TG('พื้นโครงสร้าง', D(['','พื้นหล่อในที่',                              n2(r_slab),                'kg','ตะแกรง 2 ทิศ'])),
    TG('บันได', D(['','บันได',                                      n2(st_rTotal),             'kg', stairRoleSum < st_rTotal-0.5 ? beamGap : ''])),
    TG('บันได', D(['','  – เหล็กหลัก',                              n2(stairRoleKg.main),      'kg','ตามลาด+ชานพัก + 40d + 12d'])),
    TG('บันได', D(['','  – เหล็กบน (2 ปลาย)',                       n2(stairRoleKg.top),       'kg','ตามช่อง "ยาวเหล็กบน/ปลาย" (แบบไม่ระบุ = ¼ ลาด)'])),
    TG('บันได', D(['','  – เหล็กขั้น + จมูกขั้น',                   n2(stairRoleKg.step),      'kg','ทุกขั้น (ลูกตั้ง+ลูกนอน+2×12d) · จมูก (กว้าง−2หุ้ม)'])),
    TG('บันได', D(['','  – เหล็กแจกจ่าย',                           n2(stairRoleKg.dist),      'kg','ตั้งฉาก (กว้าง−2หุ้ม + 2×12d)'])),
    TG('ฐานราก', D(['','เหล็กรัดฐานราก',                            f_hasTies ? footTiesKg : '-', 'kg', f_hasTies ? 'n=ceil(L/@) × (เส้นรอบรูป B×T−หุ้ม + 2×12d)' : 'ไม่มีสเปกเหล็กรัด/อ่านสเปกไม่ได้'])),
    TT(['','รวมเหล็กเสริม',                             n2(r_foot + r_col + r_bm + r_slab + st_rTotal + r_ties), 'kg','']),
    D(['','ความยาวเหล็กรวม (เหล็กเสริมทั้งหมด)', n2(steelLen),           'เมตร','แยกขนาด+จำนวนเส้น ดูชีตสรุปวัสดุสั่งซื้อ']),
    ...steelRows.map(x => D(['','  – '+x.t+x.d+(BAR_TH[x.t]?' ('+BAR_TH[x.t]+')':''), n2(x.len), 'เมตร', n2(x.kg)+' kg'])),
    TG('พื้นโครงสร้าง', D(['5. พื้น','พื้นสำเร็จรูป (Solid Plank)',        n2(sp_totalArea),          'ม²',''])),
    TG('พื้นโครงสร้าง', D(['','พื้นหล่อในที่',                              n2(a_slabCip),             'ม²',''])),
    TG('พื้นโครงสร้าง', D(['','เหล็กเสริม Topping',                        n2(sp_totalArea),           'ม²',sp_rebarLabel])),
    TG('ฐานราก', D(['6. ไม้แบบ','ฐานราก',                          n2(totals.f_footing), 'ม²',''])),
    TG('เสา', D(['','เสา',                                        n2(totals.f_column),  'ม²',''])),
    TG('คาน', D(['','คาน',                                        n2(totals.f_beam),    'ม²',''])),
    TG('พื้นโครงสร้าง', D(['','พื้น (ท้องพื้น+ขอบ)',                       n2(f_slab),           'ม²',''])),
    TG('บันได', D(['','บันได',                                      n2(st_fTotal),        'ม²',''])),
    TT(['','รวมไม้แบบทั้งหมด',                          n2(totals.f_total + f_slab + st_fTotal), 'ม²','']),
    ...(st_hrTotal > 0
      ? [TG('บันได', D(['','ราวกันตกบันได', n2(st_hrTotal), 'เมตร', 'ตามลาด × จำนวนข้าง'+(stairRows.find(r=>r.handrail_type)? ' · '+stairRows.find(r=>r.handrail_type).handrail_type : '')]))]
      : []),
    // ‼️ เดิมชี้ r_total[2]/[4] (ว่าง = 0 เสมอ) — แก้ 2026-10-19
    TG('หลังคา', D(['7. หลังคา','พื้นที่ฉายราบ',                   n2(r_total[8]||0),    'ม²',''])),
    TG('หลังคา', D(['','พื้นที่จริง (ลาดเอียง)',                   n2(r_total[9]||0),    'ม²',''])),
    TG('หลังคา', D(['','น้ำหนักโครงเหล็กรวม',                     n2(roofSteelKg),      'kg', rm_data.length>0?'รวมจาก '+rm_data.length+' ชนิดสมาชิก':'จาก schedule'])),
    ...(rm_data.length>0 ? rm_data.map(m=>TG('หลังคา', D(['','  - '+m[0]+' ('+m[1]+')', n2(Number(m[6])), 'kg', 'ยาว '+m[5]+' ม.']))) : []),
    ...(ss_kgTotal > 0
      ? [TG('บันได', D(['8. บันไดเหล็ก','น้ำหนักโครงเหล็กบันได', n2(ss_kgTotal), 'kg', 'รวมแผ่นพื้น/ตะแกรง · แยกรายสมาชิก ดูชีตบันไดเหล็ก']))]
      : []),
  ];
  // ‼️ ชีต "สรุปโครงสร้าง" ถูกลบ — เนื้อหาซ้ำ 100% กับ section ก. ของ "สรุปรวมทุกสาย"
  // (ใช้ structSummaryRows ก้อนเดียวกัน) · NOTE เฉพาะโครงสร้างถูกย้ายไปท้าย master แล้ว

  // Sheet 02: สรุปรวมทุกสาย (master roll-up วางหน้าสุด — section เฉพาะสายที่มีข้อมูล = ที่ผู้ใช้เลือก)
  const anyDisc = hasStructural || hasArch || hasSani || hasElec;
  if (anyDisc) {
    const sumRows = [ T('สรุปรวมทุกสายงาน (BOM Master Summary)'), BL(), H(s_header) ];
    if (hasStructural) sumRows.push(SB('ก. งานโครงสร้าง'),   ...structSummaryRows);
    if (hasArch)       sumRows.push(SB('ข. งานสถาปัตยกรรม'), ...archSummaryRows);
    if (hasSani)       sumRows.push(SB('ค. งานสุขาภิบาล'),   ...saniSummaryRows);
    if (hasElec)       sumRows.push(SB('ง. งานไฟฟ้า'),       ...elecSummaryRows);
    sumRows.push(BL(), SB('หมายเหตุ'),
      NOTE('• ปริมาณนี้ยังไม่คำนวณราคา · ปริมาณสั่งซื้อ (รวม Wastage) ดูชีต "สรุปวัสดุสั่งซื้อ"'));
    if (hasStructural) sumRows.push(
      NOTE('• น้ำหนักเหล็กรวมระยะดัดงอ + ระยะทาบแล้ว (lap=40D, hook=12D)'),
      NOTE('• แนะนำ Wastage: เหล็ก +7%, คอนกรีต +5%, ไม้แบบ +10%'));
    sumRows.push(NOTE(`• ถอดโดย SwiftBill จากแบบ "${project.name}" — ${today}`));
    buildAndStyle(wb, 'สรุปรวมทุกสาย', selRows(sumRows), [16,28,12,8,24]);
  }

  // ── Sheet 03: สรุปวัสดุสั่งซื้อ (รวม Wastage) — ทั้ง 4 สายในชีตเดียว ──
  // เดิมแยก 4 ชีต (สรุปวัสดุโครงสร้าง / สรุปสถาปัตย์ / สรุปสุขาภิบาล / สรุปไฟฟ้า)
  // ทั้งหมดใช้ 7 คอลัมน์เดียวกันอยู่แล้ว → ยุบเป็นชีตเดียว แบ่ง section ก./ข./ค./ง. ให้ตรงกับ "สรุปรวมทุกสาย"
  const wasted = (v, pct) => n2(v*(1+pct/100));
  // รวมบันไดเข้ายอดวัสดุ (คอนกรีต fc'240 / เหล็ก / ไม้แบบ)
  const c240_all = totals.c_footing+totals.c_column+totals.c_beam+totals.c_slab_cip+st_cTotal;
  const r_main = r_foot + r_col + r_bm + r_slab + st_rTotal;   // เหล็กหลัก — โค้ดคิดทั้งหมด · fallback AI เฉพาะแถวที่ parse สเปกไม่ได้
  const r_all  = r_main + r_ties;                       // เหล็กทั้งหมด (ใช้คิดลวดผูก)
  const f_all  = totals.f_total + f_slab + st_fTotal;   // ไม้แบบทั้งหมด (รวมพื้น+บันได)
  // ‼️ กำลังอัดคอนกรีตตามแบบ (fc ของแต่ละแถว) — เดิมเขียน fc'=240 ตายตัว แม้แบบเป็น 210 (ลูกค้าสั่งของผิดเกรด)
  //    ค่าเดียว = ใช้ค่านั้น · หลายค่า = บอกให้ดูชีตรายละเอียด · ไม่มีข้อมูล = "ตามแบบ"
  const fcRows = [footingRows, colRows, beamRows, cipRows, stairRows].flat().filter(r => r && typeof r==='object');
  const fcSet = [...new Set(fcRows.map(r => Number(r.fc)).filter(v => v > 0))].sort((a,b)=>a-b);
  const fcMissing = fcSet.length > 0 && fcRows.some(r => !(Number(r.fc) > 0));
  const fcLbl = fcSet.length === 1 ? `fc'=${fcSet[0]} ksc` : fcSet.length > 1 ? `fc' ${fcSet.join('/')} ksc` : "ตามแบบ";
  // ชิ้นส่วนที่มีคอนกรีตจริง (ไม่เขียนชิ้นที่ไม่ได้เลือก/ไม่มี) — เดิม "ฐานราก+เสา+คาน+พื้นหล่อ+บันได" ตายตัว
  const cParts = [['ฐานราก',totals.c_footing],['เสา',totals.c_column],['คาน',totals.c_beam],['พื้นหล่อ',totals.c_slab_cip],['บันได',st_cTotal]]
    .filter(([,v]) => Number(v) > 0).map(([k]) => k).join('+') || '-';
  const fcNote = (fcSet.length > 1 ? ' · หลายกำลังอัด แยกดูในชีตรายละเอียด' : '')
    + (fcMissing ? ' · บางรายการแบบไม่ระบุกำลังอัด โปรดตรวจแบบก่อนสั่ง' : '');
  // ของสิ้นเปลือง (ลวดผูก/ลูกปูน/ตะปู/ไม้คร่าว) — ใช้ยอดเดียวกับ BOQ/หน้าราคา (price-match itemsForPricing: รวมรายแถวจาก SB_RECOMPUTE)
  //   เดิมคิดสูตรรวมแยกของไฟล์นี้ (1% ของเหล็ก / 4 ตัวต่อ ม² ไม้แบบ) → ไม่ตรง BOQ 2–3% · ไม่มี price-match = สูตรเดิม
  const consQty = (() => { try {
    const PM = window.sbPriceMatch; if(!(PM && PM.itemsForPricing)) return null;
    const list = PM.itemsForPricing(boqData).filter(i => i.category === 'งานสิ้นเปลืองโครงสร้าง');
    return re => { const it = list.find(i => re.test(String(i.name||''))); return it ? (Number(it.qty)||0) : null; };
  } catch(e){ return null; } })();
  const consOr = (re, fb) => { const v = consQty && consQty(re); return v!=null ? v : fb; };
  const cTie = n2(consOr(/^ลวดผูก/, r_all*0.01)), cSpacer = Math.ceil(consOr(/^ลูกปูน/, f_all*4));
  const cNail = n2(consOr(/^ตะปู/, f_all*0.3)), cBatten = n2(consOr(/^ไม้คร่าว/, f_all*1.2));
  const matLayout = [ T('สรุปวัสดุสำหรับสั่งซื้อ ทุกสายงาน (รวม Wastage)'), BL(), H(MAT_HEAD) ];
  if (hasStructural) matLayout.push(
    SB('ก. งานโครงสร้าง'),
    TG('ฐานราก', D(['1. งานดิน-ทราย','ทรายอัดแน่นใต้ Lean', n2(totals.sand),   'ม³','5%', wasted(totals.sand,5),''])),
    TG('ฐานราก', D(['',  'ดินถมกลับ (ประมาณ)',    n2(totals.excavation*0.3),  'ม³','10%',wasted(totals.excavation*0.3,10),''])),
    TG('ฐานราก', D(['2. คอนกรีต','Lean Concrete 1:3:5', n2(totals.lean),       'ม³','5%', wasted(totals.lean,5),''])),
    D(['',  "คอนกรีตผสมเสร็จ "+fcLbl, n2(c240_all), 'ม³','5%', wasted(c240_all,5),cParts+fcNote]),
    TG('พื้นโครงสร้าง', D(['',  "คอนกรีตผสมเสร็จ fc'"+(precastRows[0]?.fc||210)+" ksc", n2(totals.c_slab_topping), 'ม³','5%', wasted(totals.c_slab_topping,5),'Topping พื้นสำเร็จ หนา '+n2((precastRows[0]?.topping_t||0.05)*100)+' ซม.'])),
    // ‼️ เหล็กแยกตามขนาดจริง — สั่งของได้ (DB12 กับ DB16 คนละของ คนละราคา)
    // ปริมาณหลัก = "เมตร" เพราะเหล็กไทยขายเป็นเส้น 10 ม. · น้ำหนัก kg อยู่ในหมายเหตุ
    ...(steelRows.length > 0
      ? steelRows.map((x,i) => D([
          i===0 ? '3. เหล็กเสริม' : '',
          `เหล็ก ${x.t}${x.d}${BAR_TH[x.t] ? ' ('+BAR_TH[x.t]+')' : ''}`,
          n2(x.len), 'เมตร', '7%', wasted(x.len,7),
          `${n2(x.kg)} kg · สั่ง ${Math.ceil(wasted(x.len,7)/barLenOf(x.t,x.d))} เส้น (${barLenOf(x.t,x.d)} ม.)`
        ]))
      : [D(['3. เหล็กเสริม','เหล็กเสริม (อ่านสเปกไม่ได้ — ใช้ค่าประมาณ)', n2(r_main+r_ties), 'kg','7%', wasted(r_main+r_ties,7),'ไม่มีข้อมูลแยกขนาด'])]),
    // เหล็กฐานราก/บันไดที่อ่านสเปกได้ เข้ารายการแยกขนาดด้านบนแล้ว — เหลือเฉพาะส่วนที่ parse ไม่ได้ที่ยังต้องแยกเป็นก้อน
    ...(footAiKg + footTieAiKg > 0
      ? [TG('ฐานราก', D(['',  'เหล็กฐานราก (อ่านสเปกไม่ได้ — ใช้ค่าประมาณ)', n2(footAiKg + footTieAiKg), 'kg','7%', wasted(footAiKg + footTieAiKg,7),'ไม่ทราบขนาดเหล็ก — ตรวจสเปกในชีตฐานรากก่อนสั่งซื้อ']))]
      : []),
    ...(stairAiKg > 0
      ? [TG('บันได', D(['',  'เหล็กบันได (อ่านสเปกไม่ได้ — ใช้ค่าประมาณ)', n2(stairAiKg), 'kg','7%', wasted(stairAiKg,7),'ไม่ทราบขนาดเหล็ก — ตรวจสเปกในชีตบันไดก่อนสั่งซื้อ']))]
      : []),
    D(['',  'ลวดผูก #18',              cTie,   'kg','10%',wasted(cTie,10),'~1% ของเหล็กรวม']),
    D(['',  'ลูกปูน (หนุนระยะหุ้มเหล็ก)', cSpacer, 'ตัว','10%', Math.ceil(cSpacer*1.1),'~4 ตัว/ม² ของพื้นที่ไม้แบบ · ระยะหุ้ม 2.5 ซม.']),
    D(['4. ไม้แบบ','ไม้แบบเรียบ (ไม้อัด)', n2(f_all),      'ม²','10%',wasted(f_all,10),'']),
    D(['',  'ไม้คร่าว 2"×3"',          cBatten,    'เมตร','10%',wasted(cBatten,10),'~1.2 ม./ม²']),
    D(['',  'ตะปู',                    cNail,    'kg','10%',wasted(cNail,10),'~0.3 kg/ม²']),
    ...(st_hrTotal > 0
      ? [TG('บันได', D(['5. ราวกันตก', 'ราวกันตกบันได'+(stairRows.find(r=>r.handrail_type)? ' ('+stairRows.find(r=>r.handrail_type).handrail_type+')' : ''),
            n2(st_hrTotal), 'เมตร','5%', wasted(st_hrTotal,5),'ตามลาด × จำนวนข้าง']))]
      : []),
    TG('พื้นโครงสร้าง', D(['5. พื้นสำเร็จรูป','Solid Plank', n2(sp_totalArea),         'ม²','3%', wasted(sp_totalArea,3),''])),
    TG('พื้นโครงสร้าง', D(['',  sp_rebarLabel+' (Topping)',n2(sp_totalArea),           'ม²','5%', wasted(sp_totalArea,5),'เสริม Topping'])),
    ...(rm_data.length > 0
      ? rm_data.map((m,i) => TG('หลังคา', D([
          i===0 ? '6. หลังคา' : '',
          'โครงเหล็ก '+m[0]+' ('+m[1]+')',
          n2(Number(m[6])), 'kg', '5%', wasted(Number(m[6]),5),
          'ยาวรวม '+m[5]+' ม.'
        ])))
      : [TG('หลังคา', D(['6. หลังคา','โครงเหล็กรูปพรรณ', n2(roofSteelKg),'kg','5%',wasted(roofSteelKg,5),'จันทัน+แป+อกไก่+อะเส+ขื่อ']))]),
    // ‼️ บันไดเหล็กต้องเข้าชีตสั่งของด้วย ไม่งั้นเหล็กหายเงียบ (บทเรียนเดียวกับบันได คสล. ปี 2026-07-17)
    ...(ss_kgTotal > 0
      ? [TG('บันได', D(['7. บันไดเหล็ก','โครงเหล็กบันได (รูปพรรณ+แผ่นพื้น)', n2(ss_kgTotal),'kg','5%', wasted(ss_kgTotal,5),'แยกรายสมาชิก ดูชีตบันไดเหล็ก']))]
      : []),
    BL()
  );
  if (hasArch) matLayout.push(SB('ข. งานสถาปัตยกรรม'), ...archMat.map(orderRow), BL());
  if (hasSani) matLayout.push(SB('ค. งานสุขาภิบาล'),   ...saniMat.map(orderRow), BL());
  if (hasElec) matLayout.push(SB('ง. งานไฟฟ้า'),       ...elecMat.map(orderRow), BL());
  matLayout.push(SB('หมายเหตุ'),
    NOTE('• ปริมาณสั่งซื้อ = ปริมาณสุทธิ + Wastage (ยังไม่คำนวณราคา' + (hasArch ? ' · ผนังหักช่องเปิดตามจริงแล้ว' : '') + ')'));
  if (hasStructural) matLayout.push(
    NOTE('• Wastage: คอนกรีต +5%, เหล็กเสริม +7%, ไม้แบบ +10%, พื้นสำเร็จ +3%, โครงเหล็กหลังคา +5%'),
    NOTE('• คอนกรีต '+fcLbl+': '+cParts+(totals.c_slab_topping>0 ? ' | fc\'='+((precastRows[0]?.fc||210))+': Topping พื้นสำเร็จ' : '')),
    ...((rm_data.length || roofSteelKg>0) ? [NOTE('• โครงเหล็กหลังคา: แยกรายสมาชิก ดูรายละเอียดเพิ่มเติมที่ชีตหลังคา')] : []));
  if (hasArch) matLayout.push(
    NOTE('• Wastage สถาปัตย์: อิฐ/ปูนก่อ-ฉาบ +5%, กระเบื้อง/บัว +10%, ฝ้า +5% · ประตู-หน้าต่างนับเป็นชุด'));
  if (hasSani) matLayout.push(
    NOTE('• Wastage สุขาภิบาล: ท่อ +5% · ข้อต่อ/อุปกรณ์คิดแยกตามระบบ · ความยาวท่อที่อ่านไม่ได้แสดงเป็น 0 (โปรดตรวจ)'));
  if (hasElec) matLayout.push(
    NOTE('• Wastage ไฟฟ้า: สายไฟ +10% (เผื่อต่อ/ดัดโค้ง), ท่อร้อยสาย +5% · ความยาวที่อ่านไม่ได้แสดงเป็น 0 (โปรดตรวจ)'));
  matLayout.push(NOTE(`• ถอดโดย SwiftBill จากแบบ "${project.name}" — ${today}`));
  if (anyDisc) buildAndStyle(wb, 'สรุปวัสดุสั่งซื้อ', selRows(matLayout), MAT_COLS);

  // ── สัญลักษณ์ในแบบ (Legend) — สิ่งที่ AI อ่านได้จากตารางสัญลักษณ์/รายการประกอบแบบ ──
  // ‼️ ชีตนี้คือหลักฐานว่า AI เปิดตารางอ่านจริงไหม: ถ้าว่าง = ไม่ได้อ่าน (หรือแบบไม่มีตาราง)
  //    เทียบ "สเปกตามแบบ" กับสเปกในชีตรายละเอียด → จับได้ทันทีถ้า AI แต่งสเปกเอง
  const legendRows = Array.isArray(boqData?.legend) ? boqData.legend : [];
  //   ฉบับลูกค้า: ตัดคอลัมน์ "ชีตที่เกี่ยวข้อง" (คีย์ภายใน เช่น sanitary_ware) + หมายเหตุภายใน
  if (legendRows.length) buildAndStyle(wb, 'สัญลักษณ์ในแบบ', [
    T(CUST ? 'ตารางสัญลักษณ์ / รายการประกอบแบบ' : 'ตารางสัญลักษณ์ / รายการประกอบแบบ ที่ SwiftBill อ่านได้'),
    BL(),
    H(CUST ? ['รหัส/สัญลักษณ์','ความหมายตามแบบ','สเปกตามแบบ','แผ่นแบบ']
           : ['รหัส/สัญลักษณ์','ความหมายตามแบบ','สเปกตามแบบ (คำต่อคำ)','ชีตที่เกี่ยวข้อง','แผ่นแบบ']),
    ...legendRows.map(r => D(CUST ? [r.code||'-', r.meaning||'-', r.spec||'-', r.page_ref||'-']
      : [r.code||'-', r.meaning||'-', r.spec||'-', r.sheet_key||'-', r.page_ref||'-'])),
    ...(CUST ? [] : [
      BL(),
      SB('หมายเหตุ'),
      NOTE('ทุกรายการในชีตนี้ต้องมีแถวในชีตรายละเอียดของมัน — ที่นับในผังไม่เจอ ระบบเติมแถว count=0 พร้อมตีธงไว้ให้ตรวจ'),
      NOTE('‼️ ถ้าสเปกในชีตรายละเอียดไม่ตรงกับ "สเปกตามแบบ" ที่นี่ = SwiftBill แต่งสเปกเอง โปรดแก้ให้ตรงแบบ'),
      NOTE('ชีตนี้ว่าง/ไม่มี = SwiftBill ไม่ได้อ่านตารางสัญลักษณ์ หรือแบบไม่มีตาราง — ปริมาณที่ได้จะเป็นการเดา โปรดตรวจ'),
    ]),
  ], CUST ? [18,34,40,14] : [18,30,34,18,14]);

  // ‼️ ปร.4/ปร.5 (ราคา/กำไร/ภาษี) แยกเป็นไฟล์ที่ 2 ผ่าน generatePricingExcel() — ไม่รวมในไฟล์ BOM วัสดุนี้
  //    (ผู้ใช้ต้องการ 2 ไฟล์: (1) BOM วัสดุตามหมวด = ไฟล์นี้ · (2) ใบราคา ปร.4/ปร.5)

  // ── จัดลำดับแท็บตามสายงาน (ชื่อชีตไม่มีเลข จึงเรียงด้วย SHEET_ORDER) ──
  const SHEET_ORDER = [
    'ข้อมูลโครงการ', 'สรุปรวมทุกสาย', 'สรุปวัสดุสั่งซื้อ', 'สัญลักษณ์ในแบบ',
    'ฐานราก', 'เสา', 'คาน', 'พื้นโครงสร้าง', 'บันได', 'บันไดไม้', 'บันไดเหล็ก', 'หลังคา',
    'ผนัง', 'ประตูหน้าต่าง', 'งานตกแต่งผิว',
    'สุขภัณฑ์-ถัง-ปั๊ม', 'ท่อสุขาภิบาล',
    'อุปกรณ์ไฟฟ้า', 'สายไฟท่อร้อยสาย',
  ];
  wb.SheetNames.sort((a,b)=>{ const ia=SHEET_ORDER.indexOf(a), ib=SHEET_ORDER.indexOf(b); return (ia<0?999:ia)-(ib<0?999:ib); });

  // ── Save ─────────────────────────────────────────────────────
  const safe = (project.name||'BOM').replace(/[\\/:*?"<>|]/g,'_');
  X.writeFile(wb, CUST ? `BOM_${safe}.xlsx` : `BOM_ฉบับเต็ม_${safe}.xlsx`);   // ฉบับเต็ม (admin/ตรวจงาน) ชื่อแยก ไม่ปนกับฉบับลูกค้า
}

// อ่านจำนวนเงินเป็นตัวอักษรไทย (รองรับหลักล้าน + สตางค์) — ใช้ใน ปร.5 + ใบปะหน้า BOQ 3 ชีต
function sbBahtText(num){
  num = Math.round((Number(num)||0)*100)/100;
  if(!(num>0)) return 'ศูนย์บาทถ้วน';
  const dg=['','หนึ่ง','สอง','สาม','สี่','ห้า','หก','เจ็ด','แปด','เก้า'], pl=['','สิบ','ร้อย','พัน','หมื่น','แสน'];
  const grp = (s) => { let r=''; const L=s.length;
    for(let i=0;i<L;i++){ const d=+s[i], pos=L-1-i; if(!d) continue;
      if(pos===0){ r += (d===1 && L>1) ? 'เอ็ด' : dg[d]; }
      else if(pos===1){ r += (d===1?'สิบ':(d===2?'ยี่สิบ':dg[d]+'สิบ')); }
      else r += dg[d]+pl[pos]; }
    return r; };
  const baht=Math.floor(num), satang=Math.round((num-baht)*100);
  let bs=String(baht), groups=[]; while(bs.length>6){ groups.unshift(bs.slice(-6)); bs=bs.slice(0,-6); } groups.unshift(bs);
  let txt=''; for(let g=0;g<groups.length;g++){ const p=grp(groups[g]); if(p||g<groups.length-1) txt+=p; if(g<groups.length-1) txt+='ล้าน'; }
  txt=(txt||'ศูนย์')+'บาท';
  txt += satang>0 ? grp(String(satang))+'สตางค์' : 'ถ้วน';
  return txt;
}
window.sbBahtText = sbBahtText;

/* ===================== ไฟล์ที่ 2: ใบราคา ปร.4 / ปร.5 =====================
   แยกจากไฟล์ BOQ ปริมาณ — สร้างเฉพาะเมื่อผู้ใช้ยืนยันจับคู่ราคาแล้ว (boqData.pricing)
   self-contained (helper สไตล์ของตัวเอง) เพื่อไม่แตะ generateBOQExcel ที่ทำงานดีอยู่
   คืน true เมื่อสร้างไฟล์สำเร็จ · false เมื่อไม่มีข้อมูลราคา (ให้ผู้เรียกแจ้งผู้ใช้) */
function generatePricingExcel(project, boqData) {
  const X = window.XLSX;
  if (!X) { alert('ไลบรารี Excel ยังโหลดไม่เสร็จ'); return false; }
  const P = boqData && boqData.pricing;
  if (!(P && Array.isArray(P.rows) && P.rows.length)) return false;

  const n2 = v => Math.round((Number(v)||0)*100)/100;
  const today = new Date().toLocaleDateString('th-TH',{year:'numeric',month:'long',day:'numeric'});
  const thin = c => ({ style:'thin', color:{ rgb:c } });
  const BORDER = c => ({ top:thin(c), bottom:thin(c), left:thin(c), right:thin(c) });
  const STYLE = {
    title:   { font:{bold:true,sz:14,color:{rgb:'FFFFFF'}}, fill:{fgColor:{rgb:'1F4E79'}}, alignment:{horizontal:'center',vertical:'center'} },
    sub:     { font:{bold:true,sz:11,color:{rgb:'1F4E79'}}, fill:{fgColor:{rgb:'DDEBF7'}}, alignment:{horizontal:'left',vertical:'center',indent:1} },
    head:    { font:{bold:true,sz:10,color:{rgb:'FFFFFF'}}, fill:{fgColor:{rgb:'2E75B6'}}, alignment:{horizontal:'center',vertical:'center',wrapText:true}, border:BORDER('9DC3E6') },
    cell:    { font:{sz:10,color:{rgb:'1A2A3A'}}, alignment:{vertical:'center'}, border:BORDER('BDD7EE') },
    cellAlt: { font:{sz:10,color:{rgb:'1A2A3A'}}, fill:{fgColor:{rgb:'F2F8FD'}}, alignment:{vertical:'center'}, border:BORDER('BDD7EE') },
    section: { font:{bold:true,sz:10,color:{rgb:'1F4E79'}}, fill:{fgColor:{rgb:'EAF1FB'}}, alignment:{vertical:'center'}, border:BORDER('BDD7EE') },
    total:   { font:{bold:true,sz:10,color:{rgb:'7A5C00'}}, fill:{fgColor:{rgb:'FFE699'}}, alignment:{vertical:'center'}, border:BORDER('BF9000') },
    note:    { font:{italic:true,sz:9,color:{rgb:'94A3B8'}}, alignment:{vertical:'center'} },
    info:    { font:{sz:10,color:{rgb:'1A2A3A'}}, alignment:{horizontal:'left',vertical:'center'} },
  };
  const RIGHT = { alignment:{horizontal:'right',vertical:'center'} };
  // ทศนิยมเกิน 2 ตำแหน่ง (ราคาต่อหน่วยที่ฝังค่าเผื่อวัสดุ เช่น 3.745) → แสดงได้ถึง 4 ตำแหน่ง ให้จำนวน×ราคา/หน่วย = จำนวนเงิน
  //   ทุกช่องตัวเลข 2 ตำแหน่งเสมอ (เดิมจำนวนเต็มไม่มีทศนิยม → คอลัมน์เดียวกันมี "2,247" ปน "2,300.50") · ลำดับ (คอลัมน์แรก) ไม่มีทศนิยม
  //   ช่องที่ต้องการจำนวนเต็ม (จำนวนชิ้น · ปัดเศษ) กำหนดรายแถวผ่าน row.z
  const numFmt = (v, c) => c===0 ? '#,##0' : (Math.abs(v*100 - Math.round(v*100)) > 1e-6 ? '#,##0.00##' : '#,##0.00');
  const INTF = '#,##0';
  const qFmt = (q, u) => (Number.isInteger(q) && /ชุด|ตัว|จุด|ต้น|บาน|แผ่น|เส้น|ถุง|กล่อง|ใบ|ชิ้น|อัน|ดวง|เครื่อง|ลูก|ท่อน|ม้วน|ถัง/.test(String(u||''))) ? INTF : null;
  const n4 = v => Math.round((Number(v)||0)*10000)/10000;
  const T=(...c)=>({r:'title',c}), SB=(...c)=>({r:'sub',c}), H=c=>({r:'head',c}),
        D=c=>({r:'data',c}), SEC=c=>({r:'section',c}), TT=c=>({r:'total',c}),
        ZD=(z,c)=>({r:'data',c,z}), ZT=(z,c)=>({r:'total',c,z}),   // + รูปแบบตัวเลขรายช่อง {คอลัมน์: format}
        NOTE=(...c)=>({r:'note',c}), INFO=(...c)=>({r:'info',c}), BL=()=>({r:'blank',c:[]});

  const bahtText = sbBahtText;   // อ่านจำนวนเงินเป็นตัวอักษรไทย (ใช้ร่วมกับ BOQ 3 ชีต — excel-boq.jsx)
  const clean = sbCleanTxt;      // ตัดคำภายใน ("(6 ชิ้นส่วน)", "ราคาเดิมในไฟล์") ออกจากชื่อ/สเปกที่ลูกค้าเห็น
  const tplName = sbTplLabel(P);

  function setStyle(ws, r, c, style, z){ const a=X.utils.encode_cell({r,c}); if(!ws[a])ws[a]={t:'s',v:''}; ws[a].s=style; if(z)ws[a].z=z; }
  function ensureRow(ws, r, ncol){ for(let c=0;c<ncol;c++){ const a=X.utils.encode_cell({r,c}); if(!ws[a])ws[a]={t:'s',v:''}; }
    const range=X.utils.decode_range(ws['!ref']); if(r>range.e.r)range.e.r=r; if(ncol-1>range.e.c)range.e.c=ncol-1; ws['!ref']=X.utils.encode_range(range); }
  function buildAndStyle(wb, name, rows, colWidths, extraMerges){
    const ncol=colWidths.length;
    const ws=X.utils.aoa_to_sheet(rows.map(row=>row.r==='blank'?[]:row.c));
    ws['!cols']=colWidths.map(w=>({wch:w}));
    const merges=[], rowHeights=[]; let zebra=0;
    rows.forEach((row,ri)=>{ const role=row.r; if(role==='head')zebra=0;
      if(role==='blank'){ rowHeights[ri]={hpt:6}; return; }
      if(role==='title'){ merges.push({s:{r:ri,c:0},e:{r:ri,c:ncol-1}}); rowHeights[ri]={hpt:26}; ensureRow(ws,ri,ncol); for(let c=0;c<ncol;c++)setStyle(ws,ri,c,STYLE.title); }
      else if(role==='sub'){ merges.push({s:{r:ri,c:0},e:{r:ri,c:ncol-1}}); rowHeights[ri]={hpt:18}; ensureRow(ws,ri,ncol); for(let c=0;c<ncol;c++)setStyle(ws,ri,c,STYLE.sub); }
      else if(role==='info'){ merges.push({s:{r:ri,c:0},e:{r:ri,c:ncol-1}}); ensureRow(ws,ri,ncol); for(let c=0;c<ncol;c++)setStyle(ws,ri,c,STYLE.info); }
      else if(role==='head'){ rowHeights[ri]={hpt:22}; ensureRow(ws,ri,ncol); for(let c=0;c<ncol;c++)setStyle(ws,ri,c,STYLE.head); }
      else if(role==='data'){ const base=(zebra%2===1)?STYLE.cellAlt:STYLE.cell; zebra++; ensureRow(ws,ri,ncol);
        for(let c=0;c<ncol;c++){ const v=row.c[c]; if(typeof v==='number')setStyle(ws,ri,c,{...base,...RIGHT},(row.z&&row.z[c])||numFmt(v,c)); else setStyle(ws,ri,c,base); } }
      else if(role==='section'){ rowHeights[ri]={hpt:19}; ensureRow(ws,ri,ncol); for(let c=0;c<ncol;c++)setStyle(ws,ri,c,STYLE.section); }
      else if(role==='total'){ rowHeights[ri]={hpt:20}; ensureRow(ws,ri,ncol);
        for(let c=0;c<ncol;c++){ const v=row.c[c]; if(typeof v==='number')setStyle(ws,ri,c,{...STYLE.total,...RIGHT},(row.z&&row.z[c])||numFmt(v,c)); else setStyle(ws,ri,c,STYLE.total); } }
      else if(role==='note'){ merges.push({s:{r:ri,c:0},e:{r:ri,c:ncol-1}}); ensureRow(ws,ri,ncol); for(let c=0;c<ncol;c++)setStyle(ws,ri,c,STYLE.note); }
    });
    ws['!merges']=(ws['!merges']||[]).concat(merges, extraMerges||[]);
    ws['!rows']=rowHeights;
    X.utils.book_append_sheet(wb, ws, name);
  }

  const wb = X.utils.book_new();

  const groups = {}, order = [];
  P.rows.forEach(r => { const k = r.cat || 'อื่น ๆ'; if(!groups[k]){ groups[k]=[]; order.push(k); } groups[k].push(r); });
  const matDirect = P.matDirect!=null ? P.matDirect : P.direct;   // เผื่อ payload เก่า
  const laborDirect = P.laborDirect || 0;
  const laborPct = P.laborPct!=null ? P.laborPct : 0;
  const pc = P.pct || {};

  // ── เหล็กเส้น: แปลงน้ำหนัก (kg/ตัน) → จำนวนเส้นที่สั่ง (10/12 ม.) เพื่อโชว์คู่กันใน ปร.4 ──
  //   ‼️ ราคาคิดตามน้ำหนัก แต่ซื้อจริงนับเป็นเส้น → เมตรรวม = kg ÷ (d²/162) · เส้น = ceil(เมตร×เผื่อ7% ÷ ยาว/เส้น)
  //   คิดเฉพาะแถวที่มี "ขนาดเดียว" (DB12/RB6) · ผสมหลายขนาด / เหล็กรูปพรรณ(C,H) → ข้าม
  const barLenOf = (t, d) => (window.sbBarLen ? window.sbBarLen(t, d) : 10);
  function rebarBarsNote(r){
    const u = String(r.unit||'');
    let kg = 0;
    if(/ตัน|ton/i.test(u)) kg = (Number(r.qty)||0)*1000;
    else if(/กก|kg/i.test(u)) kg = Number(r.qty)||0;
    else return '';
    const nm = String(r.name||'');                                  // ชื่อรายการที่ถอด (มี DB12/RB6 หลังยุบตามขนาด)
    const ms = nm.match(/(DB|RB)\s*\d+(?:\.\d+)?/gi);
    if(!ms || ms.length!==1) return '';                             // ไม่มีขนาด/ผสมหลายขนาด → ไม่แปลง
    const m = ms[0].match(/(DB|RB)\s*(\d+(?:\.\d+)?)/i);
    const t = m[1].toUpperCase(), d = parseFloat(m[2]);
    if(!(kg>0) || !(d>0)) return '';
    const len = kg / (d*d/162);
    const bl = barLenOf(t, d);
    const bars = sbCeil(len*1.07 / bl);
    return `น้ำหนัก ${n2(kg)} กก. ≈ ${n2(len)} ม. → สั่ง ${bars} เส้น (${bl} ม.)`;
  }

  // ── ปร.4: บัญชีประมาณราคาค่าก่อสร้าง (ฟอร์มราชการ 10 คอลัมน์ หัวตาราง merge 2 แถว) ──
  const p4 = [
    T('แบบ ปร.4 — บัญชีประมาณราคาค่าก่อสร้าง'),
    INFO(`รายการประมาณราคาค่าก่อสร้าง        ประมาณราคาโดย SwiftBill`),
    INFO(`ประมาณราคา          ${project.name||'-'}`),
    INFO(`ปริมาณงาน           ${project.area? project.area+' ตร.ม.' : '-'}`),
    INFO(`สถานที่ก่อสร้าง       ${project.location||'-'}`),
    INFO(`ประมาณราคา ณ วันที่   ${today}        ฐานราคา: ${tplName}`),
    BL(),
  ];
  const hr = p4.length;                              // แถวหัวตาราง (2 แถว merge)
  // ‼️ คอลัมน์ที่ 11 "ที่มาราคา" ต่อท้าย (10 คอลัมน์แรกคงฟอร์มราชการเดิม) · payload เก่าไม่มี srcTag → ช่องว่าง
  //   ป้ายกำหนดที่นี่ (ไม่อ่าน P.basis.srcLabel) — payload เก่าเก็บ "แก้เอง" ไว้ · ไฟล์ลูกค้าใช้คำทางการ
  const SRC_LBL = { official:'ราคากลาง', shop:'ร้านค้า', est:'ประมาณการ', own:'ผู้ใช้กำหนด', none:'รอราคา' };
  const srcOf = r => r.srcTag ? (SRC_LBL[r.srcTag] || '') : '';
  p4.push(H(['ลำดับที่','รายการ','จำนวน','หน่วย','ราคาวัสดุสิ่งของ','','ค่าแรงงาน','','ค่าวัสดุและแรงงาน','หมายเหตุ','ที่มาราคา']));
  p4.push(H(['','','','','ราคาต่อหน่วย','จำนวนเงิน','ราคาต่อหน่วย','จำนวนเงิน','','','']));
  let secNo = 0;
  order.forEach(k => {
    p4.push(SEC([++secNo, k, '', '', '', '', '', '', '', '', '']));
    groups[k].forEach(r => {
      const total = (Number(r.amount)||0) + (Number(r.laborAmount)||0);
      const nm = clean((r.matched||r.name) + (r.matched && r.spec ? ' '+clean(r.spec) : ''));
      // ‼️ ราคาคิดต่อ "ตัน" แต่แสดงตันทศนิยม 2 ตำแหน่ง → จำนวน×ราคา/หน่วย ≠ จำนวนเงิน (ต่างได้ ~100 บาท/แถว)
      //    แสดงเป็น กก. + ราคาต่อ กก. แทน (เงินเท่าเดิม · ต่างจากการปัดแค่ระดับสตางค์)
      const isTon = /ตัน|ton/i.test(String(r.unit||''));
      const qShow = isTon ? n2((Number(r.qty)||0)*1000) : n2(r.qty), uShow = isTon ? 'กก.' : (sbUnitTh(r.unit)||'-');
      const upEff = r.unitPriceEff!=null ? r.unitPriceEff : r.unitPrice;
      const upShow = isTon ? n4((Number(upEff)||0)/1000) : n4(upEff);
      // ค่าแรงต่อหน่วย: หน่วยค่าแรง "ตัน" → แปลงเป็นต่อ กก. ให้ตรงช่องจำนวน · หน่วยค่าแรงต่างจากช่องจำนวน (เช่น กระเบื้อง แผ่น vs ค่าแรง ม²)
      //   → ระบุ อัตรา × ปริมาณค่าแรง ในหมายเหตุ ให้ลูกค้าคูณตรวจได้ (เดิมระบุเฉพาะค่าแรงเหมา — ค่าแรงตามอัตรา (auto) ไม่มี)
      let lUnit = String(r.laborUnit||''), lPer = r.laborPerUnit, lQty = r.laborQty;
      if (/ตัน|ton/i.test(lUnit) && lPer!=null) { lPer = lPer/1000; lQty = lQty!=null ? lQty*1000 : null; lUnit = 'กก.'; }
      lUnit = sbUnitTh(lUnit);
      const uKey = u => String(u||'').replace(/\s/g,'').replace(/^ตร\.?ม\.?$/,'ม²').replace(/^ลบ\.?ม\.?$/,'ม³').replace(/^กก\.?$/,'กก.').replace(/\.$/,'');
      const lDiff = !!lUnit && lPer!=null && uKey(lUnit)!==uKey(uShow);
      const laborPer = lPer!=null ? n4(lPer)
        : (r.laborBasis==='pct' && (Number(r.laborAmount)||0)>0 ? `${laborPct}%` : '—');
      const rateTxt = lDiff ? `ค่าแรง ${n2(lPer)}/${lUnit}` + (lQty!=null ? ` × ${n2(lQty)} ${lUnit}` : '') : '';
      // 'rate' = ผู้ใช้พิมพ์ราคาค่าแรง/หน่วยเองในตารางราคา (คิดต่อหน่วย BOQ เหมือนเหมา) — 2026-11-10
      const lumpNote = (r.laborBasis==='lump' || r.laborBasis==='rate' || r.laborBasis==='lumpAlloc')
        ? [r.laborBasis==='lump' ? 'ราคาช่าง (ผู้ใช้กำหนด)' : r.laborBasis==='lumpAlloc' ? 'เกลี่ยจากค่าแรงเหมา' : 'ค่าแรงผู้ใช้กำหนด', rateTxt].filter(Boolean).join(' ')
        : r.laborBasis==='auto' ? rateTxt
        : r.laborBasis==='lumpInc' ? 'ค่าแรงรวมในราคาช่างของงานนี้แล้ว'
        : (r.laborBasis==='pct' && !((Number(r.laborAmount)||0)>0)) ? 'ยังไม่มีค่าแรง'   // 2026-11-10 กันค่าแรงหายเงียบ
        : '';
      p4.push(ZD({ 2: qFmt(qShow, uShow) }, [ '', nm||'-', qShow, uShow,
        r.matchedFlag ? upShow : '—',   // ราคา/หน่วยฝังค่าเผื่อวัสดุแล้ว (แนวราชการ) · qty คงเป็น net
        r.priced ? n2(r.amount) : '—',
        laborPer,
        (Number(r.laborAmount)||0)>0 ? n2(r.laborAmount) : '—',
        total>0 ? n2(total) : '—',
        sbTxtUnits([rebarBarsNote(r), lumpNote, r.note].filter(Boolean).join(' · ')), srcOf(r) ]));
    });
  });
  p4.push(TT(['', 'รวมค่างานต้นทุน', '', '', '', n2(matDirect), '', n2(laborDirect), n2(P.direct), '', '']));
  if (P.unmatched > 0 || P.uncomputable > 0 || P.noPrice > 0) {
    p4.push(BL());
    if (P.unmatched > 0)    p4.push(NOTE(`หมายเหตุ: มี ${P.unmatched} รายการยังไม่ได้กำหนดราคา — ไม่รวมในยอด`));
    if (P.uncomputable > 0) p4.push(NOTE(`หมายเหตุ: มี ${P.uncomputable} รายการหน่วยราคาไม่ตรงกับหน่วยปริมาณงาน — ไม่รวมในยอด`));
    if (P.noPrice > 0)      p4.push(NOTE(`หมายเหตุ: มี ${P.noPrice} รายการยังไม่มีราคาต่อหน่วย — ไม่รวมในยอด`));
  }
  // เหมาทั้งงาน: ระบุยอดเหมาแต่ละก้อน (ตร.ม.ละ × พื้นที่ หรือยอดรวม) — ค่าแรงรายแถวในตารางคือยอดนี้ที่เกลี่ยตามสัดส่วน
  const LL = P.laborLump;
  const lumpOn = !!(LL && Array.isArray(LL.pools) && LL.pools.some(x => x.amount>0));
  // ‼️ แถวที่คิดค่าแรงเป็น % ของค่าวัสดุจริง ๆ — ไม่มี = ห้ามเขียน "ประมาณ 30%" (เดิมโผล่ทุกไฟล์แม้ใช้ค่าแรงเหมาทั้งหมด)
  const pctN = P.rows.filter(r => r.laborBasis==='pct' && (Number(r.laborAmount)||0)>0).length;
  if (lumpOn) LL.pools.filter(x => x.amount>0).forEach(x => p4.push(NOTE(`ค่าแรงเหมา — ${x.th}: ${LL.basis==='sqm' && x.rate ? `ตร.ม.ละ ${n2(x.rate).toLocaleString('en-US')} × ${n2(LL.area).toLocaleString('en-US')} ตร.ม. = ` : ''}${n2(x.amount).toLocaleString('en-US')} บาท (เกลี่ยลงทุกรายการตามสัดส่วนค่าแรงต่อหน่วย)`)));
  else {
    const labN = P.rows.filter(r => (Number(r.laborAmount)||0)>0).length;   // แถวที่มีค่าแรง
    p4.push(NOTE(labN>0 && pctN===labN ? `ค่าแรง: คิด ${laborPct}% ของค่าวัสดุ`
      : `ค่าแรง: คิดตามอัตราค่าแรงต่อหน่วย${(P.laborLumpN||0)>0 ? ` · ${P.laborLumpN} รายการใช้ราคาช่างที่ผู้ใช้กำหนด` : ''}${pctN>0 ? ` · ${pctN} รายการที่ไม่มีอัตราต่อหน่วยคิด ${laborPct}% ของค่าวัสดุ` : ''}`));
  }
  if ((P.wasteTotal||0) > 0) p4.push(NOTE(`ค่าเผื่อวัสดุ (Wastage) รวมอยู่ในราคาต่อหน่วยแล้ว รวม ${n2(P.wasteTotal).toLocaleString('en-US')} บาท (ช่องจำนวนเป็นปริมาณสุทธิ) — รายละเอียดดูชีตวิเคราะห์วัสดุเผื่อ`));
  if ((P.laborDraftN||0) > 0) p4.push(NOTE(`หมายเหตุ: มี ${P.laborDraftN} รายการใช้อัตราค่าแรงประมาณการ (เช่น งานกันซึม ปั๊ม-ถังน้ำ เสาเข็ม ราว บัว เชิงชาย) — ควรตรวจสอบกับราคาจริงก่อนยื่นราคา`));
  const p4merges = [ {s:{r:hr,c:4},e:{r:hr,c:5}}, {s:{r:hr,c:6},e:{r:hr,c:7}} ];
  [0,1,2,3,8,9,10].forEach(c => p4merges.push({s:{r:hr,c},e:{r:hr+1,c}}));
  buildAndStyle(wb, 'ปร.4 ราคาวัสดุ', p4, [7,34,9,8,13,14,13,14,15,18,11], p4merges);

  // ── ปร.5: สรุปผลการประมาณราคาก่อสร้างเป็นราคากลาง (ฟอร์มราชการ Factor F) ──
  //    2 โหมด: 'factorf' = Factor F ตารางราชการงานอาคาร (lookup) · 'manual' = แตก OH/กำไร/VAT เอง (= grand÷direct)
  const isFF = P.priceMode === 'factorf';
  const factorF = (isFF && P.factorF) ? P.factorF : (P.direct>0 ? P.grand/P.direct : 1);
  const ffc = P.factorFCond || {};
  const rounded = Math.round(P.grand/100)*100;          // ปัดเศษเป็นหลักร้อย
  const condRows = isFF ? [
    SEC(['','เงื่อนไข Factor F (ตารางงานก่อสร้างอาคาร สำนักงบประมาณ)','','','','']),
    D(['', `เงินล่วงหน้าจ่าย  ${ffc.advance!=null?ffc.advance:0}%`, '', '', '', '']),
    D(['', `เงินประกันผลงานหัก  ${ffc.retention!=null?ffc.retention:0}%`, '', '', '', '']),
    D(['', `ดอกเบี้ยเงินกู้  ${ffc.interest!=null?ffc.interest:6}%`, '', '', '', '']),
    D(['', `ภาษีมูลค่าเพิ่ม (VAT)  ${ffc.vat!=null?ffc.vat:7}%`, '', '', '', '']),
  ] : [
    SEC(['','เงื่อนไข (องค์ประกอบ Factor F)','','','','']),
    D(['', `ค่าดำเนินการ (Overhead)  ${pc.overhead||0}%`, '', '', '', '']),
    D(['', `กำไร  ${pc.profit||0}%`, '', '', '', '']),
    D(['', `ภาษีมูลค่าเพิ่ม (VAT)  ${pc.vat||0}%`, '', '', '', '']),
  ];
  const ffNote = isFF
    ? `Factor F = ${factorF.toFixed(4)} (ตาราง Factor F งานอาคาร สำนักงบประมาณ · เทียบค่างานต้นทุน ${n2(P.direct).toLocaleString('en-US')} บาท ระหว่างช่วงในตาราง · เงื่อนไข ล่วงหน้า ${ffc.advance!=null?ffc.advance:0}%/ประกัน ${ffc.retention!=null?ffc.retention:0}%/ดอกเบี้ย ${ffc.interest!=null?ffc.interest:6}%/VAT ${ffc.vat!=null?ffc.vat:7}%)`
    : `Factor F = รวมค่าก่อสร้าง ÷ ค่างานต้นทุน = ${factorF.toFixed(4)} (จากค่าดำเนินการ ${pc.overhead||0}% + กำไร ${pc.profit||0}% + VAT ${pc.vat||0}%)`;
  buildAndStyle(wb, 'ปร.5 สรุปราคา', [
    T('แบบ ปร.5 — สรุปผลการประมาณราคาก่อสร้างเป็นราคากลาง'),
    INFO(`ประเภทงาน           ${project.name||'-'}`),
    INFO(`สถานที่ก่อสร้าง       ${project.location||'-'}`),
    INFO(`ประมาณการตามแบบ ปร.4        ประมาณราคา ณ วันที่ ${today}`),
    BL(),
    H(['ลำดับที่','รายการ','รวมค่างานต้นทุน (บาท)','FACTOR F','รวมค่าก่อสร้าง (บาท)','หมายเหตุ']),
    ZD({ 3:'0.0000' }, [1, project.name||'-', n2(P.direct), Math.round(factorF*10000)/10000, n2(P.grand), '']),   // Factor F เป็นตัวเลข (เดิมข้อความ)
    BL(),
    ...condRows,
    BL(),
    TT(['', 'รวมค่าก่อสร้างเป็นเงินทั้งสิ้น', '', '', n2(P.grand), '']),
    ZT({ 4:INTF }, ['', 'ปัดเศษเป็น', '', '', rounded, '']),
    INFO(`(ตัวอักษร)  ${bahtText(rounded)}`),
    BL(),
    NOTE(ffNote),
    NOTE(`ค่างานต้นทุน = ค่าวัสดุ + ค่าแรง${lumpOn ? ' (ค่าแรงเหมาตามที่ระบุใน ปร.4)' : pctN>0 ? ` (${pctN} รายการที่ไม่มีอัตราค่าแรงต่อหน่วยคิด ${laborPct}% ของค่าวัสดุ)` : ''}`),
  ], [8,42,18,12,18,16]);

  // ── ใบสั่งซื้อวัสดุ (รวมข้ามหมวด + Wastage → ปริมาณสั่งซื้อ) ──
  //   ปร.4 แยกตามหมวดงาน (เสา/คาน/พื้น...) — วัสดุตัวเดียวกันจึงกระจายหลายแถว
  //   ชีตนี้ยุบวัสดุตัวเดียวกัน (ชื่อจับคู่+สเปก+หน่วยราคา ตรงกัน) ข้ามทุกหมวดเป็นบรรทัดเดียว
  //   แล้วบวก Wastage ตามชนิด → ปริมาณสั่งซื้อ (ปัดขึ้นตามหน่วย) × ราคา/หน่วย = มูลค่าสั่งซื้อ
  //   ‼️ วัสดุเท่านั้น (ค่าแรงไม่ใช่ของสั่งซื้อ) · เฉพาะรายการที่จับคู่ได้+หน่วยราคาคิดปริมาณได้ (กันบวกข้ามหน่วยผิดเงียบ)
  // ‼️ ตรรกะรวม/Wastage/decomposition อยู่ที่ window.sbBuildPurchase (data.jsx) — ใช้ร่วมกับหน้าจอ VE (กัน drift)
  //    % เผื่อ = ค่าที่ฝังในแถวราคา (r.wastePct · ตรงกับ ปร.4) · payload เก่าไม่มี → % ที่ผู้ใช้ปรับในเครื่อง (sb_waste_<projectId>)
  let wasteOv = null;
  try { const pid = project && project.id; if(pid) wasteOv = JSON.parse(localStorage.getItem('sb_waste_'+pid)||'null'); } catch(e){}
  const purchase = window.sbBuildPurchase ? window.sbBuildPurchase(P.rows, wasteOv)
    : { list:[], unmatched:0, noQty:0, totals:{net:0,wastage:0,roundup:0,over:0,grand:0} };
  const poList = purchase.list, poUnmatched = purchase.unmatched, poNoQty = purchase.noQty;

  const poCols = [6, 30, 20, 12, 8, 8, 14, 14, 16, 20];
  const poRows = [
    T('ใบสรุปวัสดุสำหรับสั่งซื้อ (รวมข้ามหมวด + เผื่อเสียหาย Wastage)'),
    INFO(`โครงการ  ${project.name||'-'}        ประมาณราคา ณ วันที่ ${today}`),
    INFO(`ฐานราคา: ${tplName}        (ปริมาณสั่งซื้อรวมค่าเผื่อวัสดุแล้ว · ราคาต่อหน่วยเป็นราคาสุทธิ)`),
    BL(),
    H(['ลำดับ','รายการวัสดุ','สเปก','ปริมาณสุทธิ','หน่วย','Wastage','ปริมาณสั่งซื้อ','ราคา/หน่วย (บาท)','รวมเงิน (บาท)','รวมจากหมวด']),
  ];
  let poNo = 0, poGrand = 0;
  poList.forEach(g => {
    poNo++; poGrand += g.amount;
    const pu = sbUnitTh(g.unit)||'-';
    poRows.push(ZD({ 3: qFmt(n2(g.net), pu), 6: qFmt(n2(g.orderQty), pu) }, [ poNo, clean(g.name), clean(g.spec)||'-', n2(g.net), pu, g.w+'%',
      n2(g.orderQty), g.unitPrice>0 ? n2(g.unitPrice) : '—', g.amount>0 ? n2(g.amount) : '—',
      g.cats.join(', ') || '-' ]));
  });
  if (poList.length === 0) poRows.push(D(['', 'ยังไม่มีรายการวัสดุที่มีราคาและปริมาณสำหรับสั่งซื้อ', '', '', '', '', '', '', '', '']));
  poRows.push(BL());
  poRows.push(TT(['', `รวมมูลค่าวัสดุสำหรับสั่งซื้อ (${poList.length} รายการ · รวม Wastage)`, '', '', '', '', '', '', n2(poGrand), '']));
  poRows.push(BL());
  poRows.push(SB('หมายเหตุ'));
  poRows.push(NOTE('• ปริมาณสั่งซื้อ = ปริมาณสุทธิ × (1 + Wastage) ปัดขึ้น — หน่วยนับชิ้นปัดเป็นจำนวนเต็ม · ปริมาตร/พื้นที่/น้ำหนักปัด 2 ตำแหน่ง'));
  poRows.push(NOTE('• % Wastage ของแต่ละรายการดูที่คอลัมน์ Wastage — เป็นค่าเดียวกับที่ใช้คิดราคาใน ปร.4'));
  poRows.push(NOTE('• มูลค่านี้ยังไม่รวมค่าดำเนินการ/กำไร/ภาษี (ดู ปร.5) และไม่รวมค่าแรง — เป็นราคาวัสดุสั่งซื้อล้วน'));
  poRows.push(NOTE(`• หน่วยสั่งซื้อ = หน่วยของราคาวัสดุ (เช่น เส้น/ถุง/แผ่น/ตัว) — ถ้าราคาคิดเป็น กก./ลบ.ม./ตร.ม. ปริมาณสั่งซื้อจะเป็นหน่วยนั้น`));
  if (poUnmatched > 0 || poNoQty > 0) {
    poRows.push(NOTE(`• ไม่รวมในใบนี้: ${poUnmatched>0?poUnmatched+' รายการที่ยังไม่ได้กำหนดราคา ':''}${poNoQty>0?poNoQty+' รายการที่หน่วยราคาไม่ตรงกับหน่วยปริมาณงาน ':''}— ดูรายละเอียดใน ปร.4`));
  }
  poRows.push(NOTE(`• ถอด+จับคู่ราคาโดย SwiftBill จากแบบ "${project.name}" — ${today}`));
  buildAndStyle(wb, 'ใบสั่งซื้อวัสดุ', poRows, poCols);

  // ── วิเคราะห์วัสดุเผื่อ & จุดคุมต้นทุน (VE เชิงจัดซื้อ — ไม่เปลี่ยนแบบ/สเปก) ──
  //   ต่อจากใบสั่งซื้อ: แยกส่วนเกินเหนือปริมาณสุทธิเป็น "เผื่อเสีย (Wastage)" + "ปัดหน่วยซื้อ"
  //   → ชี้จุดที่คุมวัสดุเผื่อแล้วคุ้มสุด + ประเมินเงินประหยัดถ้าคุมได้ (ประหยัดโดยไม่ต้องแก้แบบ/ขออนุมัติผู้ออกแบบ)
  //   decomposition แม่นเป๊ะ (คำนวณใน sbBuildPurchase): เผื่อเสีย = net×w%×ราคา · ปัดหน่วย = (สั่งซื้อ − net×(1+w%))×ราคา · รวม = (สั่งซื้อ − net)×ราคา
  const waList = poList.filter(g => g.unitPrice > 0)
    .slice().sort((a,b) => b.overCost - a.overCost);   // ส่วนเกินมาก→น้อย = จุดคุมคุ้มสุดอยู่บน

  const waCols = [6, 28, 8, 15, 8, 16, 18, 15, 10];
  const waRows = [
    T('วิเคราะห์วัสดุเผื่อ & จุดคุมต้นทุน (ประหยัดโดยไม่เปลี่ยนแบบ/สเปก)'),
    INFO(`โครงการ  ${project.name||'-'}        ประมาณราคา ณ วันที่ ${today}`),
    BL(),
    H(['ลำดับ','รายการวัสดุ','หน่วย','ต้นทุนสุทธิ (บาท)','Wastage','มูลค่าเผื่อเสีย (บาท)','มูลค่าปัดหน่วยซื้อ (บาท)','รวมส่วนเกิน (บาท)','% ส่วนเกิน']),
  ];
  let waNo=0, waNet=0, waWaste=0, waRound=0, waOver=0;
  waList.forEach(g => {
    waNo++; waNet+=g.netCost; waWaste+=g.wastageCost; waRound+=g.roundupCost; waOver+=g.overCost;
    // ชื่อ + สเปก (เดิมชื่ออย่างเดียว → "เหล็กเส้นกลมผิวข้ออ้อย" ซ้ำ 3 แถวไม่รู้ขนาดไหน)
    waRows.push(D([ waNo, clean(g.name + (g.spec ? ' ' + g.spec : '')), sbUnitTh(g.unit)||'-', n2(g.netCost), g.w+'%',
      n2(g.wastageCost), n2(g.roundupCost), n2(g.overCost), n2(g.overPct)+'%' ]));
  });
  if (waList.length === 0) waRows.push(D(['','ยังไม่มีรายการวัสดุที่มีราคา','','','','','','','']));
  waRows.push(BL());
  waRows.push(TT(['','รวมทั้งหมด','', n2(waNet), '', n2(waWaste), n2(waRound), n2(waOver),
    waNet>0 ? n2(waOver/waNet*100)+'%' : '-']));
  waRows.push(BL());
  waRows.push(SB('สรุป & แนวทางคุมต้นทุน (Value Engineering เชิงจัดซื้อ)'));
  const per1pct = waNet*0.01;
  const fmtB = v => n2(v).toLocaleString('en-US', { minimumFractionDigits:2, maximumFractionDigits:2 });   // เงินในข้อความ มีคอมม่า
  waRows.push(NOTE(`• มูลค่าส่วนเกินรวม ${fmtB(waOver)} บาท (${waNet>0?n2(waOver/waNet*100):0}% ของต้นทุนสุทธิ) = เงินที่จมไปกับวัสดุเผื่อ + การปัดหน่วยซื้อ`));
  waRows.push(NOTE(`• ทุก 1% ที่ลดวัสดุเผื่อได้ (วางแผนการตัด/จัดเก็บ/ควบคุมหน้างาน) ≈ ประหยัด ${fmtB(per1pct)} บาท`));
  waRows.push(NOTE(`• หากคุมวัสดุเผื่อได้ครึ่งหนึ่งของที่เผื่อไว้ ≈ ประหยัด ${fmtB(waWaste/2)} บาท (เฉพาะส่วนเผื่อเสีย ยังไม่รวมส่วนปัดหน่วยซื้อ)`));
  const top3 = waList.slice(0,3).map((g,i)=>`${i+1}. ${clean(g.name + (g.spec ? ' ' + g.spec : ''))} (${fmtB(g.overCost)} บาท)`).join('   ·   ');
  if (top3) waRows.push(NOTE(`• จุดคุมคุ้มสุด (ส่วนเกินสูงสุด): ${top3}`));
  waRows.push(NOTE('• เป็นการประหยัดเชิงจัดซื้อ/บริหารหน้างาน — ไม่เปลี่ยนวัสดุหรือสเปก จึงไม่ต้องแก้แบบหรือขออนุมัติผู้ออกแบบ'));
  waRows.push(NOTE(`• ถอด+จับคู่ราคาโดย SwiftBill จากแบบ "${project.name}" — ${today}`));
  buildAndStyle(wb, 'วิเคราะห์วัสดุเผื่อ', waRows, waCols);

  // ── หน้าแรก: "ประมาณการนี้มาจากไหน" (สร้างท้ายสุดแล้วย้ายขึ้นเป็นชีตแรก) · payload เก่าไม่มี basis → ข้าม ──
  const basisLines = sbBasisLines(P);
  if (basisLines) {
    buildAndStyle(wb, 'ที่มาประมาณการ', [
      T('ที่มาของประมาณการ'),
      INFO(`โครงการ  ${project.name||'-'}        ประมาณราคา ณ วันที่ ${today}`),
      BL(),
      ...basisLines.map(t => D(['', t])),
    ], [4, 70]);
    wb.SheetNames = ['ที่มาประมาณการ', ...wb.SheetNames.filter(n => n !== 'ที่มาประมาณการ')];
  }

  const safe = (project.name||'ราคา').replace(/[\\/:*?"<>|]/g,'_');
  X.writeFile(wb, `ใบราคา_ปร4-ปร5_${safe}.xlsx`);
  return true;
}

// หน่วยแบบไทยชุดเดียวทุกไฟล์ลูกค้า (เดิมปน ม³/ลบ.ม. · ม²/ตร.ม. · kg/กก.) — ใช้กับช่อง "หน่วย" ที่เป็นหน่วยล้วน
function sbUnitTh(u){
  const s = String(u==null?'':u).trim();
  if (/^(ม³|m3|m³|ลบ\.?\s?ม\.?|cu\.?\s?m\.?)$/i.test(s)) return 'ลบ.ม.';
  if (/^(ม²|m2|m²|ตร\.?\s?ม\.?|sq\.?\s?m\.?)$/i.test(s)) return 'ตร.ม.';
  if (/^(kg|kgs|กก\.?|กิโลกรัม)$/i.test(s)) return 'กก.';
  if (/^(m|ม\.?|เมตร)$/.test(s)) return 'ม.';
  return s;
}
window.sbUnitTh = sbUnitTh;
// หน่วยในข้อความอิสระ/หัวคอลัมน์ ("นน.เหล็ก (kg)", "20.64 kg", "~4 ตัว/ม²") — ไม่แตะสเปกจากแบบ ("RB9mm@0.20m", "2.5 sq.mm")
function sbTxtUnits(t){
  return String(t==null?'':t)
    .replace(/\((kg)\)/gi, '(กก.)').replace(/\((m)\)/g, '(ม.)')
    .replace(/\((m3|ม³)\)/gi, '(ลบ.ม.)').replace(/\((m2|ม²)\)/gi, '(ตร.ม.)')
    .replace(/(\d)\s*kg\b/gi, '$1 กก.').replace(/\bkg\s*\//gi, 'กก./')
    .replace(/ม³/g, 'ลบ.ม.').replace(/ม²/g, 'ตร.ม.');
}
window.sbTxtUnits = sbTxtUnits;

// ตัดคำภายในออกจากชื่อ/สเปกที่ลูกค้าเห็น — "(6 ชิ้นส่วน)" (ช่วยตอนตรวจ) · "ราคาเดิมในไฟล์" (สเปกค้างในฐานราคาในตัว)
function sbCleanTxt(s){
  return String(s||'').replace(/\s*\(\d+\s*ชิ้นส่วน\)/g, '').replace(/\s*ราคาเดิมในไฟล์/g, '').replace(/\s{2,}/g, ' ').trim();
}
window.sbCleanTxt = sbCleanTxt;
// ชื่อฐานราคาในไฟล์ลูกค้า — ฐานราคาในตัว (ราคากลาง SwiftBill · ซ่อนจากลูกค้าตาม #217) เรียกกลาง ๆ · เทมเพลตของผู้ใช้ = ชื่อที่ผู้ใช้ตั้ง
function sbTplIsBuiltin(P){
  const b = (P && P.basis) || {}, nm = String((P && P.template) || b.tplName || '');
  if (b.builtin) return true;
  return /\(โดย\s*SwiftBill\)/i.test(nm) || ((window.SB_BUILTIN_TEMPLATES||[]).some(t => t.name === nm));
}
function sbTplLabel(P){
  if (sbTplIsBuiltin(P)) return 'ฐานราคาวัสดุและค่าแรง SwiftBill';
  return (P && (P.template || (P.basis && P.basis.tplName))) || '-';
}
window.sbTplLabel = sbTplLabel;

// 4 บรรทัด "ที่มาของประมาณการ" — ใช้ร่วมหน้าแรกไฟล์ ปร.4/ปร.5 และใบปะหน้า BOQ (excel-boq.jsx) · null = payload เก่า (ไม่มี basis)
//   ไม่ระบุภูมิภาคของฐานราคา (ฐานในตัวเป็นราคาขอนแก่น แต่โปรเจกต์อยู่ที่ใดก็ได้ — เจ้าของเลือก "เรียกกลาง ๆ" 2026-11-16)
function sbBasisLines(P){
  const b = P && P.basis; if (!b) return null;
  const pc = P.pct || {};
  const price = sbTplIsBuiltin(P)
    ? `ราคาวัสดุและค่าแรงจาก${sbTplLabel(P)}${b.asOf ? ' ณ '+b.asOf : ''}${b.vatExcl ? ' · ราคาต่อหน่วยไม่รวม VAT' : ''}`
    : `ราคาจากฐานราคา “${sbTplLabel(P)}”`;
  const calc = P.priceMode === 'factorf'
    ? `ค่างานต้นทุน × Factor F ${(Number(P.factorF)||1).toFixed(4)} (ตารางสำนักงบประมาณ · รวม VAT แล้ว)`
    : `ค่างานต้นทุน + ค่าดำเนินการ ${pc.overhead||0}% + กำไร ${pc.profit||0}% + VAT ${pc.vat||0}%`;
  const full = b.totalN > 0 && b.pricedN / b.totalN >= (b.minCover || 0.9);
  const cover = b.totalN > 0 && b.pricedN >= b.totalN ? 'มีราคาครบทุกรายการ'
    : `มีราคาแล้ว ${b.pricedN} จาก ${b.totalN} รายการ${full ? '' : ' · ยอดเบื้องต้น'}`;
  return [price, calc, cover, 'ไม่รวม: ค่าออกแบบ · งานนอกอาคาร · เฟอร์นิเจอร์ · เงินสำรอง'];
}
window.sbBasisLines = sbBasisLines;

// ── Utility: แปลง items[] → rows สำหรับแต่ละ sheet ─────────────
function itemsToSheetRows(items, cat, subFilter) {
  const filtered = items.filter(it => {
    const c = (it.category||it.cat||'');
    const n = (it.name||'').toLowerCase();
    if (!c.includes(cat)) return false;
    if (subFilter && !n.includes(subFilter)) return false;
    return true;
  });
  return filtered.map(it => ({
    code:    it.code || '-',
    name:    it.name || '-',
    qty:     Number(it.qty)||0,
    unit:    it.unit || '-',
    volume:  Number(it.volume)||0,
    notes:   it.notes || '',
    rebar:   '-',
  }));
}

// ── Utility: คำนวณ summary ของ footing rows ─────────────────────
// พื้นที่ฐานราก (ตร.ม.) ตามรูปทรง: สี่เหลี่ยม=B×L · สามเหลี่ยม=½BL · สามเหลี่ยมตัดมุม(คางหมู)=½(B+B2)L · วงกลม=πr²
// area_m2 (ถ้าระบุ) override ทุกสูตร
function footArea(r){
  const B = Number(r.B)||0, L = Number(r.L)||0, B2 = Number(r.B2)||0;
  if (Number(r.area_m2) > 0) return Number(r.area_m2);
  const s = String(r.shape||'').replace(/\s/g,'');
  if (s.includes('สามเหลี่ยมตัดมุม') || s.includes('คางหมู')) return 0.5*(B + (B2||B*0.5))*L;
  if (s.includes('สามเหลี่ยม')) return 0.5*B*L;
  if (s.includes('วงกลม') || s.includes('กลม')) return Math.PI*(B/2)*(L/2);
  return B*L; // สี่เหลี่ยม (ค่าเริ่มต้น)
}
function calcFootingSummary(rows) {
  return rows.map(r => {
    const B = Number(r.B)||1, L = Number(r.L)||1, T = Number(r.T)||0.5;
    const n = Number(r.count||r.qty)||1;
    const lean_t = Number(r.lean_t)||0.05;
    const sand_t = Number(r.sand_t)||0.05;
    const depth  = Number(r.depth)||1.2;
    const fa     = footArea(r);
    const area   = n2(fa);
    const cpf    = n2(fa*T);
    const c_m3   = r.concrete_m3 ? n2(r.concrete_m3) : n2(cpf*n);
    const RB = window.REBAR || {};
    const dg = 2*(RB.footDig != null ? RB.footDig : 0), bd = 2*(RB.footBed != null ? RB.footBed : 0.025);
    const lean   = r.lean_m3    ? n2(r.lean_m3)    : n2((B+bd)*(L+bd)*lean_t*n);
    const sand   = r.sand_m3    ? n2(r.sand_m3)    : n2((B+bd)*(L+bd)*sand_t*n);
    const excav  = r.excavation_m3 ? n2(r.excavation_m3) : n2((B+dg)*(L+dg)*depth*n);
    const form   = r.formwork_m2   ? n2(r.formwork_m2)   : n2(2*(B+L)*T*n);
    const rb_bot = r.rebar_kg  ? n2(r.rebar_kg)  : 0;
    const rb_tie = r.rebar_tie_kg  ? n2(r.rebar_tie_kg) : 0;
    return {
      code: r.code||'-', area_m2: area, concrete_per: cpf, concrete_m3: c_m3,
      lean_m3: lean, excavation_m3: excav, sand_m3: sand,
      formwork_m2: form, rebar_bot_kg: rb_bot, rebar_tie_kg: rb_tie,
      rebar_kg: n2(rb_bot+rb_tie)
    };
  });
}

function calcColVol(r) {
  const sec = (r.section||'0.3×0.4').split(/[×x]/);
  const B = Number(sec[0])||0.3, D = Number(sec[1])||0.4;
  const h = Number(r.height)||3.0, n = Number(r.count||r.qty)||1;
  return n2(B*D*h*n);
}
function calcColForm(r) {
  const sec = (r.section||'0.3×0.4').split(/[×x]/);
  const B = Number(sec[0])||0.3, D = Number(sec[1])||0.4;
  const h = Number(r.height)||3.0, n = Number(r.count||r.qty)||1;
  return n2(2*(B+D)*h*n);
}

// ── Utility: รวมค่าทุกหมวดสำหรับ Sheet 11 ─────────────────────
function calcTotals(footings, columns, beams, roof, precast, cip, items) {
  const sumField = (arr, f) => arr.reduce((s,r) => s+(Number(r[f])||0), 0);
  const fSums = calcFootingSummary(footings);

  // fallback จาก items ถ้าไม่มี structured data
  const getVol = (cat) => items.filter(i=>(i.category||i.cat||'').includes(cat)).reduce((s,i)=>s+(Number(i.volume)||0),0);

  return {
    excavation: n2(sumField(fSums,'excavation_m3') || getVol('ดิน')),
    sand:       n2(sumField(fSums,'sand_m3')),
    lean:       n2(sumField(fSums,'lean_m3')),
    c_footing:  n2(sumField(fSums,'concrete_m3') || getVol('ฐานราก')),
    c_column:   n2(columns.reduce((s,r)=>s+(Number(r.concrete_m3)||calcColVol(r)),0) || getVol('เสา')),
    c_beam:     n2(beams.reduce((s,r)=>s+(Number(r.concrete_m3)||Number(r.volume)||0),0) || getVol('คาน')),
    c_slab_cip:     n2(cip.reduce((s,r)=>s+(Number(r.concrete_m3)||Number(r.volume)||0),0)),
    c_slab_topping: n2(precast.reduce((s,r)=>s+(Number(r.area_m2)||0)*(Number(r.topping_t)||0.05),0)),
    get c_total(){ return n2(this.c_footing+this.c_column+this.c_beam+this.c_slab_cip+this.c_slab_topping); },
    r_footing:  n2(sumField(fSums,'rebar_kg')),
    r_column:   n2(columns.reduce((s,r)=>s+(Number(r.rebar_kg)||0),0)),
    r_beam:     n2(beams.reduce((s,r)=>s+(Number(r.rebar_kg)||0),0)),
    get r_total(){ return n2(this.r_footing+this.r_column+this.r_beam); },
    f_footing:  n2(sumField(fSums,'formwork_m2')),
    f_column:   n2(columns.reduce((s,r)=>s+(Number(r.formwork_m2)||calcColForm(r)),0)),
    f_beam:     n2(beams.reduce((s,r)=>s+(Number(r.formwork_m2)||0),0)),
    get f_total(){ return n2(this.f_footing+this.f_column+this.f_beam); },
  };
}

// ── Utility: sum columns ────────────────────────────────────────
function sumRow(data, colIdxs) {
  const result = [];
  for (let i = 0; i < (data[0]?.length||0); i++) {
    if (colIdxs.includes(i)) {
      result.push(n2(data.reduce((s,r)=>s+(Number(r[i])||0),0)));
    } else {
      result.push('');
    }
  }
  return result;
}
function n2(v){ return Math.round((Number(v)||0)*100)/100; }

window.generateBOQExcel = generateBOQExcel;
