/* ===================== Results view (Step 11/12/13) ===================== */

// ── สเปกเหล็ก: แตก 1 ช่อง ("6-DB12mm" / "RB9mm@0.20") เป็นช่องย่อยในตาราง ──────
// ‼️ ชั้นแสดงผลเท่านั้น — ค่ายังเก็บเป็น string เดิมใน field เดิม (rebar_x/ties/…)
//    → สูตรเหล็ก (sbBars/sbTies), excel-export และ prompt ไม่ต้องรู้เรื่องนี้เลย
// steel: 'bars' = นับเส้น (จำนวน·ขนาด) · 'ties' = ระยะเรียง (ขนาด·@) · 'both' = แบบจริงมีได้ทั้งคู่
// ‼️ ส่วนที่ parse ไม่ได้ตกลงช่อง "ขนาด" ทั้งก้อนเสมอ → join กลับได้ค่าเดิมเป๊ะ ไม่มีอะไรหาย
//    (เช่น "WIREMESH 4mm" หรือช่องปลอกที่ AI เผลอส่ง "6-DB12mm" มา)
//    และ mode คุมว่าจะดึงส่วนไหนออกมา → ช่อง 'bars' ไม่มีที่เก็บ @ ก็ไม่แตะ @ เลย
const sbSteelSplit = (v, mode) => {
  let rest = String(v==null?'':v).trim();
  if(rest === '-') rest = '';
  let n = '', sp = '';
  if(mode==='ties' || mode==='both'){
    // ‼️ ตัด "@ระยะ" ออกจากช่อง "ขนาด" ให้เด็ดขาด แม้มีข้อความต่อท้าย (c/c, o.c., ทั่วไป, EF, mm ฯลฯ)
    //    เดิม anchor ท้ายบรรทัด ($) → ถ้าแบบเขียน "RB6@0.15 c/c" จะ match ไม่ติด → เลข @ ค้างในช่องขนาด
    //    = อาการ "เลขระยะ@ ล้นเข้าคอลัมน์หน้า" (สเปกยังเก็บดิบ แต่ชั้นแสดงผลแยก @ ไปช่องของมันเสมอ)
    // ‼️ ยอมรับ "จุดท้ายระหว่างพิมพ์" (เช่น "0." ก่อนพิมพ์เลขหลังจุด) — เดิม (?:\.\d+)? บังคับมีเลขหลังจุด
    //    → controlled input re-render ตัดจุดทิ้ง = พิมพ์ทศนิยมไม่ได้ (อาการ "0.15"→"015")
    const m = rest.match(/@\s*(\d+\.?\d*|\.\d+)/);
    if(m){ sp = m[1]; rest = rest.slice(0, m.index).trim(); }
  }
  if(mode==='bars' || mode==='both'){
    // แยกจำนวนเส้น (n) ออกจากขนาด (d): split เมื่อ (ก) มี "-" คั่น → d เป็นอะไรก็ได้ ("2-16mm","2-T16")
    //   หรือ (ข) d เป็นสเปกมาตรฐาน (DB/RB/Ø) ที่ไม่มี "-" ("2DB16") หรือ (ค) จำนวนล้วนยังไม่เลือกขนาด ("7"→$)
    // ‼️ เดิมบังคับ lookahead DB/RB/Ø/$ อย่างเดียว → พิมพ์ขนาดอิสระ (16mm/T16) จำนวนเส้นหาย รวมเข้าช่องขนาด
    const m = rest.match(/^(\d+(?:\s*\+\s*\d+)*)\s*(?:[-–]\s*|(?=Ø|ø|DB|RB|$))/i);
    if(m){ n = m[1].replace(/\s+/g,''); rest = rest.slice(m[0].length).trim(); }
    else rest = rest.replace(/^[-–]\s*/, '');  // "-16" = marker (จำนวนว่าง + ขนาดขึ้นต้นเลข) → strip "-" เหลือขนาด
  }
  return { n, d:rest, sp };
};
// ประกอบกลับเป็นสเปกเดียว — รูปแบบต้องตรงกับที่ sbBars/sbTies (และฝั่ง excel) อ่านออก
const sbSteelJoin = (p) => {
  const n = String(p.n||'').trim(), d = String(p.d||'').trim(), sp = String(p.sp||'').trim();
  if(!n && !d && !sp) return '';
  // ‼️ ใส่ "-" คั่นเฉพาะตอนมีขนาด (d) — จำนวนเส้นล้วน ("7") ต้องไม่เก็บเป็น "7-" ที่ parse กลับไม่ได้
  // ‼️ จำนวนว่าง + ขนาดขึ้นต้นเลข ("16") กำกวมกับจำนวนเส้น → ใส่ "-" นำ บอกว่าเป็นขนาด (split strip กลับ)
  const core = n ? (d ? n+'-'+d : n) : (d && /^\d/.test(d) ? '-'+d : d);
  return core + (sp ? '@'+sp : '');
};
// ช่องย่อยของแต่ละ mode — label ตัวแรก null = ใช้ชื่อคอลัมน์เดิม
const SB_STEEL_PARTS = {
  bars: [{p:'n',label:'(เส้น)',alignR:1}, {p:'d',label:'ขนาด'}],
  ties: [{p:'d',label:null}, {p:'sp',label:'@ (ม.)',alignR:1}],
  both: [{p:'n',label:'(เส้น)',alignR:1}, {p:'d',label:'ขนาด'}, {p:'sp',label:'@ (ม.)',alignR:1}],
};
// ขนาดเหล็กมาตรฐานสำหรับดรอปดาวน์ช่อง "ขนาด/ปลอก" (steelPart==='d') — RB เส้นกลม · DB ข้ออ้อย
// ‼️ ถ้าค่าเดิมในแถวไม่อยู่ในลิสต์ (เช่น Ø12mm, WIREMESH) จะถูกเติมเป็นตัวเลือกท้ายสุด → ไม่มีค่าหาย
const SB_REBAR_SIZES = ['RB6mm','RB9mm','DB10mm','DB12mm','DB16mm','DB20mm','DB25mm','DB28mm','DB32mm'];
// เกรดคอนกรีต fc' (ksc) มาตรฐานไทย → dropdown ช่อง fc (เหมือนขนาดเหล็ก) · ค่านอกลิสต์จาก AI เก็บเป็นตัวเลือกท้าย (render)
const SB_FC_OPTS = [{v:'',t:'—'}].concat([180,210,240,280,300,320,350,400].map(g=>({v:String(g),t:String(g)})));
// รูปทรงผืนหลังคา (ว่าง = สี่เหลี่ยม) — ต้องตรงกับ LISTS.roofShape ใน tools/eval/lib/template-spec.js
const SB_ROOF_SHAPES = [{v:'',t:'สี่เหลี่ยม'},{v:'สามเหลี่ยม',t:'สามเหลี่ยม'},{v:'คางหมู',t:'คางหมู'}];
// พื้นที่ฉายราบตามรูปทรง (ต่อผืน) · กว้าง/ยาว ไม่ครบ → null (ใช้ flat_area ที่กรอก/AI ส่ง)
const sbRoofFlat = (r) => {
  const W=+r.width||0, L=+r.length||0; if(!(W>0 && L>0)) return null;
  const sh=String(r.shape||'').trim().toLowerCase();
  if(sh==='สามเหลี่ยม' || sh==='triangle') return W*L/2;
  if(sh==='คางหมู' || sh==='trapezoid') return (W + Math.max(+r.width_top||0,0))/2*L;
  return W*L;
};
// cols (ตัวจริง ผูกกับ field) → viewCols (ที่ตารางวาด) · steelBase/steelPart บอก editCell ว่าเขียนกลับที่ไหน
const sbExpandCols = (cols) => {
  const out = [];
  cols.forEach(c=>{
    const parts = typeof c.steel==='string' ? SB_STEEL_PARTS[c.steel] : null;
    if(!parts){ out.push(c); return; }
    parts.forEach((pt,i)=>out.push({
      ...c, k: c.k+'__'+pt.p,
      label: pt.label==null ? c.label : (i===0 ? c.label+' '+pt.label : pt.label),
      steelPart: pt.p, steelMode: c.steel, steelBase: c.k, steelAlt: c.alt, alignR: pt.alignR,
    }));
  });
  return out;
};
// อ่านค่าดิบของ field จริงที่อยู่เบื้องหลังช่องย่อย (รองรับ alt เหมือน sbRaw)
function sbBaseRaw(row, col){
  let v = row[col.steelBase];
  if((v===undefined||v===null||v==='') && col.steelAlt) v = row[col.steelAlt];
  return (v===undefined||v===null) ? '' : v;
}

// แถวในชีต "ตู้-แผงจ่ายไฟ" เป็นตัวตู้ไหม (ไม่ใช่ลูกเบรกเกอร์/หลักดิน/กล่องต่อสาย) — ใช้ล็อกช่อง "จำนวนช่อง"
// ‼️ ways > 0 = ตู้เสมอ (ไม่ซ่อนค่าที่มีอยู่) · แถวใหม่ที่ยังไม่พิมพ์ชนิด = แก้ได้ (เผื่อเพิ่มตู้เอง)
function sbIsPanelRow(r){
  if(Number(r.ways) > 0) return true;
  const s = `${r.code||''} ${r.type||''}`;
  return !/เบรก|breaker|MCC?B|RCBO|RCD|ELCB|หลักดิน|สายดิน|กราวด์|ground|GND|กล่อง|มิเตอร์|meter|kWh/i.test(s);
}

// ── คอลัมน์ของแต่ละ sheet — ให้ตรงกับ Excel (excel-export.jsx) ───────────
// num = ทศนิยม 2 ตำแหน่ง · int = จำนวนเต็ม · ไม่ระบุ = ข้อความ · alt = field สำรอง
// derived = ช่องที่คำนวณอัตโนมัติจากสูตร (แก้มือไม่ได้) ส่วนช่องอื่นแก้ได้
// naIf(row) = true → ช่องนี้ไม่ใช้กับแถวนั้น โชว์ "-" แก้ไม่ได้ (เช่น จำนวนช่องของลูกเบรกเกอร์)
// steel = ช่องสเปกเหล็ก → แตกเป็นช่องย่อยตาม mode (ดู SB_STEEL_PARTS ด้านบน)
const SB_SHEET_COLS = {
  footings: { label:'ฐานราก', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ประเภท'}, {k:'shape',label:'รูปทรง'},
    {k:'B',label:'B (m)',num:1}, {k:'L',label:'L (m)',num:1}, {k:'B2',label:'B2 บน (m)',num:1}, {k:'T',label:'T (m)',num:1},
    {k:'count',label:'จำนวน',int:1,alt:'qty'}, {k:'depth',label:'ลึกขุด (m)',num:1},
    {k:'lean_t',label:'หนา Lean (m)',num:1}, {k:'sand_t',label:'หนา ทราย (m)',num:1},
    {k:'fc',label:"fc'",int:1,opts:SB_FC_OPTS},
    // ‼️ ฐานราก 'both': แบบเขียนได้ทั้งนับเส้น ("8Ø12mm") และระยะเรียง ("DB16mm@0.15") — sbFootRebarCalc รับทั้งคู่
    {k:'rebar_x',label:'เหล็กล่าง X',alt:'rebar',steel:'both'}, {k:'rebar_y',label:'เหล็กล่าง Y',steel:'both'},
    // ตะแกรงบน: สเปกเดียว 2 ทิศ · รูป U = ขาลงข้างฐานเต็มความหนา
    {k:'rebar_top',label:'เหล็กบน (2 ทิศ)',steel:'both'},
    {k:'top_shape',label:'รูปเหล็กบน',opts:[{v:'',t:'ตรง'},{v:'U',t:'ตัว U (ขาลงข้างฐาน)'}]},
    {k:'ties',label:'ปลอก/รัด (@ หรือ จำนวนวง)',steel:'both'},   // "RB9@0.20" หรือ "4-RB9" (รัดรอบนับวง) — sbFootTiesCalc
    {k:'piles',label:'เสาเข็ม/ฐาน',int:1},
    {k:'concrete_m3',label:'คสล.รวม (ม³)',num:1,derived:1}, {k:'formwork_m2',label:'ไม้แบบ (ม²)',num:1,derived:1},
    {k:'rebar_m',label:'เหล็กตะแกรง (ม.)',num:1,derived:1}, {k:'rebar_top_kg',label:'ส่วนเหล็กบน (kg)',num:1,derived:1},
    // ‼️ rebar_kg: คิดอัตโนมัติจากสเปก (เหมือนเสา/คาน) แต่ "ล็อกเฉพาะเมื่ออ่านสเปกได้" (lockIf) —
    //    อ่านสเปกไม่ได้ (สเปกฐานรากมักเป็นตะแกรง/เขียนย่อ) → เปิดให้กรอกมือทับ · วางในแท็บ "ผลคำนวณ" (calcGroup)
    {k:'rebar_kg',label:'เหล็กตะแกรง ล่าง+บน (kg)',num:1,calcGroup:1,lockIf:r=>!!r._rebar_locked},
    {k:'ties_m',label:'ความยาวปลอก/รัด (m)',num:1,derived:1}, {k:'ties_kg',label:'นน.ปลอก/รัด (kg)',num:1,derived:1},
  ]},
  columns: { label:'เสา', cols:[
    {k:'code',label:'รหัส'}, {k:'floor',label:'ชั้น/ช่วง'},
    {k:'grid',label:'ตำแหน่ง (กริด)',alt:'gridline'},
    {k:'section',label:'หน้าตัด B×D (m)'},
    {k:'B',label:'B (m)',num:1,derived:1}, {k:'D',label:'D (m)',num:1,derived:1},
    {k:'height',label:'สูง (m)',num:1}, {k:'count',label:'จำนวน',int:1,alt:'qty'},
    {k:'fc',label:"fc' (kg/cm²)",int:1,opts:SB_FC_OPTS},
    {k:'rebar_main',label:'เหล็กยืน',alt:'rebar',steel:'bars'},
    {k:'rebar_m',label:'ความยาวเหล็กยืน (m)',num:1,derived:1}, {k:'rebar_kg',label:'นน.เหล็กยืน (kg)',num:1,derived:1},
    // ชุดปลอก = จำนวนปลอกซ้อน/ตัว (เบิ้ลปลอก 2 ชั้น = 2) · ว่าง/1 = ปกติ → คูณ นน./จำนวนเหล็กปลอก
    {k:'ties_sets',label:'ชุดปลอก (เบิ้ล)',int:1},
    {k:'ties',label:'ปลอก',steel:'ties'},
    {k:'ties_n',label:'จำนวนปลอก',int:1,derived:1},
    {k:'ties_m',label:'ความยาวเหล็กปลอก (m)',num:1,derived:1}, {k:'ties_kg',label:'นน.เหล็กปลอก (kg)',num:1,derived:1},
    {k:'concrete_per',label:'ปริมาตร/ตัว (ม³)',num:1,derived:1,
      derive:(r)=> Number(r.concrete_per) || (Number(r.concrete_m3||0)/(Number(r.count||r.qty)||1))},
    {k:'concrete_m3',label:'ปริมาตรคอนกรีต (ม³)',num:1,derived:1},
    {k:'formwork_m2',label:'ไม้แบบรวม (ม²)',num:1,derived:1},
    {k:'spacer_n',label:'ลูกปูน',int:1,derived:1},
    {k:'nail_kg',label:'ตะปู (kg)',num:1,derived:1},
    {k:'steel_total_kg',label:'น.น.เหล็กรวม (kg)',num:1,derived:1},
    {k:'tie_wire_kg',label:'ลวดผูกเหล็ก (kg)',num:1,derived:1},
    {k:'bend_m',label:'ระยะเหล็กงอ (m)',num:1,derived:1}, {k:'lap_m',label:'ระยะเหล็กทาบ (m)',num:1,derived:1},
  ]},
  // เสาเหล็กรูปพรรณ (ชั้นที่เป็นเหล็ก / เสาเหล็กล้วน) — น.น./ม. เติมจากตารางหน้าตัดเหล็ก · ไม่มีคอนกรีต
  // ‼️ เสาผสม = แถว RC ใน columns + แถวเหล็กใน steel_columns รหัสเดียวกัน · floor เชื่อมว่าเป็นต้นเดียว
  //    v1 คิดแค่น้ำหนัก (สูง×จำนวน×น.น./ม.) · base plate/anchor bolt/กันไฟ = ยังไม่คิด
  steel_columns: { label:'เสาเหล็ก', cols:[
    {k:'code',label:'รหัส'}, {k:'floor',label:'ชั้น/ช่วง'},
    {k:'section',label:'หน้าตัด',secList:1,secWeight:1},
    {k:'unit_weight',label:'น.น./ม. (กก./ม.)',num:1}, {k:'height',label:'สูง/ท่อน (m)',num:1},
    {k:'count',label:'จำนวน',int:1,alt:'qty'},
    {k:'total_length_m',label:'ความยาวรวม (m)',num:1,derived:1},
    {k:'weight_kg',label:'น้ำหนักรวม (kg)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  // อุปกรณ์ประกอบเสาเหล็ก (v1: base plate + anchor bolt) — ผูกกับรหัสเสาเหล็ก
  // ‼️ น.น.เพลต = ปริมาตรเหล็ก (B×L×t) × 7850 × จำนวนแผ่น · bolt รวม = ตัว/แผ่น × จำนวนแผ่น (โค้ดคิด)
  steel_col_fittings: { label:'อุปกรณ์ประกอบเสาเหล็ก', cols:[
    {k:'code',label:'รหัสเสา'}, {k:'plate_size',label:'เพลท B×L×t (mm)'},
    {k:'count',label:'จำนวนแผ่น',int:1,alt:'qty'},
    {k:'plate_kg',label:'น.น.เพลตรวม (kg)',num:1,derived:1},
    {k:'bolt_size',label:'Anchor bolt'}, {k:'bolt_per',label:'ตัว/แผ่น',int:1},
    {k:'bolt_total',label:'bolt รวม (ตัว)',int:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  beams: { label:'คาน', cols:[
    {k:'code',label:'รหัส'},
    {k:'section',label:'หน้าตัด B×D (m)'},
    {k:'B',label:'B (m)',num:1,derived:1}, {k:'D',label:'D (m)',num:1,derived:1},
    {k:'grid',label:'ตำแหน่ง (กริด)',alt:'gridline'}, {k:'length',label:'ยาว (m)',num:1},
    {k:'count',label:'จำนวน',int:1,alt:'qty'},
    // ‼️ ชนิดคาน: เป็น metadata คุมการจำแนกของ AI + แสดงผล · ปริมาณเหล็กคิดจากช่องบทบาทด้านล่างล้วน (ไม่มีตัวคูณซ่อน)
    {k:'beam_type',label:'ชนิดคาน',opts:[{v:'',t:'—'},{v:'simple',t:'ช่วงเดียว'},{v:'continuous',t:'ต่อเนื่อง'},{v:'cantilever',t:'ยื่น'}]},
    // เหล็กบน (บน+บนเสริม+บนหัวเสา) → ความยาว/นน. รวมกลุ่ม · เหล็กล่าง (ล่าง+ล่างกลางช่วง) แยกกลุ่ม (ดู sbBeamSplit)
    {k:'rebar_top',label:'เหล็กบน',alt:'rebar',steel:'bars'},
    {k:'rebar_top_add',label:'เหล็กบนเสริม',steel:'bars'},
    {k:'rebar_top_sup',label:'เหล็กบนหัวเสา',steel:'bars'},
    {k:'rebar_top_m',label:'ความยาวเหล็กบน (m)',num:1,derived:1}, {k:'rebar_top_kg',label:'นน.เหล็กบน (kg)',num:1,derived:1},
    {k:'rebar_bot',label:'เหล็กล่าง',steel:'bars'},
    {k:'rebar_bot_mid',label:'เหล็กล่างกลางช่วง',steel:'bars'},
    {k:'rebar_bot_m',label:'ความยาวเหล็กล่าง (m)',num:1,derived:1}, {k:'rebar_bot_kg',label:'นน.เหล็กล่าง (kg)',num:1,derived:1},
    // ชุดปลอก = จำนวนปลอกซ้อน/ตัว (เบิ้ลปลอก 2 ชั้น = 2) · ว่าง/1 = ปกติ → คูณ นน./จำนวนเหล็กปลอก
    {k:'ties_sets',label:'ชุดปลอก (เบิ้ล)',int:1},
    {k:'ties',label:'ปลอก',steel:'ties'},
    {k:'ties_n',label:'จำนวนปลอก',int:1,derived:1},
    {k:'ties_m',label:'ความยาวเหล็กปลอก (m)',num:1,derived:1}, {k:'ties_kg',label:'นน.เหล็กปลอก (kg)',num:1,derived:1},
    {k:'concrete_m3',label:'ปริมาตรรวม (ม³)',num:1,derived:1,alt:'volume'},
    {k:'formwork_m2',label:'ไม้แบบรวม (ม²)',num:1,derived:1},
    {k:'spacer_n',label:'ลูกปูน',int:1,derived:1},
    {k:'nail_kg',label:'ตะปู (kg)',num:1,derived:1},
    {k:'steel_total_kg',label:'น.น.เหล็กรวม (kg)',num:1,derived:1},
    {k:'tie_wire_kg',label:'ลวดผูกเหล็ก (kg)',num:1,derived:1},
    {k:'bend_m',label:'ระยะเหล็กงอ (m)',num:1,derived:1}, {k:'lap_m',label:'ระยะเหล็กทาบ (m)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  // ผืนหลังคา: AI ส่ง กว้าง×ยาว (ฉายราบในผัง) + มุมลาด + จำนวนผืน · โค้ดคิดพื้นที่ (VE ได้ · mirror walls)
  // ‼️ เหล็กโครง (จันทัน/แป/อกไก่/อะเส/ขื่อ) แยกไป roof_members ทั้งหมด — ไม่คิดในแถวหลักแล้ว
  roof: { label:'หลังคา', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง/อาคาร',alt:'name',wide:1},
    {k:'width',label:'กว้าง (m)',num:1}, {k:'length',label:'ยาว (m)',num:1},
    // รูปทรงระนาบ (2026-10-19 เจ้าของขอ — หลังคาปั้นหยาแบ่งเป็นสามเหลี่ยม/คางหมู):
    //   สามเหลี่ยม: กว้าง = ฐาน · ยาว = สูง → ×½ · คางหมู: กว้าง = ฐานล่าง · ฐานบน · ยาว = สูง → (ล่าง+บน)/2 × สูง
    {k:'shape',label:'รูปทรง',opts:SB_ROOF_SHAPES}, {k:'width_top',label:'ฐานบน (m) — คางหมู',num:1},
    {k:'angle_deg',label:'มุมลาด (°)',int:1}, {k:'count',label:'จำนวน',int:1,alt:'qty'},
    {k:'flat_area',label:'พื้นที่ฉายราบ (ม²)',num:1,alt:'volume'},
    {k:'actual_area',label:'พื้นที่จริง (ม²)',num:1,derived:1}, {k:'notes',label:'หมายเหตุ'},
  ]},
  // สมาชิกโครงหลังคา/โครงถัก — น.น./ม. เติมจากตารางหน้าตัดเหล็ก (แก้ทับได้) · ความยาว/น้ำหนักรวม = derived
  roof_members: { label:'รายละเอียดสมาชิกโครงหลังคา', cols:[
    {k:'type',label:'ชนิดสมาชิก'},
    // หน้าตัด = พิมพ์ได้ + เลือกจากตารางน้ำหนักเหล็ก (datalist) · เปลี่ยนแล้ว น.น./ม. ลิงก์ให้อัตโนมัติ
    {k:'section',label:'หน้าตัด',secList:1,secWeight:1},
    {k:'unit_weight',label:'น.น./ม. (กก./ม.)',num:1}, {k:'length_each_m',label:'ยาว/ท่อน (m)',num:1,naIf:r=>sbRoofAreaMode(r)},
    // แบบให้ระยะเรียง @ + คลุมผืน (RF1-RF5 / ทั้งหมด) → ความยาวรวม = พื้นที่จริงผืนที่คลุม ÷ @ (โค้ดคิด)
    //   ‼️ โหมดนี้ไม่ใช้ ยาว/ท่อน · ช่วงกระจาย · จำนวน (recompute ล้างทิ้ง) → naIf โชว์ "-" แก้ไม่ได้ กันพิมพ์แล้วค่าหาย
    //   ไม่มีคลุมผืน → จำนวนแนว = floor(ช่วงกระจาย/ระยะ)+1 (วิธีเดิม · ได้แค่ 1 ระนาบ)
    {k:'spacing_m',label:'ระยะเรียง @ (m)',num:1}, {k:'covers',label:'คลุมผืน (RF1-RF5 / ทั้งหมด)',coverList:1},
    {k:'covers_area_m2',label:'พื้นที่ที่คลุม (ม²)',num:1,derived:1}, {k:'span_m',label:'ช่วงกระจาย (m)',num:1,naIf:r=>sbRoofAreaMode(r)},
    {k:'count',label:'จำนวน (ท่อน/แนว)',int:1,alt:'qty',naIf:r=>sbRoofAreaMode(r)},
    {k:'total_length_m',label:'ความยาวรวม (m)',num:1,derived:1},
    {k:'total_weight_kg',label:'น้ำหนักรวม (kg)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  slabs_cip: { label:'พื้นหล่อในที่ (CIP)', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง',alt:'name'},
    {k:'grid',label:'ตำแหน่ง (กริด)',alt:'gridline'},
    {k:'B',label:'B (m)',num:1}, {k:'L',label:'L (m)',num:1}, {k:'T',label:'T (m)',num:1},
    {k:'count',label:'จำนวนช่วง',int:1,alt:'qty'},
    // เฟส A: ชนิดพื้น (บนคาน=มีท้องแบบ · บนดิน=ไม่มีท้องแบบ+ทราย/พลาสติก) · fc' · หักช่องเปิด · หนาทรายรองพื้น
    {k:'slab_support',label:'ชนิดพื้น',opts:[{v:'บนคาน',t:'บนคาน (มีท้องแบบ)'},{v:'บนดิน',t:'บนดิน (ไม่มีท้องแบบ)'}]},
    {k:'fc',label:"fc' (ksc)",int:1,opts:SB_FC_OPTS},
    {k:'openings_m2',label:'หักช่องเปิด (ม²)',num:1},
    {k:'sand_t',label:'หนาทรายรองพื้น (m)',num:1},
    // เหล็กพื้น 'ties': sbSlabCalc คิดจากระยะเรียงอย่างเดียว (ไม่มี @ = คิดไม่ได้ ใช้ค่า AI)
    {k:'rebar_short',label:'เหล็กล่างด้านสั้น',alt:'rebar',steel:'ties'},
    {k:'rebar_long',label:'เหล็กล่างด้านยาว',steel:'ties'},
    {k:'rebar_top',label:'เหล็กบน (เต็มผืน)',steel:'ties'},   // เฟส B: เหล็กบน (opt-in ว่าง=0)
    // เหล็กบนหัวคาน (2026-10-19 เจ้าของเลือกแบบ A — แบบไทยส่วนใหญ่เสริมบน "เฉพาะแถบริมคาน" ไม่เต็มผืน):
    //   ทิศ = แนวเหล็ก (เหมือนเหล็กล่าง) · ยื่น = ระยะจากขอบคานเข้าในพื้น (ว่าง = ¼ ของช่วงทิศนั้น) · sbSlabSupCalc
    {k:'top_sup_short',label:'เหล็กบนหัวคาน ด้านสั้น',steel:'ties'}, {k:'top_sup_short_m',label:'ยื่นจากขอบ ด้านสั้น (m)',num:1},
    {k:'top_sup_long',label:'เหล็กบนหัวคาน ด้านยาว',steel:'ties'},   {k:'top_sup_long_m',label:'ยื่นจากขอบ ด้านยาว (m)',num:1},
    {k:'wiremesh',label:'ตะแกรงลวด (WIREMESH)'},               // เฟส B: ตะแกรงสำเร็จ (พื้นบนดิน)
    {k:'wiremesh_kg',label:'นน.ตะแกรง (kg)',num:1},
    {k:'rebar_m',label:'ความยาวเหล็กเสริม (m)',num:1,derived:1}, {k:'rebar_kg',label:'นน.เหล็กล่าง (kg)',num:1,derived:1},
    {k:'rebar_top_kg',label:'นน.เหล็กบน (kg)',num:1,derived:1},
    {k:'rebar_sup_kg',label:'นน.เหล็กบนหัวคาน (kg)',num:1,derived:1},
    {k:'concrete_m3',label:'คอนกรีต (ม³)',num:1,derived:1,alt:'volume'},
    {k:'formwork_m2',label:'ไม้แบบ (ม²)',num:1,derived:1},
    {k:'sand_m3',label:'ทรายรองพื้น (ม³)',num:1,derived:1},
    {k:'poly_m2',label:'พลาสติกปูรอง (ม²)',num:1,derived:1},
    {k:'spacer_n',label:'ลูกปูน',int:1,derived:1},
    {k:'steel_total_kg',label:'นน.เหล็กรวม (kg)',num:1,derived:1},
    {k:'tie_wire_kg',label:'ลวดผูกเหล็ก (kg)',num:1,derived:1},
    {k:'bend_m',label:'ระยะเหล็กงอ (m)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  slabs_precast: { label:'พื้นสำเร็จรูป (Solid Plank)', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง',alt:'name'},
    {k:'grid',label:'ตำแหน่ง (กริด)',alt:'gridline'},
    {k:'B',label:'B (m)',num:1}, {k:'L',label:'L (m)',num:1}, {k:'count',label:'จำนวนช่วง',int:1,alt:'qty'},
    {k:'plank_t',label:'หนาแผ่น (m)',num:1}, {k:'topping_t',label:'หนา Topping (m)',num:1},
    // ‼️ topping = ตะแกรงสำเร็จ ("WIREMESH #4@0.20") ไม่ใช่รูป จำนวน-ขนาด → เหล็กเสริม/ปลอก เป็นค่า AI/กรอกมือ (ไม่บังคับสูตร)
    {k:'topping_rebar',label:'เหล็ก Topping',alt:'wiremesh',steel:1},
    {k:'topping_rebar2',label:'เหล็กเสริม Topping'},
    {k:'topping_rebar_n',label:'จำนวนเหล็กเสริม',int:1}, {k:'topping_rebar_m',label:'ความยาวเหล็กเสริม (m)',num:1}, {k:'topping_rebar_kg',label:'นน.เหล็กเสริม (kg)',num:1},
    {k:'fc',label:"fc' Topping",int:1,opts:SB_FC_OPTS}, {k:'load_kg_m2',label:'น้ำหนักบรรทุก (กก./ม²)',int:1},
    {k:'steel_total_kg',label:'นน.เหล็กรวม (kg)',num:1,derived:1}, {k:'tie_wire_kg',label:'ลวดผูกเหล็ก (kg)',num:1,derived:1},
    {k:'area_m2',label:'พื้นที่รวม (ม²)',num:1,derived:1,alt:'volume'},
    {k:'spacer_n',label:'ลูกปูน',int:1,derived:1},
    {k:'concrete_m3',label:'คอนกรีต (m3)',num:1,derived:1},
    {k:'formwork_m2',label:'ไม้แบบ (ม²)',num:1,derived:1},
    {k:'bend_m',label:'ระยะเหล็กงอ (m)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  stairs: { label:'บันได', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง/ชั้น',alt:'name'},
    {k:'width',label:'กว้าง (m)',num:1}, {k:'steps',label:'จำนวนลูกตั้ง',int:1},
    {k:'riser',label:'ลูกตั้ง (m)',num:1}, {k:'tread',label:'ลูกนอน (m)',num:1},
    {k:'waist_t',label:'ท้องบันได (m)',num:1},
    {k:'slope_m',label:'ความลาดเอียงบันได (m)',num:1,derived:1},
    // ระดับ: ใช้ตรวจว่า steps×riser (rise_m) ตรงกับความสูงชั้นจริงไหม — ไม่เข้าสูตรปริมาณ
    {k:'level_bottom',label:'ระดับล่าง (m)',num:1,detail:1}, {k:'level_top',label:'ระดับบน (m)',num:1,detail:1},
    {k:'rise_m',label:'สูงรวม (m)',num:1,derived:1},
    // คอนกรีตแตกส่วน (แม่บันได = ท้องเอียง · ขั้น = ปริซึมสามเหลี่ยม)
    {k:'concrete_waist',label:'คอนกรีตแม่บันได (m3)',num:1,derived:1},
    {k:'concrete_steps',label:'คอนกรีตขั้นบันได (m3)',num:1,derived:1},
    {k:'concrete_stair',label:'คอนกรีตรวมบันได (m3)',num:1,derived:1},
    // ไม้แบบแตกส่วน (ท้อง = ท้องเอียง+หน้าลูกตั้ง · ข้าง = แม่บันได 2 ข้าง)
    {k:'formwork_soffit',label:'ไม้แบบท้องบันได (m2)',num:1,derived:1},
    {k:'formwork_side',label:'ไม้แบบข้างบันได (m2)',num:1,derived:1},
    {k:'formwork_stair',label:'ไม้แบบรวมบันได (m2)',num:1,derived:1},
    {k:'nail_stair_kg',label:'ปริมาณตะปู (kg)',num:1,derived:1},
    {k:'rebar_main',label:'เหล็กหลัก',alt:'rebar',steel:'both'},
    {k:'rebar_top',label:'เหล็กบน',steel:'both'}, {k:'top_len_m',label:'ยาวเหล็กบน/ปลาย (m)',num:1},
    {k:'rebar_dist',label:'เหล็กเสริมกันร้าว',steel:'both'},
    // เหล็กขั้นบันได: งอตามรูปขั้น "ทุกขั้น" (ระยะเรียงตามความกว้าง) + จมูกขั้น "ทุกมุม" (เส้น/ขั้น วิ่งตามความกว้าง)
    {k:'rebar_step',label:'เหล็กขั้นบันได',steel:'both',detail:1}, {k:'rebar_nose',label:'เหล็กจมูกขั้น',steel:'both',detail:1},
    {k:'rebar_rb6',label:'เหล็กเสริมบันได RB6 (m)',num:1,derived:1},
    {k:'rebar_rb9',label:'เหล็กเสริมบันได RB9 (m)',num:1,derived:1},
    {k:'rebar_db',label:'เหล็กเสริมบันได DB (m)',num:1,derived:1},
    {k:'rebar_m',label:'ความยาวเหล็กรวม (m)',num:1,derived:1},
    // ‼️ rebar_kg ไม่ mark derived (เหมือนฐานราก) — สเปกบันไดอ่านไม่ได้บ่อย ต้องเปิดให้กรอกมือทับ
    {k:'rebar_kg',label:'น.น.เหล็กบันได (kg)',num:1,calcGroup:1,lockIf:r=>!!r._rebar_locked},
    // ชานพัก: มี L×W → พื้นที่คิดให้เอง · มีแต่ ม² → กรอกช่องพื้นที่ตรง ๆ ได้ (แบบเก่า)
    {k:'landing_L',label:'ชานพัก ยาว (m)',num:1,detail:1}, {k:'landing_W',label:'ชานพัก กว้าง (m)',num:1,detail:1},
    {k:'landing_area',label:'ชานพัก (ม²)',num:1,detail:1}, {k:'landing_t',label:'หนาชานพัก (m)',num:1,detail:1},
    {k:'count',label:'จำนวน',int:1,alt:'qty'}, {k:'fc',label:"fc'",int:1,detail:1,opts:SB_FC_OPTS},
    {k:'concrete_landing',label:'ปริมาตรคอนกรีตชานพัก (m³)',num:1,derived:1},
    {k:'formwork_landing',label:'ไม้แบบชานพัก (m²)',num:1,derived:1},
    {k:'concrete_m3',label:'คอนกรีตรวม (m3)',num:1,derived:1,alt:'volume'},
    {k:'formwork_m2',label:'ไม้แบบรวม (m2)',num:1,derived:1},
    {k:'spacer_n',label:'ลูกปูน',int:1,derived:1},
    {k:'nail_kg',label:'ตะปูรวม (kg)',num:1,derived:1},
    {k:'steel_total_kg',label:'น.น.เหล็กรวม (kg)',num:1,derived:1},
    {k:'tie_wire_kg',label:'ลวดผูกเหล็ก (kg)',num:1,derived:1},
    {k:'handrail_type',label:'ชนิดราวกันตก',detail:1}, {k:'handrail_sides',label:'ราว (ข้าง)',int:1,detail:1},
    {k:'handrail_m',label:'ราวกันตก (m)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  // บันไดไม้ (เรือนไทย/บ้านยกใต้ถุน) — ปริมาณเป็น "ปริมาตรไม้" (ไม้ไทยขายเป็นลูกบาศก์ฟุต) ไม่มีคอนกรีต/เหล็ก
  // AI อ่านขนาดหน้าตัดไม้ (นิ้ว) + จำนวน · โค้ดคิดความยาวจากเรขาคณิตบันได แล้วรวมปริมาตร
  wood_stairs: { label:'บันไดไม้', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง/ชั้น',alt:'name'},
    {k:'width',label:'กว้าง (m)',num:1}, {k:'steps',label:'จำนวนลูกตั้ง',int:1},
    {k:'treads',label:'จำนวนลูกนอน',int:1},
    {k:'riser',label:'ลูกตั้ง (m)',num:1}, {k:'tread',label:'ลูกนอน (m)',num:1},
    {k:'slope_m',label:'ยาวตามลาด (m)',num:1,derived:1}, {k:'rise_m',label:'สูงรวม (m)',num:1,derived:1},
    {k:'stringer_size',label:'แม่บันได (นิ้ว)',detail:1}, {k:'stringer_count',label:'แม่บันได (ตัว)',int:1,detail:1},
    {k:'tread_size',label:'ไม้ลูกนอน (นิ้ว)',detail:1}, {k:'riser_board_size',label:'ไม้ลูกตั้ง (นิ้ว)',detail:1},
    {k:'post_size',label:'เสาบันได (นิ้ว)',detail:1}, {k:'post_count',label:'เสา (ต้น)',int:1,detail:1}, {k:'post_h',label:'สูงเสา (m)',num:1,detail:1},
    {k:'handrail_size',label:'ราวจับ (นิ้ว)',detail:1}, {k:'handrail_sides',label:'ราว (ข้าง)',int:1,detail:1},
    {k:'baluster_size',label:'ลูกกรง (นิ้ว)',detail:1}, {k:'baluster_spacing',label:'ระยะลูกกรง (m)',num:1,detail:1}, {k:'rail_h',label:'สูงราว (m)',num:1,detail:1},
    {k:'count',label:'จำนวน',int:1,alt:'qty'},
    {k:'wood_m3',label:'ปริมาตรไม้ (ม³)',num:1,derived:1,alt:'volume'},
    {k:'wood_cuft',label:'ปริมาตรไม้ (ลบ.ฟ.)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  // บันไดเหล็ก (โครงเหล็กรูปพรรณ) — ปริมาณหลัก = "น้ำหนัก (kg)" + แผ่นพื้น/ตะแกรงเป็น ม² · ไม่มีคอนกรีต/ไม้แบบ
  // ‼️ แยกจาก stairs (คสล.) และ wood_stairs เด็ดขาด · น.น./ม. เติมจาก window.steelWeight(หน้าตัด) เหมือน steel_columns/roof_members
  steel_stairs: { label:'บันไดเหล็ก', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง/ชั้น',alt:'name'},
    {k:'width',label:'กว้าง (m)',num:1}, {k:'steps',label:'จำนวนลูกตั้ง',int:1},
    {k:'treads',label:'จำนวนลูกนอน',int:1},
    {k:'riser',label:'ลูกตั้ง (m)',num:1}, {k:'tread',label:'ลูกนอน (m)',num:1},
    {k:'slope_m',label:'ยาวตามลาด (m)',num:1,derived:1}, {k:'rise_m',label:'สูงรวม (m)',num:1,derived:1},
    {k:'stringer_section',label:'แม่บันได (หน้าตัด)',detail:1}, {k:'stringer_count',label:'แม่บันได (ตัว)',int:1,detail:1},
    {k:'tread_section',label:'โครงลูกนอน (หน้าตัด)',detail:1}, {k:'riser_section',label:'ลูกตั้ง (หน้าตัด)',detail:1},
    {k:'tread_plate_t',label:'แผ่นลูกนอน หนา (มม.)',num:1,detail:1},
    {k:'landing_L',label:'ชานพัก ยาว (m)',num:1,detail:1}, {k:'landing_W',label:'ชานพัก กว้าง (m)',num:1,detail:1},
    {k:'landing_plate_t',label:'แผ่นชานพัก หนา (มม.)',num:1,detail:1},
    {k:'handrail_section',label:'ราวจับ/ราวกันตก (หน้าตัด)',detail:1}, {k:'handrail_sides',label:'ราว (ข้าง)',int:1,detail:1},
    {k:'post_section',label:'เสาราว (หน้าตัด)',detail:1}, {k:'post_count',label:'เสาราว (ต้น)',int:1,detail:1}, {k:'post_h',label:'สูงเสาราว (m)',num:1,detail:1},
    {k:'count',label:'จำนวน',int:1,alt:'qty'},
    {k:'steel_kg',label:'น้ำหนักเหล็กรวม (kg)',num:1,derived:1,alt:'weight_kg'},
    {k:'plate_m2',label:'แผ่นพื้น/ตะแกรง (ม²)',num:1,derived:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  // ── งานสถาปัตย์ ──────────────────────────────────────────────
  walls: { label:'ผนัง', cols:[
    {k:'code',label:'รหัส'}, {k:'material',label:'วัสดุ',wide:1}, {k:'location',label:'ตำแหน่ง',alt:'name',wide:1},
    {k:'shape',label:'รูปทรง',opts:[{v:'rect',t:'สี่เหลี่ยม'},{v:'triangle',t:'สามเหลี่ยม (จั่ว)'},{v:'trapezoid',t:'คางหมู'}]},
    {k:'length',label:'ยาว (m)',num:1}, {k:'height',label:'สูง (m)',num:1}, {k:'height2',label:'สูง2 คางหมู (m)',num:1},
    {k:'count',label:'จำนวนแนว',int:1,alt:'qty'},
    {k:'gross_m2',label:'พื้นที่รวม (ม²)',num:1,derived:1}, {k:'openings_m2',label:'หักช่องเปิด (ม²)',num:1,derived:1},
    {k:'net_m2',label:'สุทธิ (ม²)',num:1,derived:1}, {k:'plaster_sides',label:'ฉาบ (หน้า)',int:1},
    {k:'plaster_m2',label:'ฉาบปูน (ม²)',num:1,derived:1}, {k:'notes',label:'หมายเหตุ'},
  ]},
  doors: { label:'ประตู', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'material',label:'วัสดุ'},
    {k:'W',label:'กว้าง (m)',num:1}, {k:'H',label:'สูง (m)',num:1},
    {k:'area_m2',label:'พื้นที่ (ม2)',num:1,derived:1,derive:(r)=> sbR2((+r.W||0)*(+r.H||0))},
    {k:'frame',label:'วงกบ'},
    {k:'count',label:'จำนวน (ชุด)',int:1,alt:'qty'}, {k:'location',label:'ตำแหน่ง (กริด)',alt:'grid'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  windows: { label:'หน้าต่าง', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'material',label:'วัสดุ'},
    {k:'W',label:'กว้าง (m)',num:1}, {k:'H',label:'สูง (m)',num:1},
    {k:'area_m2',label:'พื้นที่ (ม2)',num:1,derived:1,derive:(r)=> sbR2((+r.W||0)*(+r.H||0))},
    {k:'frame',label:'วงกบ'},
    {k:'count',label:'จำนวน (ชุด)',int:1,alt:'qty'}, {k:'location',label:'ตำแหน่ง (กริด)',alt:'grid'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  floor_finishes: { label:'พื้นสถาปัตย์ (วัสดุปูพื้น)', cols:[
    {k:'room',label:'ห้อง',alt:'name'}, {k:'material',label:'วัสดุ'},
    {k:'B',label:'B (m)',num:1}, {k:'L',label:'L (m)',num:1}, {k:'area_m2',label:'พื้นที่ (ม²)',num:1,derived:1,alt:'volume'},
    {k:'door_open_m',label:'หักช่องประตู (m)',num:1},
    {k:'skirting_m',label:'บัวเชิงผนัง (m)',num:1,derived:1}, {k:'skirting_material',label:'วัสดุบัว'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  ceilings: { label:'ฝ้าเพดาน', cols:[
    {k:'room',label:'ห้อง',alt:'name'}, {k:'material',label:'วัสดุ'},
    {k:'level',label:'ระดับฝ้า (m)',num:1},
    {k:'B',label:'B (m)',num:1}, {k:'L',label:'L (m)',num:1},
    {k:'area_m2',label:'พื้นที่ (ม²)',num:1,derived:1,alt:'volume'},
    {k:'cornice_m',label:'บัวฝ้า (m)',num:1}, {k:'notes',label:'หมายเหตุ'},
  ]},
  waterproofing: { label:'กันซึม', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'พื้นที่/ห้อง',alt:'room'},
    {k:'type',label:'ชนิดพื้นที่'}, {k:'material',label:'ระบบกันซึม'},
    {k:'area_m2',label:'พื้นที่พื้น (ม²)',num:1,alt:'volume'},
    {k:'upturn_h',label:'สูงขอบกันซึม (m)',num:1}, {k:'upturn_m2',label:'ขอบกันซึม (ม²)',num:1},
    {k:'total_m2',label:'รวม (ม²)',num:1,derived:1}, {k:'notes',label:'หมายเหตุ'},
  ]},
  // วัสดุมุงหลังคา (สถาปัตย์) — วัสดุที่มุงบนโครงหลังคา (เมทัลชีท/กระเบื้อง ฯลฯ) · คนละตัวกับ "หลังคา" (โครงเหล็ก/คสล.)
  // ‼️ พื้นที่จริง = พื้นที่ฉายราบ ÷ cos(มุมลาด) (mirror roof) · แผ่นรอง/ฉนวน = พื้นที่จริง (เฉพาะที่ระบุ)
  roof_covering: { label:'วัสดุมุงหลังคา', cols:[
    {k:'code',label:'รหัส'}, {k:'location',label:'ตำแหน่ง/อาคาร',alt:'name'},
    {k:'material',label:'วัสดุมุง'},
    {k:'flat_area',label:'พื้นที่ฉายราบ (ม²)',num:1,alt:'volume'},
    {k:'angle_deg',label:'มุมลาด (°)',int:1},
    {k:'actual_area',label:'พื้นที่จริงตามลาด (ม²)',num:1,derived:1},
    {k:'underlay',label:'แผ่นรอง/ฉนวนกันความร้อน'},
    {k:'underlay_m2',label:'พื้นที่แผ่นรอง (ม²)',num:1,derived:1},
    {k:'ridge_m',label:'ครอบสัน/ครอบข้าง (m)',num:1},
    {k:'eave_m',label:'เชิงชาย/ปั้นลม (m)',num:1},
    {k:'notes',label:'หมายเหตุ'},
  ]},
  // ── งานสุขาภิบาล ──────────────────────────────────────────────
  sanitary_ware: { label:'สุขภัณฑ์', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'material',label:'สเปก/วัสดุ'},
    {k:'count',label:'จำนวน (ชุด)',int:1,alt:'qty'}, {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  water_pipes: { label:'ท่อน้ำดี', cols:[
    {k:'code',label:'รหัส'}, {k:'system',label:'ระบบ'}, {k:'material',label:'วัสดุ/ชั้น'},
    {k:'dia',label:'ขนาด Ø'}, {k:'length_m',label:'ยาว (m)',num:1,alt:'volume'}, {k:'basis',label:'ที่มา'},
    {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  drain_pipes: { label:'ท่อน้ำทิ้ง-โสโครก', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'material',label:'วัสดุ/ชั้น'},
    {k:'dia',label:'ขนาด Ø'}, {k:'length_m',label:'ยาว (m)',num:1,alt:'volume'}, {k:'basis',label:'ที่มา'},
    {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  sani_tanks: { label:'บ่อ-ถังบำบัด', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'size',label:'ขนาด/ความจุ'},
    {k:'count',label:'จำนวน',int:1,alt:'qty'}, {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  pumps_tanks: { label:'ปั๊ม-ถังน้ำดี', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'spec',label:'สเปก/รุ่น',alt:'material'},
    {k:'size',label:'ขนาด/ความจุ'}, {k:'count',label:'จำนวน (ชุด)',int:1,alt:'qty'},
    {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  // ── งานไฟฟ้า ──────────────────────────────────────────────────
  luminaires: { label:'ดวงโคม', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิดโคม'}, {k:'lamp',label:'หลอด/สเปก'},
    {k:'mount',label:'การติดตั้ง'}, {k:'count',label:'จำนวน (ชุด)',int:1,alt:'qty'},
    {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  outlets_switches: { label:'เต้ารับ-สวิตช์', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'rating',label:'พิกัด (A)'},
    {k:'count',label:'จำนวน (จุด)',int:1,alt:'qty'}, {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
  wiring: { label:'สายไฟ-ท่อร้อยสาย', cols:[
    // รายการ: วงจรแสงสว่าง (L) · วงจรเต้ารับ (RC) · สายเมน · สายดิน · ท่อ (แถวของตัวเอง) — ทุกแถวเป็นเมตร
    {k:'code',label:'รหัส'}, {k:'circuit',label:'รายการ'},
    {k:'conductor',label:'สายไฟ (สเปก)',alt:'wire_ref'},
    // เส้น: อ่านจากสเปกสาย · แบบไม่ระบุสเปก = ว่าง ให้ผู้ใช้กรอก (กรอบส้ม · needIf) · แถวท่อไม่มีเส้น (naIf)
    // ปริมาณรวม: สาย = ความยาว × เส้น (ยังไม่กรอกเส้น = ความยาวไปก่อน) · ท่อ = ความยาว (พิ้งกำหนด 24 ต.ค.)
    {k:'route_m',label:'ความยาว (ม.)',num:1},
    {k:'n_cond',label:'เส้น',int:1, naIf:r=>r.row_type==='conduit',
      needIf:r=>(r.row_type==='branch'||r.row_type==='feeder') && !(+r.n_cond>0),
      needMsg:'ยังไม่ระบุจำนวนเส้น — กรอกตามสเปกสาย (ระหว่างนี้ปริมาณรวม = ความยาว)'},
    {k:'qty_m',label:'ปริมาณรวม (ม.)',num:1,derived:1,mainTab:1},   // mainTab = คิดอัตโนมัติแต่อยู่แท็บหลัก (ปริมาณที่ใช้จริง)
    {k:'basis',label:'ที่มา',detail:1}, {k:'notes',label:'หมายเหตุ'},
  ]},
  panels: { label:'ตู้-แผงจ่ายไฟ', cols:[
    {k:'code',label:'รหัส'}, {k:'type',label:'ชนิด'}, {k:'rating',label:'พิกัด'},
    {k:'ways',label:'จำนวนช่อง',int:1,naIf:r=>!sbIsPanelRow(r)}, {k:'count',label:'จำนวน (ตู้)',int:1,alt:'qty'},
    {k:'location',label:'ตำแหน่ง'}, {k:'notes',label:'หมายเหตุ'},
  ]},
};
// ‼️ ทุกชีตต้องมีคอลัมน์อ้างอิงแผ่นแบบท้ายสุด — เติมอัตโนมัติ ไม่ต้องไล่เพิ่มทีละชีต
//    page_ref = รหัสแผ่นจาก title block (เช่น "A-09", "S-03,S-01") ที่ AI อ่านข้อมูลแถวนั้นมา
//    ‼️ ไม่ใช้เลขหน้า PDF: screen_upload ตัดหน้าที่เลือกด้วย pdf-lib → หน้าถูกนับ 1 ใหม่ เลขจึงไม่ตรงแบบจริง
//    แก้มือได้ (ไม่ใช่ derived) — AI อ่าน title block พลาดได้ ให้ผู้ใช้แก้ทับ
Object.values(SB_SHEET_COLS).forEach(s=>{
  if(!s.cols.some(c=>c.k==='page_ref')) s.cols.push({k:'page_ref',label:'แผ่นแบบ'});
});
// viewCols = คอลัมน์ที่ตารางวาดจริง (ช่องสเปกเหล็กถูกแตกเป็นช่องย่อยแล้ว) — แตกครั้งเดียวตอนโหลด
// ‼️ cols = ตัวจริงที่ผูกกับ field เสมอ (sbBlankRow ใช้ตัวนี้) · อย่าเอา viewCols ไปสร้างแถว
// ‼️ ซ่อน "แผ่นแบบ" (page_ref) จากตารางบนจอ (เจ้าของ 2026-10-07: ไม่จำเป็นต้องโชว์) — ข้อมูลยังอยู่ใน cols/แถว
//    Excel ยังออกคอลัมน์ "แผ่นแบบ" (excel-export อ่าน r.page_ref ตรง) · pagebar ยังโชว์รหัสแผ่นจาก items
Object.values(SB_SHEET_COLS).forEach(s=>{ s.viewCols = sbExpandCols(s.cols).filter(c=>c.k!=='page_ref'); });
// คอลัมน์ "เสริม/ตามชนิด" ที่ซ่อนได้เมื่อว่างทั้งคอลัมน์ (ดูง่ายสบายตา) — ‼️ explicit list กันซ่อนมิติหลักพลาด
//   (ตำแหน่งกริดจับด้วย label แยก · B2 จับด้วยรูปทรงแยก · ช่องมิติหลัก B/L/T/สูง/ยาว/จำนวน/เหล็กหลัก ไม่อยู่ในนี้)
const SB_AUTOHIDE_EMPTY = new Set([
  'ties_sets',                           // ชุดปลอก (เบิ้ล) — เสา/คาน
  'spacing_m', 'span_m',                 // ระยะเรียง @ / ช่วงกระจาย — สมาชิกโครงหลังคา
  'wiremesh', 'wiremesh_kg', 'rebar_top',// ตะแกรงลวด / นน.ตะแกรง / เหล็กบนเต็มผืน — พื้นหล่อในที่
  'top_sup_short', 'top_sup_short_m', 'top_sup_long', 'top_sup_long_m', 'rebar_sup_kg', // เหล็กบนหัวคาน — พื้นหล่อในที่
  'shape', 'width_top',                  // รูปทรง/ฐานบน — ผืนหลังคา (ว่าง = สี่เหลี่ยม)
  'rebar_top_add', 'rebar_top_sup', 'rebar_bot_mid', // เหล็กเสริมพิเศษของคาน
]);
// หมวด (CAT_COLOR) → sheet ที่เกี่ยวข้อง
const SB_CAT_SHEETS = {
  'ฐานราก': ['footings'], 'เสา': ['columns','steel_columns','steel_col_fittings'], 'คาน': ['beams'],
  'พื้นโครงสร้าง': ['slabs_cip','slabs_precast'], 'บันได': ['stairs','wood_stairs','steel_stairs'], 'หลังคา': ['roof','roof_members'],
  'ผนัง': ['walls'], 'ประตู-หน้าต่าง': ['doors','windows'],
  'พื้นสถาปัตย์': ['floor_finishes'], 'ฝ้าเพดาน': ['ceilings'], 'กันซึม': ['waterproofing'], 'วัสดุมุงหลังคา': ['roof_covering'],
  'สุขภัณฑ์': ['sanitary_ware'], 'ท่อน้ำดี': ['water_pipes'],
  'ท่อน้ำทิ้ง-โสโครก': ['drain_pipes'], 'บ่อ-ถังบำบัด': ['sani_tanks'], 'ปั๊ม-ถังน้ำดี': ['pumps_tanks'],
  'ดวงโคม': ['luminaires'], 'เต้ารับ-สวิตช์': ['outlets_switches'],
  'สายไฟ-ท่อร้อยสาย': ['wiring'], 'ตู้-แผงจ่ายไฟ': ['panels'],
};
// สีกรอบ marker ต่อรหัส (item_marks งานสุขาภิบาล) — ชุดเดียวกับ marker งานไฟฟ้า (elec-marks.jsx)
const ITEM_MARK_COLORS = ['#2563eb','#16a34a','#dc2626','#9333ea','#0891b2','#ea580c','#be185d','#4d7c0f','#7c3aed','#b45309','#0f766e','#475569'];
// ปุ่มวาง marker เลือก 4 หมวดงาน (id = disc ใน SCOPE_ITEMS ของ data.jsx)
const MARK_DISCS = [{id:'str',th:'โครงสร้าง'},{id:'arch',th:'สถาปัตย์'},{id:'sani',th:'สุขาภิบาล'},{id:'elec',th:'ไฟฟ้า'}];
// คอลัมน์ทั่วไป (สำหรับหมวดที่ไม่มี sheet เฉพาะ เช่น บันได)
const SB_GENERIC_COLS = [
  {k:'code',label:'รหัส'}, {k:'name',label:'รายการ',alt:'notes'},
  {k:'qty',label:'จำนวน',int:1}, {k:'unit',label:'หน่วย'},
];

// ── สูตรเรขาคณิตอัตโนมัติ (mirror excel-export.jsx) — เหล็ก (rebar_kg/weight_kg) แก้มือ ──
const sbR2 = (n) => Math.round((Number(n)||0)*100)/100;
const sbSection = (s) => { const p=String(s||'0.3×0.4').split(/[×x]/); return [Number(p[0])||0, Number(p[1])||0]; };
// ── เหล็กแยกขนาด (สำหรับสั่งซื้อ/คิดราคาให้ถูกชนิด): kg ต่อขนาด เช่น {DB12:..,RB9:..} ──
// Ø → DB(≥10 ข้ออ้อย)/RB(<10 กลม) ให้ตรงกับ sizeTokens ใน price-match
const sbSizeKey = (t, d) => ((t==='DB'||t==='RB') ? t : (Number(d)>=10?'DB':'RB')) + d;
const sbAddSize = (map, t, d, kg) => { if(!(kg>0)||!(d>0)) return; const k=sbSizeKey(t,d); map[k]=sbR2((map[k]||0)+kg); };
const sbScaleSize = (map, f) => { const o={}; for(const k in (map||{})) o[k]=sbR2(map[k]*f); return o; };
const sbMergeSize = (a, b) => { const o={}; [a,b].forEach(m=>{ for(const k in (m||{})) o[k]=sbR2((o[k]||0)+m[k]); }); return o; };
// parse สเปกปลอก → {d:ขนาด มม., sp:ระยะเรียง ม.} · รองรับ "Ø6@0.15m" "RB9mm@0.20m" "DB12mm@0.15m"
// ไม่มี @ระยะ → คืน null (คิดน้ำหนักไม่ได้ ต้องกรอกมือ — ไม่เดา)
const sbTies = (s) => {
  const t = String(s||'');
  const d  = t.match(/(Ø|DB|RB)\s*(\d+(?:\.\d+)?)/i);
  const sp = t.match(/@\s*(\d+(?:\.\d+)?)/);
  if(!d || !sp) return null;
  const dia = Number(d[2]), spc = Number(sp[1]);
  if(!(dia>0) || !(spc>0)) return null;
  return { d:dia, sp:spc, t:d[1].toUpperCase() };
};
// ปลอก → {kg, len} · n=ceil(L/@) · ยาว/ตัว = เส้นรอบรูปหักระยะหุ้ม + งอ 135° 2 ข้าง (2×12d)
const sbTiesCalc = (section, L, ties, count) => {
  const t = sbTies(ties);
  if(!t) return sbHasSpec(ties) ? { kg:0, len:0, bySize:{}, bad:[String(ties)] } : null;
  const [B,D] = sbSection(section);
  const c = REBAR.cover;
  const peri = 2*((B-2*c) + (D-2*c));
  if(!(peri>0) || !(L>0)) return { kg:0, len:0, bySize:{}, bad:[] };
  const lenEach = peri + REBAR.hookN*REBAR.hook*t.d/1000;
  const totLen = sbCeil(L/t.sp) * lenEach * (Number(count)||1);
  const kg = sbR2(totLen*(t.d*t.d/162));
  const bySize = {}; sbAddSize(bySize, t.t, t.d, kg);
  return { kg, len:sbR2(totLen), bySize, bad:[] };
};
// parse สเปกเหล็กหลัก → {n:จำนวนเส้น, d:ขนาด มม.} · รองรับ "4Ø16mm" "2-DB16" "5+5-DB12mm"
// ไม่มีจำนวนเส้นนำหน้า (เช่น "RB9mm") → null (คิดไม่ได้ ใช้ค่าจาก AI แทน)
const sbBars = (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;
};
// เหล็กหลัก → {kg, len}: Σ [n เส้น × (ความยาว + addD×d)] × จำนวนสมาชิก · addD ค่าเริ่ม = ทาบ 40d + งอ 12d
// ‼️ เสาส่ง addD = REBAR.colMainAdd (0 = ยาวเท่าความสูงเสา — เจ้าของเลือก 2026-10-16)
const sbMainCalc = (specs, L, count, addD = REBAR.lap + REBAR.hook) => {
  const len = Number(L)||0; if(!(len>0)) return null;
  let kg = 0, tot = 0, ok = false; const bySize = {}, bad = [];
  (specs||[]).forEach(s => {
    const b = sbBars(s); if(!b){ if(sbHasSpec(s)) bad.push(String(s)); return; }
    const barLen = b.n * (len + addD*b.d/1000) * (Number(count)||1);
    const gkg = barLen * (b.d*b.d/162);
    tot += barLen; kg += gkg; ok = true; sbAddSize(bySize, b.t, b.d, gkg);
  });
  return (ok || bad.length) ? { kg:sbR2(kg), len:sbR2(tot), bySize, bad } : null;
};
// เหล็กหลักคาน — คิดตาม "บทบาท" (ยาวต่างกันตามชนิดคาน) · ต้องตรงกับ beamMainCalc ใน excel-export.jsx
//  วิ่งตลอด (บน/บนเสริม/ล่าง) = L + งอ 2×12d (ดู sbBeamThrough) · ล่างเสริมกลางช่วง = 0.80L + 2×12d · บนเสริมหัวเสา = 0.50L(ยื่น0.25L×2หัว) + 2×12d
//  ‼️ 2026-10-16 เจ้าของเลือก: เส้นวิ่งตลอด = L + งอ 2×12d (+ ทาบ REBAR.beamLap×d — 0 = ไม่บวกทาบต่อช่วง) แทน L + ทาบ40d + งอ12d
const sbBeamThrough = (len) => (d) => len + ((+REBAR.beamLap||0) + REBAR.hookN*REBAR.hook)*d/1000;
const sbBeamMainCalc = (r, L, count) => {
  const len = Number(L)||0; if(!(len>0)) return null;
  const n = Number(count)||1, hook = REBAR.hook;
  let kg = 0, tot = 0, ok = false; const bySize = {}, bad = [];
  const add = (spec, lenOf) => {
    const b = sbBars(spec); if(!b){ if(sbHasSpec(spec)) bad.push(String(spec)); return; }
    const barLen = b.n * lenOf(b.d) * n;
    const gkg = barLen * (b.d*b.d/162);
    tot += barLen; kg += gkg; ok = true; sbAddSize(bySize, b.t, b.d, gkg);
  };
  const through = sbBeamThrough(len);               // วิ่งตลอด
  add(r.rebar_top||r.rebar, through);               // บนหลัก
  add(r.rebar_top_add,      through);               // บนเสริม (แถวเดียวกับบน วิ่งตลอด)
  add(r.rebar_bot,          through);               // ล่างหลัก
  add(r.rebar_top_sup, (d)=> 0.50*len + 2*hook*d/1000);   // บนเสริมหัวเสา (partial)
  add(r.rebar_bot_mid, (d)=> 0.80*len + 2*hook*d/1000);   // ล่างเสริมกลางช่วง (partial)
  return (ok || bad.length) ? { kg:sbR2(kg), len:sbR2(tot), bySize, bad } : null;
};
// แยกน้ำหนัก/ความยาวเหล็ก "บน" (top+top_add+top_sup) vs "ล่าง" (bot+bot_mid) ตามคอลัมน์เฉลย
// ‼️ ใช้สูตรความยาวเดียวกับ sbBeamMainCalc → ผลรวม (top+bot) = rebar_kg เดิม (regression=0)
const sbBeamSplit = (r, L, count) => {
  const len=Number(L)||0; if(!(len>0)) return null;
  const n=Number(count)||1, hook=REBAR.hook;
  const through=sbBeamThrough(len);
  let ok=false;
  const grp=(items)=>{ let kg=0,tot=0; items.forEach(([spec,lenOf])=>{ const b=sbBars(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:sbR2(kg), len:sbR2(tot) }; };
  const top=grp([[r.rebar_top||r.rebar,through],[r.rebar_top_add,through],[r.rebar_top_sup,(d)=>0.50*len+2*hook*d/1000]]);
  const bot=grp([[r.rebar_bot,through],[r.rebar_bot_mid,(d)=>0.80*len+2*hook*d/1000]]);
  return ok ? { top, bot } : null;
};
// น้ำหนักเหล็กพื้น (ตะแกรง 2 ทิศ): เส้นขนานด้านสั้น ยาว=ด้านสั้น เรียงตามด้านยาว (และกลับกัน)
// n = floor(ช่วงตั้งฉาก/@)+1 (มีเส้นริม 2 ข้าง) · ยาว/เส้น = span − 2c + งอปลาย 2×12d
const sbSlabCalc = (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), c = REBAR.cover, cnt = Number(count)||1;
  let kg = 0, tot = 0, ok = false; const bySize = {}, bad = [];
  const dir = (spec, spanLen, alongLen) => {
    const t = sbTies(spec); if(!t){ if(sbHasSpec(spec)) bad.push(String(spec)); return; }
    const lenEach = (spanLen - 2*c) + REBAR.hookN*REBAR.hook*t.d/1000;
    if(!(lenEach > 0)) { ok = true; return; }
    const barLen = (sbFloor(alongLen/t.sp) + 1) * lenEach * cnt;
    const gkg = barLen * (t.d*t.d/162);
    tot += barLen; kg += gkg; ok = true; sbAddSize(bySize, t.t, t.d, gkg);
  };
  dir(rebarShort, shortS, longS);   // ขนานด้านสั้น → ยาว=ด้านสั้น, เรียงตามด้านยาว
  dir(rebarLong,  longS,  shortS);  // ขนานด้านยาว → ยาว=ด้านยาว, เรียงตามด้านสั้น
  return (ok || bad.length) ? { kg:sbR2(kg), len:sbR2(tot), bySize, bad } : null;
};
// เหล็กบนหัวคาน (แถบริมคาน) — เจ้าของเลือกแบบ A 2026-10-19 · ต้องตรงกับ slabSupCalc ใน excel-export.jsx + template-spec
//  ด้านสั้น = เหล็กแนวด้านสั้น วางที่ 2 ขอบยาว · ด้านยาว = เหล็กแนวด้านยาว วางที่ 2 ขอบสั้น (ทิศเดียวกับเหล็กล่าง)
//  ต่อแถบ: เหล็กหลัก floor(ขอบ/@)+1 เส้น ยาว = ยื่น + งอลงคาน 12d · เหล็กกระจายในแถบ (จุดในรูปตัด) ceil(ยื่น/@) เส้น
//  ยาว = ขอบ − 2c ใช้สเปกเดียวกับเหล็กหลักแถบนั้น · ยื่นว่าง = ¼ ของช่วงทิศนั้น
const sbSlabSupCalc = (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), c = REBAR.cover, cnt = Number(count)||1;
  let kg = 0, tot = 0, ok = false; const bySize = {}, bad = [];
  const strip = (spec, ext, span, edgeLen) => {
    const t = sbTies(spec); if(!t){ if(sbHasSpec(spec)) bad.push(String(spec)); return; }
    const e = (+ext>0) ? +ext : span/4;
    const main = (sbFloor(edgeLen/t.sp) + 1) * (e + REBAR.hook*t.d/1000);
    const dist = sbCeil(e/t.sp) * Math.max(edgeLen - 2*c, 0);
    const barLen = 2 * (main + dist) * cnt;              // 2 ขอบ
    const gkg = barLen * (t.d*t.d/162);
    tot += barLen; kg += gkg; ok = true; sbAddSize(bySize, t.t, t.d, gkg);
  };
  strip(specS, extS, shortS, longS);
  strip(specL, extL, longS, shortS);
  return (ok || bad.length) ? { kg:sbR2(kg), len:sbR2(tot), bySize, bad } : null;
};
// ตะแกรงสำเร็จ (WIREMESH) → {kg, len} · ใช้กับ slabs_cip.wiremesh + slabs_precast.topping_rebar (เจ้าของเลือก 2026-10-16)
// 2 ทิศ · จำนวนเส้น = floor(ช่วงตั้งฉาก/@)+1 · ยาว/เส้น = เต็มช่วง (ไม่หักระยะหุ้ม ไม่บวกงอ — ตะแกรงตัดเต็มแผ่น)
// สเปกรับ "WIREMESH Ø4mm@0.20" / "Wiremesh 4mm @ 0.20 m." / "Ø6mm@0.20m" · ไม่มีขนาด มม./ระยะ (เช่น "#4@0.20" เบอร์ลวด) → null = ใช้ kg ที่กรอกมือ
const sbMesh = (s) => {
  const t = String(s||'');
  const d = t.match(/(?:Ø|DB|RB)\s*(\d+(?:\.\d+)?)/i) || t.match(/(\d+(?:\.\d+)?)\s*mm/i);
  const sp = t.match(/@\s*(\d+(?:\.\d+)?)/);
  const dia = d ? Number(d[1]) : 0, spc = sp ? Number(sp[1]) : 0;
  return (dia>0 && dia<20 && spc>0) ? { d:dia, sp:spc } : null;
};
const sbMeshCalc = (B, L, spec, count) => {
  const m = sbMesh(spec), b = Number(B)||0, l = Number(L)||0;
  if(!m || !(b>0) || !(l>0)) return null;
  const len = ((sbFloor(l/m.sp)+1)*b + (sbFloor(b/m.sp)+1)*l) * (Number(count)||1);
  return { kg:sbR2(len*(m.d*m.d/162)), len:sbR2(len) };
};
// เหล็กล่างฐานราก (ตะแกรง 2 ทิศ) — ต้องตรงกับ footRebarCalc ใน excel-export.jsx
// ‼️ ระบุแกนตรง ๆ ไม่ใช้ min/max แบบ sbSlabCalc: rebar_x = เหล็กขนานแกน X → ยาว = B เรียงตามด้าน L
//    (ถ้าใช้ short/long แบบพื้น พอ B>L จะสลับทิศเงียบ ๆ)
// ‼️ ระยะหุ้มใช้ footCover 5 ซม. (ฐานรากหล่อบน lean) ไม่ใช่ 2.5 ซม. ของเสา/คาน
// ‼️ รองรับ 2 แบบ: ระยะเรียง "DB16mm@0.15" (sbTies) · นับเส้น "8Ø12mm"/"5+5-DB12mm" (sbBars)
// ‼️ มีสเปกแต่ parse ไม่ได้แม้ทิศเดียว → null ทั้งก้อน ใช้ค่า AI แทน — ไม่คิดครึ่ง ๆ กลาง ๆ ให้เหล็กขาด
const sbHasSpec = (s) => { const t = String(s==null?'':s).trim(); return !!t && t !== '-'; };
// ขนาดหน้าตัดไม้ "2\"x8\"" / "2x8" / "4\"×4\"" → {w,t} หน่วยนิ้ว · parse ไม่ได้ = null (ไม่เดา)
const sbWoodSize = (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;
};
const SB_WOOD_IN = 0.0254, SB_WOOD_CUFT = 35.3147;   // ม./นิ้ว · ลบ.ฟ./ลบ.ม. (ไม้ไทยคิดเป็นลูกบาศก์ฟุต)
// เรขาคณิตบันไดไม้ = เหมือนบันได คสล. (rise/run/slope) · ลูกนอน = steps−1 (ขั้นบนสุด = พื้นชั้นบน)
const sbWoodStairGeo = (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 };
};
// ปริมาตรไม้รวม = Σ(หน้าตัด × ยาว × จำนวน) ทุกสมาชิก — โค้ดคิดความยาวจากเรขาคณิต (VE ได้)
// ‼️ สเปกไม้ตัวไหน parse ไม่ได้ → ข้ามตัวนั้น + นับ bad (เตือน) ไม่ null ทั้งก้อน (ตัวอื่นที่อ่านได้ยังใช้ได้)
// ต้องตรงกับ woodStairCalc ใน excel-export.jsx
const sbWoodStairCalc = (r) => {
  const g = sbWoodStairGeo(r);
  if(!(g.W>0) || !(g.slope>0)) return null;
  let vol = 0, bad = 0; const parts = [];
  const add = (spec, cnt, L, role) => {
    if(!sbHasSpec(spec)) return;
    const s = sbWoodSize(spec); if(!s){ bad++; return; }
    if(!(cnt>0) || !(L>0)) return;
    const v = s.w*SB_WOOD_IN * s.t*SB_WOOD_IN * L * cnt;
    vol += v; parts.push({ role, size:`${s.w}"×${s.t}"`, cnt, L:sbR2(L), v:sbR2(v) });
  };
  add(r.stringer_size, +r.stringer_count||2, g.slope, 'แม่บันได');   // วิ่งตามลาด ปกติ 2 ตัว
  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(sbHasSpec(r.baluster_size) && sp>0 && sides>0)
    add(r.baluster_size, (sbFloor(g.slope/sp)+1)*sides, rh, 'ลูกกรง');
  if(vol<=0) return null;
  return { m3:sbR2(vol*g.n), cuft:sbR2(vol*g.n*SB_WOOD_CUFT), parts, bad };
};
// ── บันไดเหล็ก: น้ำหนักเหล็ก (kg) + แผ่นพื้น (ม²) ────────────────────────────
// เรขาคณิตเหมือนบันได คสล./ไม้ (rise/run/slope) — โค้ดคิดความยาวเอง (VE ได้ ไม่ต้องยิง AI ซ้ำ)
const SB_STEEL_DEN = 7850;   // กก./ม³ (เหล็ก) — ค่าเดียวกับ steel_col_fittings
const sbSteelStairGeo = (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 };
};
// รวมน้ำหนักทุกสมาชิก · ‼️ หน้าตัดตัวไหนจับคู่ตารางเหล็กไม่ได้ → ข้ามตัวนั้น + นับ bad (เตือน) ไม่เดา 0
// ‼️ สเปกว่าง = ข้ามเงียบ (บันไดโปร่งไม่มีลูกตั้ง / ไม่มีชานพัก = ปกติ ไม่ใช่ error)
// ต้องตรงกับ steelStairCalc ใน excel-export.jsx
const sbSteelStairCalc = (r) => {
  const g = sbSteelStairGeo(r);
  if(!(g.W>0) || !(g.slope>0)) return null;
  let kg = 0, m2 = 0, bad = 0; const parts = [];
  // สมาชิกเหล็กรูปพรรณ: kg = น.น./ม. × ยาว × จำนวน
  const add = (section, cnt, L, role) => {
    if(!sbHasSpec(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, w = len*uw;
    kg += w; parts.push({ role, size:String(section).trim(), uw:sbR2(uw), cnt, L:sbR2(L), len:sbR2(len), kg:sbR2(w) });
  };
  // แผ่น/ตะแกรง: ม² ตามพื้นที่ · kg = ม² × หนา(มม.→ม.) × 7850
  const addPlate = (t_mm, area, role) => {
    const t = +t_mm||0;
    if(!(t>0) || !(area>0)) return;
    const w = area*(t/1000)*SB_STEEL_DEN;
    kg += w; m2 += area; parts.push({ role, size:'หนา '+sbR2(t)+' มม.', m2:sbR2(area), kg:sbR2(w) });
  };
  add(r.stringer_section, +r.stringer_count||2, g.slope, 'แม่บันได');       // วิ่งตามลาด ปกติ 2 ตัว
  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, 'แผ่นชานพัก');
  if(kg<=0 && m2<=0) return null;
  return { kg:sbR2(kg*g.n), m2:sbR2(m2*g.n), parts, bad, n:g.n };
};
// ตะแกรงบน (rebar_top · สเปกเดียวใช้ 2 ทิศ) — topU = ดัดเป็นตัว U คว่ำ ขาลงข้างฐานเต็มความหนา → +2×(T−2c)/เส้น (เจ้าของเลือก 2026-10-17)
const sbFootTopU = (s) => /u/i.test(String(s||''));
// ตะแกรงฐานราก "a+bØd #" = a เส้นแกน X + b เส้นแกน Y (เจ้าของยืนยัน 2026-10-18 · ห่วงใยฯ2 "6+6Ø12 #" = 6 เส้น/ทิศ)
//   เดิม sbBars รวมเป็น a+b เส้นในทุกทิศ → AI ใส่ "6+6Ø12" ทั้งช่อง X และ Y = เหล็ก 2 เท่า
//   ช่อง Y ว่างแต่ช่อง X เป็น "a+b" = เขียนตะแกรงครั้งเดียว → Y ใช้ b · "a+b+c" (3 ตัวขึ้นไป) ไม่แตะ
//   ต้องตรงกับ footMesh ใน excel-export.jsx
const SB_FOOT_PAIR = /^(\s*)(\d+)\s*\+\s*(\d+)(?=\s*[-–]?\s*(?:Ø|DB|RB)\s*\d)/i;
const sbFootMesh = (rx, ry, top) => {
  const pick = (s, i) => String(s).replace(SB_FOOT_PAIR, (m, sp, a, b) => sp + (i ? b : a));
  const isPair = (s) => SB_FOOT_PAIR.test(String(s||''));
  const y = sbHasSpec(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 sbFootRebarCalc = (B, L, T, rx, ry, count, top, topU) => {
  const mesh = sbFootMesh(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 = (REBAR.footCover != null ? REBAR.footCover : 0.05);
  // ยาว/เส้น = ช่วงราบ (span−2c) + งอปลาย 2×12d (มาตรฐานที่เจ้าของเลือก 2026-10-16)
  // ‼️ เลิกขาตั้ง 2×(T−2c) ของเหล็กล่าง: ฐานหนา 0.70 ได้ขาข้างละ 0.60 ม. เหล็กเกินเกือบ 2 เท่า (ขาเต็มความหนามีเฉพาะตะแกรงบนตัว U)
  let kg = 0, tot = 0, ok = 0, topKg = 0, topLen = 0; const bySize = {}, bad = [];
  const leg = topU ? 2*Math.max(0, (Number(T)||0) - 2*c) : 0;
  const dir = (spec, spanLen, alongLen, isTop) => {
    if(!sbHasSpec(spec)) return;            // ไม่ได้ระบุทิศนี้ = ข้าม ไม่ใช่ความล้มเหลว
    let n = 0, d = 0, tp = '';
    const t = sbTies(spec);
    if(t){ n = sbFloor(alongLen/t.sp) + 1; d = t.d; tp = t.t; }
    else {
      const bar = sbBars(spec);
      if(!bar){ bad.push(String(spec)); return; }
      n = bar.n; d = bar.d; tp = bar.t;
    }
    const lenEach = (spanLen - 2*c) + (isTop ? leg : 0) + REBAR.hookN*REBAR.hook*d/1000;
    if(!(n>0) || !(lenEach>0)){ bad.push(String(spec)); return; }
    const barLen = n * lenEach * cnt;
    const gkg = barLen * (d*d/162);
    tot += barLen; kg += gkg; ok++; sbAddSize(bySize, tp, d, gkg);
    if(isTop){ topLen += barLen; topKg += gkg; }
  };
  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 ทิศ (ตาม "#" ในแบบ)
  // ‼️ เดิม: bad ทิศใด → null ทั้งก้อน ใช้ค่า AI · ตอนนี้: คืนทิศที่อ่านได้แยกขนาด + bad ให้หน้าราคาตั้ง needsQty
  return (ok > 0 || bad.length) ? { kg:sbR2(kg), len:sbR2(tot), bySize, bad, topKg:sbR2(topKg), topLen:sbR2(topLen) } : null;
};
// เหล็กรัดฐานราก — "@" = ปลอกปิดรอบหน้าตัด B×T เรียงตาม L (sbTiesCalc เดิม) ·
// "นับวง" เช่น "4-RB9" (แบบเขียน "รัดรอบ" ไม่บอกระยะ → นับเส้นจากรูปตัด · เจ้าของเลือก 2026-10-17) = n วงรอบแปลนฐาน 2((B−2c)+(L−2c)) + 2×12d ต่อฐาน
const sbFootTiesCalc = (B, L, T, ties, count) => {
  if(sbTies(ties)) return sbTiesCalc(B+'×'+T, L, ties, count);
  const bar = sbBars(ties);
  if(!bar) return sbTiesCalc(B+'×'+T, L, ties, count);   // ว่าง → null · อ่านไม่ได้ → bad
  const c = REBAR.cover, peri = 2*(((Number(B)||0)-2*c) + ((Number(L)||0)-2*c));
  if(!(peri>0)) return { kg:0, len:0, bySize:{}, bad:[] };
  const totLen = bar.n * (peri + REBAR.hookN*REBAR.hook*bar.d/1000) * (Number(count)||1);
  const kg = sbR2(totLen*(bar.d*bar.d/162));
  const bySize = {}; sbAddSize(bySize, bar.t, bar.d, kg);
  return { kg, len:sbR2(totLen), bySize, bad:[] };
};
// ── เรขาคณิตบันได — ใช้ร่วมทั้งคอนกรีต/ไม้แบบ/เหล็ก (ต้องตรงกับ st_geo ใน excel-export.jsx) ──
// ‼️ ลูกนอนมี steps−1 เสมอ (ขั้นบนสุด = ระดับชานพัก/พื้น ไม่ต้องมีลูกนอนของตัวเอง)
//    → run = (steps−1)×tread · slope = √(rise² + run²) ของทั้งช่วง
//    (สูตรเดิม steps×√(riser²+tread²) = ผลรวมด้านเอียงทีละขั้น → เกินจริง ~1 ขั้น ≈ 4%)
// ‼️ ชานพัก: แบบให้มาเป็น ม² อย่างเดียว → อนุมานว่ากว้างเท่าบันได เพื่อหาความยาว (สำหรับเหล็กที่วิ่งต่อเข้าชานพัก)
// ‼️ landing_t = ความหนาชานพัก · แบบมักหนากว่าท้องบันได — อ่านไม่ได้ค่อย fallback เป็น waist_t
// ‼️ ชานพัก: มีมิติจริง (landing_L×landing_W) → ใช้ตรง ๆ · มีแต่ ม² → อนุมานว่ากว้างเท่าบันได (ทางเก่า)
const sbStairGeo = (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 hasDims = lL>0 && lW>0;
  const la = hasDims ? lL*lW : (+r.landing_area||0);
  const rise = ns*ri, run = Math.max(ns-1,0)*td;
  return { W, ns, ri, td, wt, la, lt, n, rise, hasDims,
           slope: Math.sqrt(rise*rise + run*run),
           landing_L: lL>0 ? lL : (W>0 ? la/W : 0),
           sides: +r.handrail_sides||0 };
};
// เหล็กบันได → {kg, len, topSkipped} · null = สเปกอ่านไม่ได้ ใช้ค่า AI แทน (ต้องตรงกับ stairRebarCalc ใน excel-export.jsx)
// เหล็กหลัก  : วิ่งตามลาดต่อเนื่องเข้าชานพัก (slope + ชานพัก) เรียงตามความกว้าง · ยาว/เส้น = ระยะวิ่ง + ทาบ 40d + งอ 12d
// เหล็กบน    : เสริมที่ปลายช่วงทั้ง 2 ข้าง ยาวตามที่แบบระบุ (top_len_m ต่อปลาย) + งอ 12d · แบบไม่ระบุ = REBAR.stairTopFrac × ความยาวลาด (¼)
// เหล็กขั้น  : งอตามรูปขั้น (ลูกตั้ง+ลูกนอน + งอ 2×12d) เรียงตามความกว้าง × (steps−1) ขั้น
// เหล็กจมูก  : เส้น/ขั้น × (กว้าง − 2c) × (steps−1) ขั้น · สเปกไม่มีจำนวนเส้น ("RB9mm" = ทุกมุม) → 1 เส้น/ขั้น
// เหล็กแจกจ่าย: ตั้งฉาก ยาว = กว้าง − 2c + งอ 2×12d · เรียงตามระยะวิ่ง
// ‼️ รองรับ 2 แบบเหมือนฐานราก: ระยะเรียง "DB12mm@0.15" (sbTies) · นับเส้น "8-DB12mm" (sbBars)
// ‼️ parse ไม่ได้แม้ทิศเดียว → null ทั้งก้อน ไม่คิดครึ่ง ๆ ให้เหล็กขาด
// ‼️ มีสเปกเหล็กบนแต่แบบไม่บอกความยาว → ข้ามเฉพาะเหล็กบน + ตีธง topSkipped (ไม่เดา L/4)
//    ไม่ทำให้ทั้งก้อนเป็น null เพราะเหล็กหลัก/แจกจ่ายที่อ่านได้แล้วยังใช้ได้
// เหล็กจมูกขั้น "RB9mm" (ไม่มีจำนวนเส้น = ทุกมุม) → "1-RB9mm" · มีจำนวน/ระยะเรียงอยู่แล้ว = ใช้ตามนั้น
const sbNoseSpec = (s) => { const t = String(s==null?'':s).trim(); return /^(Ø|DB|RB)\s*\d/i.test(t) && !/@/.test(t) ? '1-'+t : t; };
const sbStairRebarCalc = (r) => {
  const g = sbStairGeo(r);
  if(!(g.W>0) || !(g.slope>0)) return null;
  const c = REBAR.cover, runLen = g.slope + g.landing_L;
  const pend = []; let ok = 0; const bad = [];
  const dir = (spec, alongLen, lenOf, role, mult = 1) => {
    if(!sbHasSpec(spec)) return;            // ไม่ได้ระบุ = ข้าม ไม่ใช่ความล้มเหลว
    let n = 0, d = 0, tp = '';
    const t = sbTies(spec);
    if(t){ n = sbFloor(alongLen/t.sp) + 1; d = t.d; tp = t.t; }
    else { const b = sbBars(spec); if(!b){ bad.push(String(spec)); return; } n = b.n; d = b.d; tp = b.t; }
    const lenEach = lenOf(d);
    if(!(n>0) || !(lenEach>0) || !(mult>0)){ bad.push(String(spec)); return; }
    pend.push({ d, t:tp, len: n*lenEach*mult*g.n, role }); ok++;
  };
  // main/top = เหล็กหลักบันได (วิ่งตามลาด+ชานพักต่อเนื่อง) · dist = เหล็กกันร้าว (ตั้งฉาก)
  dir(r.rebar_main||r.rebar, g.W,   (d)=> runLen + (REBAR.lap + REBAR.hook)*d/1000, 'main');
  dir(r.rebar_dist,          runLen,(d)=> (g.W - 2*c) + REBAR.hookN*REBAR.hook*d/1000, 'dist');
  const topLen = (+r.top_len_m||0) || (+REBAR.stairTopFrac||0)*g.slope;   // แบบไม่ระบุ → ¼ ลาด
  const topSkipped = sbHasSpec(r.rebar_top) && !(topLen>0);
  if(sbHasSpec(r.rebar_top) && topLen>0)
    dir(r.rebar_top, g.W, (d)=> 2*(topLen + REBAR.hook*d/1000), 'main');   // 2 ปลาย (เหล็กบนบันได)
  const nStep = Math.max(g.ns-1, 0);
  dir(r.rebar_step, g.W, (d)=> g.ri + g.td + 2*REBAR.hook*d/1000, 'main', nStep);
  dir(sbNoseSpec(r.rebar_nose), g.W, ()=> g.W - 2*c, 'main', nStep);
  if(ok === 0 && !bad.length) return null;
  // แตกความยาวตามขนาดเหล็ก (byDia) และบทบาท (main=เสริมบันได · dist=กันร้าว) — สำหรับคอลัมน์ RB6/RB9 เฉลย
  let kg = 0, tot = 0; const byDia = {}, mainDia = {}, distDia = {}, bySize = {};
  pend.forEach(p => { tot += p.len; const gkg = p.len*(p.d*p.d/162); kg += gkg;
    byDia[p.d] = sbR2((byDia[p.d]||0) + p.len);
    const tgt = p.role==='dist' ? distDia : mainDia;
    tgt[p.d] = sbR2((tgt[p.d]||0) + p.len);
    sbAddSize(bySize, p.t, p.d, gkg); });
  return { kg:sbR2(kg), len:sbR2(tot), topSkipped, byDia, mainDia, distDia, bySize, bad };
};
// พื้นที่ฐานรากตามรูปทรง (ต้องตรงกับ footArea ใน excel-export.jsx)
const sbFootArea = (r) => {
  const B=+r.B||0, L=+r.L||0, B2=+r.B2||0;
  if(+r.area_m2 > 0) return +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;
};
// ── ของสิ้นเปลือง + ระยะเหล็ก ตามคอลัมน์เฉลย (mirror rate ใน excel-export) ──
// น.น.เหล็กรวม = rebar_kg + ties_kg · ลวดผูก 1% ของเหล็กรวม · ตะปู 0.3 kg/ม²ไม้แบบ · ลูกปูน 4 ตัว/ม²ไม้แบบ
// ระยะงอ = 12d · ระยะทาบ = 40d (จากขนาดเหล็กหลัก) — โชว์ระยะเผื่อที่ใช้คิดจริง
const sbFillExtras = (r, mainSpec) => {
  const rk=Number(r.rebar_kg)||0, tk=Number(r.ties_kg)||0, fm=Number(r.formwork_m2)||0;
  const tot=rk+tk;
  r.steel_total_kg=sbR2(tot);
  r.tie_wire_kg=sbR2(tot*0.01);
  r.nail_kg=sbR2(fm*0.3);
  r.spacer_n=sbCeil(fm*4);
  const b=sbBars(mainSpec) || sbTies(mainSpec);   // เหล็กหลัก (นับเส้น) หรือเหล็ก @ระยะ (พื้น) — เอาแค่ขนาด d
  if(b){ r.bend_m=sbR2(REBAR.hook*b.d/1000); r.lap_m=sbR2(REBAR.lap*b.d/1000); }
};
// จำนวนปลอกรวม = ceil(ความยาวต่อตัว / ระยะเรียง) × จำนวนตัว — ต้องปัดต่อตัวก่อนคูณ ให้ตรงกับ sbTiesCalc (นน.ปลอก)
const sbTiesCount = (ties, Lper, n) => { const t=sbTies(ties); return (t && Lper>0) ? sbCeil(Lper/t.sp)*(Number(n)||1) : ''; };

// ── ลิงก์ช่องเปิดผนัง ↔ ประตู-หน้าต่าง ─────────────────────────────
// index รหัสบาน → {w,h} (จากชีต doors/windows) · ผนังอ้าง ref = รหัสบาน → ดึงกว้าง×สูงจริงมาหักช่องเปิด
// ‼️ แก้ขนาดบานที่ตารางประตู-หน้าต่างที่เดียว → ผนังทุกใบที่อ้างถึงอัปเดตตาม (แม่น + ไม่ต้องกรอกซ้ำ 2 ที่)
let SB_OPENING_IDX = {};
// ── เหล็กยืนตอม่อ (เจ้าของเลือก 2026-10-19 · "เส้นแดง") ─────────────
// ตอม่อ (ชั้น/ช่วงมีคำว่า "ตอม่อ") = เหล็กยืนหยั่งลงถึงตะแกรงล่างฐาน (T ฐาน − หุ้มฐาน) + งอฉาก 12d ปลายล่าง
//   คอนกรีต/ไม้แบบ/ปลอก ยังคิดตามสูงตอม่อ (±0.00 → หลังฐาน) · เสาชั้นอื่น = สูงเสา (colMainAdd) เหมือนเดิม
//   T ฐาน = T มากสุดในชีตฐานราก (ตอม่อไม่ผูกรหัสฐาน · บ้านทั่วไปฐานหนาเท่ากัน) · ไม่มีฐาน = หยั่ง 0 (งออย่างเดียว)
//   ต้องตรงกับ generateBOQExcel (excel-export.jsx) + tools/eval/lib/template-spec.js (COLUMNS)
let SB_FOOT_T = 0;
const sbFootTref = (sheets) => Math.max(0, ...((sheets && Array.isArray(sheets.footings)) ? sheets.footings : []).map(r => +(r && r.T) || 0));
// พื้นที่จริง (ตามลาด) ต่อรหัสผืนหลังคา — ให้สมาชิกที่แบบเขียนเป็น @ (แป/จันทัน) คิด ความยาวรวม = พื้นที่ผืนที่คลุม ÷ @
//   คิดจากเรขาคณิตแถว roof ตรง ๆ (mirror SB_RECOMPUTE.roof) ไม่พึ่ง actual_area — ลำดับชีตใน sheets ไม่แน่นอน
let SB_ROOF_AREA = {};
const sbRoofAreaIdx = (sheets) => {
  const idx = {};
  ((sheets && Array.isArray(sheets.roof)) ? sheets.roof : []).forEach(r => {
    if(!r || typeof r !== 'object') return;
    const code = String(r.code||'').trim().toUpperCase(); if(!code) return;
    const n = +(r.count??r.qty)||1, a = +r.angle_deg||30;
    const f1 = sbRoofFlat(r), fa = f1!==null ? f1*n : (+r.flat_area||+r.volume||0);
    if(fa>0) idx[code] = (idx[code]||0) + fa/Math.cos(a*Math.PI/180);
  });
  return idx;
};
// ช่อง "คลุมผืน": "RF1-RF5" · "RF1,RF3" · "RF1–RF4, RF6" · "ทั้งหมด" → รหัสผืนที่มีอยู่จริงใน idx (ไม่ซ้ำ)
const sbRoofCovers = (s, idx) => {
  const t = String(s||'').trim().toUpperCase().replace(/[–—]/g,'-').replace(/\s*-\s*/g,'-');
  if(!t) return [];
  if(/^(ทั้งหมด|ทุกผืน|ALL|\*)$/.test(t)) return Object.keys(idx);
  const out = new Set();
  t.split(/[\s,;/]+/).forEach(tok => {
    const m = tok.match(/^([A-Z]+)(\d+)-(?:[A-Z]+)?(\d+)$/);
    if(m){ const a=+m[2], b=+m[3]; for(let i=Math.min(a,b); i<=Math.max(a,b); i++) out.add(m[1]+i); }
    else if(tok) out.add(tok);
  });
  return [...out].filter(c => idx[c] > 0);
};
const sbIsPier = (r) => /ตอม่อ/.test(String((r && r.floor) || ''));
const sbColMainLen = (r, h) => h + (sbIsPier(r) ? Math.max(0, SB_FOOT_T - (REBAR.footCover != null ? REBAR.footCover : 0.05)) : 0);
const sbColMainAdd = (r) => (+REBAR.colMainAdd || 0) + (sbIsPier(r) ? REBAR.hook : 0);
function sbBuildOpeningIdx(sheets){
  const idx = {};
  ['doors','windows'].forEach(k=>{
    const arr = sheets && Array.isArray(sheets[k]) ? sheets[k] : [];
    arr.forEach(r=>{
      const code = String((r&&r.code)||'').trim().toUpperCase();
      const w = +((r&&r.W))||0, h = +((r&&r.H))||0;
      if(code && w>0 && h>0 && !idx[code]) idx[code] = { w, h };
    });
  });
  return idx;
}

const SB_RECOMPUTE = {
  footings:(r)=>{ const B=+r.B||0,L=+r.L||0,T=+r.T||0,n=+(r.count??r.qty)||0,d=+r.depth||0,lt=+r.lean_t||0.05,st=+r.sand_t||0.05;
    const A=sbFootArea(r);
    r.concrete_m3=sbR2(A*T*n); r.formwork_m2=sbR2(2*(B+L)*T*n);
    const dg=2*REBAR.footDig, bd=2*REBAR.footBed;
    r.excavation_m3=sbR2((B+dg)*(L+dg)*d*n); r.lean_m3=sbR2((B+bd)*(L+bd)*lt*n); r.sand_m3=sbR2((B+bd)*(L+bd)*st*n);
    // เหล็กล่าง: คิดจากสเปกก่อน — parse ไม่ได้ปล่อย rebar_kg เดิม (ค่าจาก AI / ที่กรอกมือ) ไว้ ไม่ทับ
    // rebar_kg = ตะแกรงล่าง + บน (หน้าราคาใช้ช่องนี้ + rebar_by_size) · rebar_top_kg = ส่วนตะแกรงบน (โชว์แยก)
    const rk=sbFootRebarCalc(B,L,T,r.rebar_x||r.rebar,r.rebar_y,n,r.rebar_top,sbFootTopU(r.top_shape)); if(rk!==null){ r.rebar_kg=rk.kg; r.rebar_m=rk.len; r.rebar_by_size=rk.bySize; r.rebar_bad=rk.bad; r.rebar_top_kg=rk.topKg; }
    // ล็อกช่อง rebar_kg เมื่ออ่านสเปกได้ครบ (คำนวณจริง) · อ่านไม่ได้/ไม่มีสเปก → ปลดล็อกให้กรอกมือ
    r._rebar_locked = !!(rk && rk.len>0 && (!rk.bad || !rk.bad.length));
    // เหล็กปลอก/รัดฐานราก: "@" = ปลอกรอบหน้าตัด B×T เรียงตาม L · "n-RB9" = n วงรัดรอบแปลน (sbFootTiesCalc) · parse ไม่ได้ → ties_bad (needsQty)
    const ftk=sbFootTiesCalc(B, L, T, r.ties, n);
    if(ftk!==null){ r.ties_kg=ftk.kg; r.ties_m=ftk.len; r.ties_by_size=ftk.bySize; r.ties_bad=ftk.bad; }
    sbFillExtras(r, r.rebar_x||r.rebar); },   // ของสิ้นเปลือง (ลวดผูก/ตะปู/ลูกปูน) จาก rebar_kg+ties_kg+formwork
  columns:(r)=>{ const [B,D]=sbSection(r.section); const h=+r.height||0,n=+(r.count??r.qty)||0;
    const sets=Math.max(1, +r.ties_sets||1);   // เบิ้ลปลอก (ปลอกซ้อน 2 ชุด/ตัว) → คูณ นน./จำนวนเหล็กปลอก
    r.B=sbR2(B); r.D=sbR2(D);
    r.concrete_per=sbR2(B*D*h); r.concrete_m3=sbR2(B*D*h*n); r.formwork_m2=sbR2(2*(B+D)*h*n);
    const tk=sbTiesCalc(r.section,h,r.ties,n); if(tk!==null){ r.ties_kg=sbR2(tk.kg*sets); r.ties_m=sbR2(tk.len*sets); r.ties_by_size=sbScaleSize(tk.bySize,sets); r.ties_bad=tk.bad; }
    const tn=sbTiesCount(r.ties, h, n); r.ties_n = (tn==='' ? '' : tn*sets);
    const mk=sbMainCalc([r.rebar_main||r.rebar], sbColMainLen(r,h), n, sbColMainAdd(r)); if(mk!==null){ r.rebar_kg=mk.kg; r.rebar_m=mk.len; r.rebar_by_size=mk.bySize; r.rebar_bad=mk.bad; }
    sbFillExtras(r, r.rebar_main||r.rebar); },
  // เสาเหล็กรูปพรรณ: เติม น.น./เมตร จากตารางหน้าตัดเหล็ก (แก้ทับได้) · ความยาว/น้ำหนักรวม = โค้ดคิด
  // ‼️ ผู้ใช้กรอก unit_weight เองไว้ = ไม่ทับ · จับคู่ชื่อหน้าตัดไม่ได้ = ปล่อยว่าง ไม่เดา 0 (mirror roof_members)
  steel_columns:(r)=>{
    if(!(+r.unit_weight>0) && window.steelWeight){ const w=window.steelWeight(r.section); if(w!=null) r.unit_weight=w; }
    const uw=+r.unit_weight||0, h=+r.height||0, n=+(r.count??r.qty)||0;
    // สูง/ท่อน + จำนวน ครบ → คิดจากส่วนย่อย (แก้แล้วยอดอัปเดต) · ไม่ครบ → ใช้ยอดรวมที่ AI ให้มา
    const tot=(h>0 && n>0) ? h*n : (+r.total_length_m||0);
    if(tot>0) r.total_length_m=sbR2(tot);
    if(uw>0 && tot>0) r.weight_kg=sbR2(tot*uw); },
  // อุปกรณ์ประกอบเสาเหล็ก: น.น.เพลต = B×L×t (mm→m) × 7850 × จำนวน · bolt รวม = ตัว/แผ่น × จำนวน
  //   parse ขนาดเพลตไม่ครบ 3 มิติ = ไม่ทับค่าเดิม (mirror footings)
  steel_col_fittings:(r)=>{ const n=+(r.count??r.qty)||0;
    const d=String(r.plate_size||'').match(/\d+(?:\.\d+)?/g);
    if(d && d.length>=3 && n>0){ r.plate_kg=sbR2((+d[0]/1000)*(+d[1]/1000)*(+d[2]/1000)*7850*n); }
    const bp=+r.bolt_per||0; if(bp>0 && n>0) r.bolt_total=Math.round(bp*n); },
  beams:(r)=>{ const [B,D]=sbSection(r.section); const L=+r.length||0,n=+(r.count??r.qty)||0;
    const sets=Math.max(1, +r.ties_sets||1);   // เบิ้ลปลอก (ปลอกซ้อน 2 ชุด/ตัว) → คูณ นน./จำนวนเหล็กปลอก
    r.B=sbR2(B); r.D=sbR2(D);
    r.concrete_m3=sbR2(B*D*L*n); r.formwork_m2=sbR2((2*D+B)*L*n);
    const tk=sbTiesCalc(r.section,L,r.ties,n); if(tk!==null){ r.ties_kg=sbR2(tk.kg*sets); r.ties_m=sbR2(tk.len*sets); r.ties_by_size=sbScaleSize(tk.bySize,sets); r.ties_bad=tk.bad; }
    const tn=sbTiesCount(r.ties, L, n); r.ties_n = (tn==='' ? '' : tn*sets);
    const mk=sbBeamMainCalc(r, L, n); if(mk!==null){ r.rebar_kg=mk.kg; r.rebar_m=mk.len; r.rebar_by_size=mk.bySize; r.rebar_bad=mk.bad; }
    const sp=sbBeamSplit(r, L, n); if(sp!==null){ r.rebar_top_m=sp.top.len; r.rebar_top_kg=sp.top.kg; r.rebar_bot_m=sp.bot.len; r.rebar_bot_kg=sp.bot.kg; }
    sbFillExtras(r, r.rebar_top||r.rebar_bot||r.rebar); },
  // พื้นหล่อในที่: ไม้แบบ = ท้องพื้น (B×L) + ขอบ (2×(B+L)×T) · เหล็ก = ตะแกรง 2 ทิศ
  slabs_cip:(r)=>{ const B=+r.B||0,L=+r.L||0,T=+r.T||0,n=+(r.count??r.qty)||1;
    const ground = (r.slab_support==='บนดิน');
    const grossA = B*L*n, openA = Math.max(+r.openings_m2||0,0);
    const netA = Math.max(grossA - openA, 0);              // หักช่องเปิดจากพื้นที่พื้น
    r.concrete_m3 = sbR2(netA*T);
    // ไม้แบบ: ท้องพื้น (เฉพาะพื้นวางบนคาน — บนดินเทบนทราย ไม่มีท้องแบบ) + ขอบรอบ 4 ด้าน
    const soffit = ground ? 0 : netA;
    r.formwork_m2 = sbR2(soffit + 2*(B+L)*T*n);
    // พื้นวางบนดิน: ทรายรองพื้น (× หนาทราย default 0.05) + พลาสติกปูรอง (= พื้นที่สุทธิ)
    if(ground){ const st=+r.sand_t||0.05; r.sand_m3=sbR2(netA*st); r.poly_m2=sbR2(netA); }
    else { r.sand_m3=0; r.poly_m2=0; }
    // เหล็กล่าง (ตะแกรง 2 ทิศ) — เดิม · parse ไม่ได้ = คงค่า AI/กรอกมือใน rebar_kg
    const rk=sbSlabCalc(B,L,r.rebar_short,r.rebar_long,n); if(rk!==null){ r.rebar_kg=rk.kg; r.rebar_m=rk.len; r.rebar_by_size=rk.bySize; r.rebar_bad=rk.bad; }
    // เหล็กบน (เต็มผืน 2 ทิศ ใช้สเปกเดียว) — opt-in: ว่าง/"-" = 0 (พื้นวางอิสระไม่มีเหล็กบน)
    const topSpec = String(r.rebar_top==null?'':r.rebar_top).trim();
    const rt = (topSpec && topSpec!=='-') ? sbSlabCalc(B,L,r.rebar_top,r.rebar_top,n) : null;
    r.rebar_top_kg = rt ? rt.kg : 0;
    r.rebar_top_by_size = rt ? rt.bySize : {}; r.rebar_top_bad = rt ? rt.bad : [];
    // เหล็กบนหัวคาน (แถบริมคาน 2 ทิศ) — ว่าง = 0
    const rs = sbSlabSupCalc(B,L,r.top_sup_short,r.top_sup_short_m,r.top_sup_long,r.top_sup_long_m,n);
    r.rebar_sup_kg = rs ? rs.kg : 0; r.rebar_sup_m = rs ? rs.len : 0;
    r.rebar_sup_by_size = rs ? rs.bySize : {}; r.rebar_sup_bad = rs ? rs.bad : [];
    // ตะแกรงลวด: คิดจากสเปกถ้าอ่านได้ (sbMeshCalc) · อ่านไม่ได้ = คง kg ที่กรอกมือ/AI
    const wm=sbMeshCalc(B,L,r.wiremesh,n); if(wm) r.wiremesh_kg=wm.kg;
    // นน.เหล็กรวม = เหล็กล่าง + เหล็กบน + เหล็กบนหัวคาน + ตะแกรงลวด · ลวดผูก 1% ของรวม
    const botKg=+r.rebar_kg||0, topKg=+r.rebar_top_kg||0, supKg=+r.rebar_sup_kg||0, wmKg=Math.max(+r.wiremesh_kg||0,0);
    const totKg = botKg+topKg+supKg+wmKg;
    r.steel_total_kg = sbR2(totKg);
    r.tie_wire_kg = sbR2(totKg*0.01);
    const fm=+r.formwork_m2||0;
    r.nail_kg = sbR2(fm*0.3);
    r.spacer_n = sbCeil(fm*4);
    const bMain = sbBars(r.rebar_short||r.rebar_long||r.rebar_top) || sbTies(r.rebar_short||r.rebar_long||r.rebar_top);
    if(bMain){ r.bend_m=sbR2(REBAR.hook*bMain.d/1000); r.lap_m=sbR2(REBAR.lap*bMain.d/1000); } },
  // พื้นสำเร็จ: ไม้แบบ = ขอบ topping อย่างเดียว (แผ่นสำเร็จทำหน้าที่แบบหล่อ ไม่มีท้องแบบ — เจ้าของเลือก 2026-10-16)
  //   คอนกรีต topping = พื้นที่ × หนา topping · เหล็ก topping (ตะแกรง) คิดจากสเปกถ้าอ่านได้ ไม่งั้นใช้ kg กรอกมือ/AI
  slabs_precast:(r)=>{ const B=+r.B||0,L=+r.L||0,n=+(r.count??r.qty)||1;
    r.area_m2=sbR2(B*L*n);
    r.formwork_m2=sbR2(2*(B+L)*(+r.topping_t||0.05)*n);
    r.concrete_m3=sbR2((+r.area_m2||0)*(+r.topping_t||0.05));
    const wm=sbMeshCalc(B,L,r.topping_rebar||r.wiremesh,n); if(wm){ r.topping_rebar_kg=wm.kg; r.topping_rebar_m=wm.len; }
    const sk=Number(r.topping_rebar_kg)||0, fm=Number(r.formwork_m2)||0;
    r.steel_total_kg=sbR2(sk); r.tie_wire_kg=sbR2(sk*0.01); r.spacer_n=sbCeil(fm*4);
    const b=sbTies(r.topping_rebar); if(b) r.bend_m=sbR2(REBAR.hook*b.d/1000); },
  // บันได: คอนกรีต = ท้องบันได + ลูกขั้น (ปริซึมสามเหลี่ยม × steps−1) + ชานพัก (หนา landing_t)
  //        ไม้แบบ  = ท้องบันได + หน้าลูกตั้ง (steps หน้า) + ‼️ ข้างบันได 2 ข้าง (แม่บันได) + ท้องชานพัก
  //        ‼️ ไม่รวมขอบชานพัก — ด้านที่ติดผนัง/ต่อบันไดไม่ต้องตั้งแบบ และแบบไม่บอกว่าติดด้านไหน จึงไม่เดา
  stairs:(r)=>{ const g=sbStairGeo(r); const n=g.n;
    if(g.hasDims) r.landing_area=sbR2(g.la);      // มีมิติชานพักครบ → พื้นที่คิดจาก L×W (ไม่ใช้ค่าที่ AI ส่ง)
    r.rise_m=sbR2(g.rise); r.slope_m=sbR2(g.slope);   // สูงรวม/ความลาด — เทียบระดับบน−ล่างเพื่อจับ steps ที่อ่านพลาด
    // คอนกรีตแตกส่วน (mirror เทอมเดิม): แม่บันได=ท้องเอียง · ขั้น=ปริซึมสามเหลี่ยม (steps−1) · ชานพัก
    const cWaist=g.slope*g.W*g.wt, cSteps=0.5*g.ri*g.td*g.W*Math.max(g.ns-1,0), cLand=g.la*g.lt;
    r.concrete_waist=sbR2(cWaist*n); r.concrete_steps=sbR2(cSteps*n); r.concrete_landing=sbR2(cLand*n);
    r.concrete_stair=sbR2((cWaist+cSteps)*n);
    r.concrete_m3=sbR2((cWaist+cSteps+cLand)*n);
    // ไม้แบบแตกส่วน: ท้อง=ท้องเอียง+หน้าลูกตั้ง · ข้าง=แม่บันได 2 ข้าง · ชานพัก=ท้องชานพัก
    const fSoffit=g.slope*g.W + g.ri*g.W*g.ns, fSide=2*g.slope*g.wt, fLand=g.la;
    r.formwork_soffit=sbR2(fSoffit*n); r.formwork_side=sbR2(fSide*n); r.formwork_landing=sbR2(fLand*n);
    r.formwork_stair=sbR2((fSoffit+fSide)*n);
    r.formwork_m2=sbR2((fSoffit+fSide+fLand)*n);
    r.nail_stair_kg=sbR2((fSoffit+fSide)*n*0.3);      // ตะปูเฉพาะบันได (ไม่รวมชานพัก)
    // ราวกันตก: ยาว = ตามลาด × จำนวนข้าง (ไม่รวมขอบชานพัก — เจ้าของเลือก 2026-10-16) · ไม่ระบุจำนวนข้าง = ไม่คิด (ไม่เดา)
    r.handrail_m = g.sides>0 ? sbR2(g.slope*g.sides*n) : '';
    const rk=sbStairRebarCalc(r); if(rk!==null){ r.rebar_kg=rk.kg; r.rebar_m=rk.len; r.rebar_by_size=rk.bySize; r.rebar_bad=rk.bad;
      // แยกความยาวตามขนาดเหล็ก: RB6 (Ø6) · RB9 (Ø9) · DB (Ø≥10 = เหล็กข้ออ้อยหลัก)
      r.rebar_rb6=rk.byDia[6]||''; r.rebar_rb9=rk.byDia[9]||'';
      let db=0; for(const d in rk.byDia){ if(+d>=10) db+=rk.byDia[d]; } r.rebar_db=db>0?sbR2(db):''; }
    r._rebar_locked = !!(rk && rk.len>0 && (!rk.bad || !rk.bad.length));  // ล็อก rebar_kg เมื่ออ่านสเปกได้ (เหมือนฐานราก)
    sbFillExtras(r, r.rebar_main||r.rebar_dist); },   // นน.เหล็กรวม/ลวดผูก/ลูกปูน/ตะปูรวม จาก rebar_kg+formwork
  // บันไดไม้: โค้ดคิดความยาวสมาชิกจากเรขาคณิต → ปริมาตรไม้รวม (ม³ + ลบ.ฟ.)
  wood_stairs:(r)=>{ const g=sbWoodStairGeo(r);
    r.rise_m=sbR2(g.rise); r.slope_m=sbR2(g.slope);
    const wk=sbWoodStairCalc(r); if(wk!==null){ r.wood_m3=wk.m3; r.wood_cuft=wk.cuft; } },
  // บันไดเหล็ก: เรขาคณิตเหมือน คสล./ไม้ · น้ำหนัก+แผ่นคิดจากหน้าตัด → parse ไม่ได้ = ไม่ทับค่าเดิม (ค่า AI/กรอกมือ)
  steel_stairs:(r)=>{ const g=sbSteelStairGeo(r);
    r.rise_m=sbR2(g.rise); r.slope_m=sbR2(g.slope);
    const sk=sbSteelStairCalc(r); if(sk!==null){ r.steel_kg=sk.kg; r.plate_m2=sk.m2; } },
  // ผนัง: โค้ดคิดพื้นที่จากมิติ (VE ได้ · ตรวจย้อนได้) — AI ส่งแค่ ยาว/สูง/รูปทรง/ช่องเปิด
  //   gross = สี่เหลี่ยม L×H · สามเหลี่ยม(จั่ว) ½L×H · คางหมู ½(H+H2)×L  · ×จำนวนแนว
  //   ‼️ idempotent: openings จาก array = พื้นที่/แนว ×n · จาก openings_m2(กรอกมือ) = ยอดรวมแถวอยู่แล้ว ไม่คูณ n ซ้ำ
  //   ‼️ ไม่มี length/height (ผนังโค้ง/รูปแปลก) = ไม่ทับ field เดิม (คงค่า AI/กรอกมือ) — mirror floor_finishes
  walls:(r)=>{
    const L=+r.length||0, H=+r.height||0, H2=+r.height2||0, n=+(r.count??r.qty)||1;
    const shp=String(r.shape||'rect').toLowerCase();
    let per=0;
    if(L>0 && H>0){
      if(shp==='triangle')                per=0.5*L*H;
      else if(shp==='trapezoid' && H2>0)  per=0.5*(H+H2)*L;
      else                                per=L*H;   // rect
    }
    if(per<=0) return;                                // ไม่มีมิติ = ไม่ทับ
    const gross=per*n;
    const arr=Array.isArray(r.openings)?r.openings:null;
    // ช่องเปิด/แนว: มี ref (รหัสบาน) → ดึงกว้าง×สูงจากตารางประตู-หน้าต่าง (SB_OPENING_IDX) · o.w/o.h ที่กรอกเองมาก่อน (override)
    const opPer = arr ? arr.reduce((s,o)=>{
      const ref=String((o&&o.ref)||'').trim().toUpperCase();
      const hit=ref?SB_OPENING_IDX[ref]:null;
      const w=(+((o&&o.w))>0)?+o.w:(hit?hit.w:0);
      const h=(+((o&&o.h))>0)?+o.h:(hit?hit.h:0);
      return s + w*h*(+((o&&o.n))||1);
    },0) : 0;
    const openings=arr ? opPer*n            // /แนว × จำนวนแนว
                       : (+r.openings_m2||0);   // ไม่มี array = ใช้ยอดที่กรอก/AI ประเมิน
    const net=Math.max(0, gross-openings);            // กัน openings > gross เงียบ ๆ
    const sides=+r.plaster_sides||2;
    r.gross_m2=sbR2(gross); r.openings_m2=sbR2(openings);
    r.net_m2=sbR2(net); r.plaster_m2=sbR2(net*sides); // = ทาสีด้วย (excel col เดียวกัน)
  },
  // ผืนหลังคา: พื้นที่ฉายราบ = กว้าง×ยาว×จำนวนผืน (โค้ดคิด) · พื้นที่จริงตามลาด = ฉายราบ ÷ cos(มุมลาด)
  //   ‼️ ไม่มี กว้าง/ยาว (ผืนรูปแปลก) = ไม่ทับ flat_area (คงค่าที่ AI/กรอกมือ = ยอดรวมแล้ว) — mirror walls
  roof:(r)=>{ const a=+r.angle_deg||30, n=+(r.count??r.qty)||1;
    const f1=sbRoofFlat(r); if(f1!==null) r.flat_area=sbR2(f1*n);   // สี่เหลี่ยม/สามเหลี่ยม/คางหมู
    const fa=+r.flat_area||+r.volume||0;
    if(fa>0) r.actual_area=sbR2(fa/Math.cos(a*Math.PI/180)); },
  // โครงหลังคาราย member (จันทัน/แป/อกไก่/อะเส/ขื่อ): เติม น.น./เมตร จากตารางหน้าตัดเหล็ก (window.steelWeight)
  // ‼️ ผู้ใช้กรอก unit_weight เองไว้ = ไม่ทับ · จับคู่ชื่อหน้าตัดไม่ได้ = ปล่อยว่าง ไม่เดา 0 (เปลี่ยนหน้าตัด → editCell relink)
  //    น้ำหนักรวม = ความยาวรวม × น.น./เมตร (โค้ดคิด — mirror excel-export roof_members)
  roof_members:(r)=>{
    if(!(+r.unit_weight>0) && window.steelWeight){ const w=window.steelWeight(r.section); if(w!=null) r.unit_weight=w; }
    const uw=+r.unit_weight||0, le=+r.length_each_m||0;
    const sp=+r.spacing_m||0, span=+r.span_m||0;
    // ‼️ แบบให้ระยะเรียง @ + ระบุผืนที่คลุม (แป/จันทัน) → ความยาวรวม = พื้นที่จริงของผืนที่คลุม ÷ @
    //    ใช้ได้ทุกรูปทรงผืน (ปั้นหยา: แนวยาวไม่เท่ากัน) — เดิมให้ AI แปลงเป็น จำนวน×ยาว เอง แล้วกะเลขกลม "ประมาณ"
    //    (บ้านดุง-8: จันทัน 40×5 −17% · แป 100×8 +15%) · ล้าง count/ยาว/ท่อน กันค่าค้างไม่ตรงยอด
    //    ‼️ คลุมผืนไม่ตรงรหัสผืนจริง = ยอด 0 (แถวขึ้นเตือน "ไม่มีปริมาณ" ให้แก้ช่องคลุมผืน) — ไม่ถอยไปใช้ count เดิมเงียบ ๆ
    //       mirror tools/eval/lib/template-spec.js (ROOF_MEMBERS)
    const cov=String(r.covers||'').trim();
    if(sp>0 && cov){
      const codes=sbRoofCovers(cov, SB_ROOF_AREA), area=codes.reduce((s,c)=>s+SB_ROOF_AREA[c],0);
      const tot=area/sp;
      r.covers_area_m2=sbR2(area); r.count=''; r.length_each_m='';
      r.total_length_m=sbR2(tot); r.total_weight_kg=sbR2(tot*uw);
      return;
    }
    r.covers_area_m2='';
    // แบบให้ระยะเรียง @ แทนจำนวนท่อน → จำนวนแนว = floor(ช่วงกระจาย/ระยะ)+1 (mirror เหล็กพื้น/ปลอก)
    // ‼️ ใช้เฉพาะเมื่อยังไม่มี count — เดิมทับ count เสมอ แต่ span_m คือช่วงของ "ระนาบเดียว" (ความยาวลาด)
    //    หลังคาปั้นหยา/จั่วมีหลายระนาบ → แปบ้านดุงจาก AI 36 แนว × 14 ม. = 504 ถูกทับเหลือ 18 แนว (252 ม.)
    let n=+(r.count??r.qty)||0;
    if(!(n>0) && sp>0 && span>0){ n=sbFloor(span/sp)+1; r.count=n; }
    // ยาว/ท่อน + จำนวน ครบ → คิดจากส่วนย่อย (แก้แล้วยอดอัปเดต) · ไม่ครบ → ใช้ยอดรวมที่ AI ให้มา
    const tot = (le>0 && n>0) ? le*n : (+r.total_length_m||0);
    if(tot>0) r.total_length_m=sbR2(tot);
    if(uw>0 && tot>0) r.total_weight_kg=sbR2(tot*uw); },
  // กันซึม: รวม = พื้นที่พื้น + ขอบกันซึมผนัง
  waterproofing:(r)=>{ r.total_m2 = sbR2((+r.area_m2||+r.volume||0) + (+r.upturn_m2||0)); },
  // วัสดุมุงหลังคา: พื้นที่จริง = ฉายราบ ÷ cos(มุมลาด) (mirror roof) · แผ่นรอง/ฉนวน = พื้นที่จริง (เฉพาะเมื่อระบุวัสดุ)
  roof_covering:(r)=>{ const fa=+r.flat_area||+r.volume||0, a=+r.angle_deg||30;
    r.actual_area=sbR2(fa/Math.cos(a*Math.PI/180));
    const u=String(r.underlay||'').trim();
    r.underlay_m2 = (u && u!=='-') ? r.actual_area : 0; },
  // ฝ้าเพดาน: พื้นที่ฝ้า = พื้นที่ห้อง (B×L) — mirror พื้นสถาปัตย์ · ไม่มีมิติ = ไม่ทับค่าเดิม (เก็บค่า AI ไว้)
  ceilings:(r)=>{ const B=+r.B||0, L=+r.L||0; if(B>0 && L>0) r.area_m2=sbR2(B*L); },
  // พื้นสถาปัตย์: พื้นที่ = B×L · บัวเชิงผนัง = เส้นรอบรูป(2(B+L)) − หักช่องประตู · ห้องรูปไม่ปกติ (ไม่มี B/L) = เก็บค่า AI ไว้ ไม่ทับ
  // ‼️ door_open_m ไม่มี (ข้อมูลเก่า/AI ไม่ส่ง) → ถอดกลับจากบัวเดิมครั้งแรก = per − skirting_ai เพื่อคงค่าหักประตูไว้
  //    แล้วรอบถัดไปใช้ door_open_m ที่ตั้งไว้ → บัวตอบสนองเมื่อแก้ B/L (คงจำนวนหักประตูเดิม)
  floor_finishes:(r)=>{ const B=+r.B||0, L=+r.L||0;
    if(B>0 && L>0){ r.area_m2=sbR2(B*L);
      const per=2*(B+L);
      if(r.door_open_m==null || r.door_open_m===''){ const sk=+r.skirting_m||0;
        r.door_open_m = (sk>0 && sk<=per) ? sbR2(per-sk) : 0; }
      r.skirting_m = sbR2(Math.max(0, per - (+r.door_open_m||0))); } },
  // งานไฟฟ้า — แถวท่อ (conduit): ท่อ = route_m ไม่มีสาย · แถวสาย (branch = เส้นรอบรูป / feeder): สาย = route_m × จำนวนเส้น (แก้ #3 ท่อ≠สาย)
  //   ยังไม่กรอกเส้น (แบบไม่ระบุสเปก) → สาย = ความยาวไปก่อน · qty_m = คอลัมน์ "ปริมาณรวม" (สาย → wire_m · ท่อ → conduit_m)
  //   ท่อในแถวสายคิดเฉพาะผลเก่าที่ยังใส่สเปกท่อไว้ในแถวเดียวกัน (ผลใหม่ท่อแยกแถว → กันนับซ้ำ) · แถว point (ผลเก่า) ไม่คิดความยาว
  wiring:(r)=>{ const t=r.row_type||'', rt=+r.route_m||0, nc=+r.n_cond||0;
    if(t==='conduit'){ r.conduit_m=sbR2(rt); r.wire_m=0; r.qty_m=r.conduit_m; }
    else if(t==='feeder'||t==='branch'||(t!=='point'&&rt>0)){
      r.conduit_m=(r.conduit||r.conduit_ref) ? sbR2(rt) : 0; r.wire_m=sbR2(nc>0 ? rt*nc : rt); r.qty_m=r.wire_m; } },
};

// ── boqData ที่ "ผ่านสูตรแล้ว" สำหรับหน้าราคา/ไฟล์ Excel (2026-11-09) ──
//   boqData ได้ช่องที่สูตรเติม (concrete_m3 / rebar_kg / formwork_m2 …) เมื่อกด "ยืนยันปริมาณ" ที่หน้านี้เท่านั้น
//   ถอดเสร็จแล้วกดแถบขั้นตอนข้ามไปหน้าราคา/ดาวน์โหลด = ผลถอดดิบ → แถวหาย/ปริมาณ 0 (วัดจริง: บ้านดุง 72 แทน 92 แถวราคา)
//   → คำนวณซ้ำบน "สำเนา" ก่อนใช้ (สูตรเดียวกับตอนเปิดหน้านี้ · รันซ้ำได้ผลเดิม · ไม่แตะ boqData ต้นฉบับ)
function sbRecomputeBoq(boqData){
  if(!boqData || !boqData.sheets || typeof boqData.sheets!=='object') return boqData;
  try{
    const sheets = JSON.parse(JSON.stringify(boqData.sheets));
    SB_OPENING_IDX = sbBuildOpeningIdx(sheets); SB_FOOT_T = sbFootTref(sheets); SB_ROOF_AREA = sbRoofAreaIdx(sheets);
    Object.keys(sheets).forEach(sk => { if(!SB_RECOMPUTE[sk] || !Array.isArray(sheets[sk])) return;
      sheets[sk].forEach(row => { if(row && typeof row==='object') SB_RECOMPUTE[sk](row); }); });
    return { ...boqData, sheets };
  }catch(e){ console.warn('recompute failed:', e); return boqData; }
}
window.sbRecomputeBoq = sbRecomputeBoq;

// ── ตรวจ "ไม่มีปริมาณ" รายแถว — แถวที่ปริมาณเป็น 0/ว่าง = ห้ามยืนยัน จนกว่าจะกรอกหรือลบแถว ──
// q   = ปริมาณหลักที่ไปถึงราคา (หลัง SB_RECOMPUTE) · fix = ช่องที่ "ผู้ใช้กรอกแก้ได้" ที่ทำให้ q เป็น 0
// ‼️ งานโครงสร้าง/สถาปัตย์ q เป็นค่า ƒ (คอนกรีต/พื้นที่) แก้มือไม่ได้ → เรืองแสงที่มิติต้นทาง (B/L/T, ยาว/สูง) แทน
// ‼️ ช่อง "จำนวน" ว่าง/0: สูตรเดิมถือเป็น 1 เงียบ ๆ (count||1) แต่หน้าจอโชว์ 0 → ให้ผู้ใช้ยืนยันเอง (ตรวจทุกชีตที่มีช่องนี้)
const sbN = (v) => { const n = Number(v); return isNaN(n) ? 0 : n; };
const sbV = (r, k, alt) => { const v = r[k]; return (v===undefined||v===null||v==='') && alt ? r[alt] : v; };
const sbRoofByArea = (r) => String(r.covers||'').trim()!=='';
// โหมดคิดจากพื้นที่ (มี @ + คลุมผืน) — เงื่อนไขเดียวกับ SB_RECOMPUTE.roof_members · ใช้ล็อกช่องที่ไม่ใช้ (naIf)
const sbRoofAreaMode = (r) => sbN(r.spacing_m)>0 && sbRoofByArea(r);
const SB_QTY_RULE = {
  footings:      { q:r=>sbN(r.concrete_m3),                 fix:['B','L','T'] },
  columns:       { q:r=>sbN(r.concrete_m3),                 fix:['section','height'] },
  steel_columns: { q:r=>sbN(r.weight_kg),                   fix:['unit_weight','height'] },
  beams:         { q:r=>sbN(sbV(r,'concrete_m3','volume')), fix:['section','length'] },
  roof:          { q:r=>sbN(r.actual_area),                 fix:['width','length'] },
  // เรียง @ / คลุมผืน = คิดจากพื้นที่ผืน (ไม่ใช้ยาว/ท่อน) · แถวอื่นคิดจาก ยาว × จำนวน (ไม่ใช้คลุมผืน)
  roof_members:  { q:r=>sbN(r.total_weight_kg),
                   fix:r=>{
                     if(sbRoofAreaMode(r)) return sbN(r.unit_weight)>0 ? ['covers'] : ['unit_weight'];   // ครบแล้วยังได้ 0 = รหัสผืนไม่ตรง
                     return (sbN(r.spacing_m)>0 || sbRoofByArea(r)) ? ['unit_weight','spacing_m','covers'] : ['unit_weight','length_each_m'];
                   } },
  slabs_cip:     { q:r=>sbN(sbV(r,'concrete_m3','volume')), fix:['B','L','T'] },
  slabs_precast: { q:r=>sbN(sbV(r,'area_m2','volume')),     fix:['B','L'] },
  stairs:        { q:r=>sbN(sbV(r,'concrete_m3','volume')), fix:['width','steps','riser','tread'] },
  wood_stairs:   { q:r=>sbN(sbV(r,'wood_m3','volume')),     fix:['width','steps'] },
  steel_stairs:  { q:r=>sbN(sbV(r,'steel_kg','weight_kg')), fix:['width','steps'] },
  walls:         { q:r=>sbN(r.net_m2),                      fix:['length','height'] },
  floor_finishes:{ q:r=>sbN(sbV(r,'area_m2','volume')),     fix:['B','L'] },
  ceilings:      { q:r=>sbN(sbV(r,'area_m2','volume')),     fix:['B','L'] },
  waterproofing: { q:r=>sbN(r.total_m2),                    fix:['area_m2'] },
  roof_covering: { q:r=>sbN(r.actual_area),                 fix:['flat_area'] },
  water_pipes:   { q:r=>sbN(sbV(r,'length_m','volume')),    fix:['length_m'] },
  drain_pipes:   { q:r=>sbN(sbV(r,'length_m','volume')),    fix:['length_m'] },
  // สายไฟ: สายป้อน (feeder) + วงจรย่อย (branch) วัดเป็นระยะ · แถวจุด (point, ผลเก่า) นับจำนวนจุด
  wiring:        { q:r=>(r.row_type==='point') ? sbN(r.points) : sbN(r.route_m),
                   fix:r=>(r.row_type==='point') ? ['points'] : ['route_m'] },
};
// คืน Set ของคีย์ช่องที่ต้องเรืองแสง (ว่าง = แถวนี้มีปริมาณครบ)
function sbQtyIssueKeys(sk, row){
  const out = new Set();
  if(!row || typeof row !== 'object') return out;
  const def = SB_SHEET_COLS[sk];
  const hasCount = !!(def && def.cols.some(c=>c.k==='count'));
  // ชีตนับชิ้นล้วน (สุขภัณฑ์/ดวงโคม/ประตู/บ่อ/ปั๊ม/ตู้ไฟ ฯลฯ) — ปริมาณ = จำนวน
  // ‼️ สมาชิกหลังคาที่เรียง @ + คลุมผืน: SB_RECOMPUTE ล้าง count เสมอ (คิดจากพื้นที่ ÷ @) → ห้ามเตือนให้กรอกช่องที่ถูกล้าง
  const areaBased = sk==='roof_members' && sbN(row.spacing_m)>0 && sbRoofByArea(row);
  if(hasCount && !areaBased && !(sbN(sbV(row,'count','qty')) > 0)) out.add('count');
  // ผืนหลังคาไม่มีมุมลาด: สูตรใช้ 30° แทนเงียบ ๆ (พื้นที่/แป/จันทันเพี้ยนตาม) → ให้ผู้ใช้กรอกมุมจากแบบเอง
  //   prompt สั่ง AI เว้นว่าง + "ไม่มั่นใจ: อ่านมุมไม่ได้" แทนการเดา 30° (เจ้าของเลือก 2026-10-25)
  if(sk==='roof' && !(sbN(row.angle_deg) > 0)) out.add('angle_deg');
  const rule = SB_QTY_RULE[sk];
  if(rule && !(rule.q(row) > 0)){
    const fix = typeof rule.fix === 'function' ? rule.fix(row) : rule.fix;
    // ช่องว่าง / "-" (AI ใช้แทน "อ่านไม่ได้") / ตัวเลข 0 — ข้อความอย่าง "0.20x0.40" ไม่นับว่าว่าง
    const blank = fix.filter(k => { const v = row[k]; const s = String(v ?? '').trim();
      return s==='' || /^[-–—]$/.test(s) || (!isNaN(Number(s)) && Number(s)===0); });
    (blank.length ? blank : fix).forEach(k=>out.add(k));
  }
  return out;
}
// สรุปทั้งโปรเจกต์: byRow['sk-idx'] = Set คีย์ · byCat[หมวด] = จำนวนแถว · total
function sbQtyIssues(sheets){
  const byRow = {}, byCat = {}; let total = 0;
  if(!sheets) return { byRow, byCat, total };
  for(const [cat, keys] of Object.entries(SB_CAT_SHEETS)){
    for(const sk of keys){
      (Array.isArray(sheets[sk]) ? sheets[sk] : []).forEach((r, idx)=>{
        const ks = sbQtyIssueKeys(sk, r);
        if(!ks.size) return;
        byRow[sk+'-'+idx] = ks; byCat[cat] = (byCat[cat]||0) + 1; total++;
      });
    }
  }
  return { byRow, byCat, total };
}

function sbCell(row, col){
  if(col.derive){
    const dv = col.derive(row);
    if(col.int){ const n=Number(dv); return isNaN(n)?'-':String(Math.round(n)); }
    const n=Number(dv); return isNaN(n)?'-':fmt(n,2);
  }
  let v = row[col.k];
  if((v===undefined||v===null||v==='') && col.alt) v = row[col.alt];
  if(v===undefined||v===null||v==='') return col.num||col.int ? '0' : '-';
  if(col.int){ const n=Number(v); return isNaN(n)?String(v):String(Math.round(n)); }
  if(col.num){ const n=Number(v); return isNaN(n)?String(v):fmt(n,2); }
  return String(v);
}
// ค่าดิบสำหรับช่องแก้ไข (ไม่ฟอร์แมต ให้พิมพ์ได้ง่าย)
function sbRaw(row, col){
  let v = row[col.k];
  if((v===undefined||v===null||v==='') && col.alt) v = row[col.alt];
  return (v===undefined||v===null) ? '' : v;
}

// สร้างกลุ่มตามหมวด อ่านจาก sheets (editable) + fallback items สำหรับหมวดที่ไม่มี sheet
// แต่ละ row แนบ _sk (sheet key) + _idx (ตำแหน่งใน array จริง) เพื่อใช้แก้ไข
function sbBuildGroups(sheets, items, search, selectedCats){
  sheets = sheets || {};
  items = Array.isArray(items) ? items : [];
  const q = (search||'').toLowerCase();
  // หมวดที่ผู้ใช้เลือกไว้ตอนกำหนดขอบเขต — ถ้า AI ถอดไม่เจอเลย ยังต้องโชว์หมวด (เปล่า+ตีธง) ห้ามซ่อนเงียบ
  //   โปรเจกต์เก่าก่อนฟีเจอร์นี้ = ไม่มี selectedCats → set ว่าง → คงพฤติกรรมเดิม (โชว์เฉพาะหมวดที่มีข้อมูล)
  const selSet = new Set(Array.isArray(selectedCats) ? selectedCats : []);
  const matchRow = (r) => !q ||
    String(r.code||'').toLowerCase().includes(q) ||
    String(r.location||r.name||'').toLowerCase().includes(q);
  const out = [];
  for(const cat of Object.keys(CAT_COLOR)){
    const keys = SB_CAT_SHEETS[cat];
    const isSel = selSet.has(cat);   // เคส B: หมวดถูกเลือกไว้ → โชว์แม้ AI ไม่เจอเลย
    const blocks = [];
    if(keys){
      for(const sk of keys){
        const def = SB_SHEET_COLS[sk];
        const all = Array.isArray(sheets[sk]) ? sheets[sk] : [];
        const rows = all.map((r,idx)=>({ ...r, _sk:sk, _idx:idx })).filter(matchRow);
        // ‼️ โชว์ตารางเปล่า (ให้กรอกเอง) เมื่อ: หมวดหลายชนิด (เช่น เสา = คสล./เหล็ก/อุปกรณ์ โชว์ทุกชนิดเสมอ)
        //    หรือ หมวดถูกเลือกไว้แต่ AI ถอดไม่เจอเลย (เคส B) → ผู้ใช้เห็น + กรอกชนิดที่ AI ไม่เจอได้เอง
        //    · ระหว่างค้นหา (q) ไม่โชว์บล็อกว่าง กันรก
        const showEmpty = all.length===0 && !q && (keys.length>1 || isSel);
        if(rows.length || showEmpty) blocks.push({ key:sk, label: keys.length>1 ? def.label : null, cols:def.viewCols, rows, editable:true });
      }
    } else {
      // หมวดไม่มี sheet เฉพาะ → ดึงจาก items (อ่านอย่างเดียว)
      const rows = items
        .filter(it => String(it.category||'').includes(cat))
        .map((it,i)=>({ code:it.code||('R'+(i+1)), name:it.name||it.notes, qty:it.qty, unit:it.unit, notes:it.notes }))
        .filter(matchRow);
      if(rows.length) blocks.push({ key:'generic_'+cat, label:null, cols:SB_GENERIC_COLS, rows, editable:false });
    }
    const count = blocks.reduce((a,b)=>a+b.rows.length,0);
    // เคส B: หมวดถูกเลือกแต่ AI ถอดไม่เจอเลย → ยังโชว์ (มีตารางเปล่าให้กรอก) + ตีธง missing · ไม่ทำระหว่างค้นหา
    const missing = count===0 && isSel && !!keys && !q && blocks.length>0;
    if(count || missing){
      const units = blocks.reduce((a,b)=>a + b.rows.reduce((s,r)=>s + (Number(r.count||r.qty)||0),0), 0);
      const vol = blocks.reduce((a,b)=>a + b.rows.reduce((s,r)=>s + (Number(r.concrete_m3||r.volume||r.area_m2)||0),0), 0);
      out.push({ cat, color:CAT_COLOR[cat], blocks, count, units, vol, missing });
    }
  }
  return out;
}

// ── โหมดสรุป: ยอดหลักต่อหมวด (อ่านค่าที่ SB_RECOMPUTE คิดไว้ในแถวแล้ว — ไม่มีสูตรใหม่) ──
const sbSumOf = (rows, f) => (rows||[]).reduce((s,r)=>s+(Number(typeof f==='function' ? f(r) : r[f])||0), 0);
const sbSteelKg = (r) => Number(r.steel_total_kg) || ((Number(r.rebar_kg)||0) + (Number(r.ties_kg)||0));
const SB_RC_SHEETS = ['footings','columns','beams','slabs_cip','slabs_precast','stairs'];
const SB_COUNT_UNIT = { 'สุขภัณฑ์':'ชุด', 'บ่อ-ถังบำบัด':'ชุด', 'ปั๊ม-ถังน้ำดี':'ชุด', 'ดวงโคม':'จุด', 'เต้ารับ-สวิตช์':'จุด', 'ตู้-แผงจ่ายไฟ':'รายการ' };
// คืน [{label, v, unit, dec}] — ค่า 0 ไม่โชว์ (แถวที่ยังไม่มีปริมาณมีป้าย "ไม่มีปริมาณ" บอกอยู่แล้ว)
function sbCatSummary(g){
  const rows = (sk) => { const b = g.blocks.find(x=>x.key===sk); return b ? b.rows : []; };
  const out = [];
  const add = (label, v, unit, dec=0) => { if(v>0) out.push({ label, v, unit, dec }); };
  const rc = (sks, countUnit) => {
    const rs = sks.flatMap(rows);
    if(countUnit) add('', sbSumOf(rs,'count'), countUnit);
    add('คอนกรีต', sbSumOf(rs,'concrete_m3'), 'ม³', 2);
    add('เหล็ก', sbSumOf(rs,sbSteelKg), 'กก.');
  };
  switch(g.cat){
    case 'ฐานราก': rc(['footings'],'ฐาน'); break;
    case 'เสา': rc(['columns'],'ต้น'); add('เหล็กรูปพรรณ', sbSumOf(rows('steel_columns'),'weight_kg'), 'กก.'); break;
    case 'คาน': rc(['beams'],'ช่วง'); break;
    case 'พื้นโครงสร้าง':
      add('สำเร็จรูป', sbSumOf(rows('slabs_precast'),'area_m2'), 'ม²', 1);
      add('หล่อในที่', sbSumOf(rows('slabs_cip'),'concrete_m3'), 'ม³', 2);
      add('เหล็ก', sbSumOf([...rows('slabs_cip'),...rows('slabs_precast')],sbSteelKg), 'กก.'); break;
    case 'บันได': rc(['stairs'],'ช่วง'); add('ไม้', sbSumOf(rows('wood_stairs'),'wood_m3'), 'ม³', 2); add('เหล็กรูปพรรณ', sbSumOf(rows('steel_stairs'),'steel_kg'), 'กก.'); break;
    case 'หลังคา': add('พื้นที่จริง', sbSumOf(rows('roof'),'actual_area'), 'ม²', 1); add('เหล็กรูปพรรณ', sbSumOf(rows('roof_members'),'total_weight_kg'), 'กก.'); break;
    case 'ผนัง': add('สุทธิ', sbSumOf(rows('walls'),'net_m2'), 'ม²', 1); add('ฉาบ', sbSumOf(rows('walls'),'plaster_m2'), 'ม²', 1); break;
    case 'ประตู-หน้าต่าง': add('ประตู', sbSumOf(rows('doors'),'count'), 'ชุด'); add('หน้าต่าง', sbSumOf(rows('windows'),'count'), 'ชุด'); break;
    case 'พื้นสถาปัตย์': add('', sbSumOf(rows('floor_finishes'),'area_m2'), 'ม²', 1); break;
    case 'ฝ้าเพดาน': add('', sbSumOf(rows('ceilings'),'area_m2'), 'ม²', 1); break;
    case 'กันซึม': add('', sbSumOf(rows('waterproofing'),r=>Number(r.total_m2)||r.area_m2), 'ม²', 1); break;
    case 'วัสดุมุงหลังคา': add('ตามลาด', sbSumOf(rows('roof_covering'),'actual_area'), 'ม²', 1); break;
    case 'ท่อน้ำดี': add('ยาว', sbSumOf(rows('water_pipes'),'length_m'), 'ม.', 1); break;
    case 'ท่อน้ำทิ้ง-โสโครก': add('ยาว', sbSumOf(rows('drain_pipes'),'length_m'), 'ม.', 1); break;
    case 'สายไฟ-ท่อร้อยสาย': add('รวม', sbSumOf(rows('wiring'),'qty_m'), 'ม.'); break;
    default: if(SB_COUNT_UNIT[g.cat]) add('', sbSumOf(g.blocks.flatMap(b=>b.rows),r=>r.count??r.qty), SB_COUNT_UNIT[g.cat]);
  }
  return out;
}
// การ์ดยอดรวมบนสุดของโหมดสรุป — คิดจาก sheet เต็ม (ไม่ขึ้นกับการค้นหา/ตัวกรองหมวด)
function sbTopTotals(sheets){
  const s = sheets || {}, rs = (k) => Array.isArray(s[k]) ? s[k] : [];
  const rc = SB_RC_SHEETS.flatMap(rs);
  return [
    { label:'คอนกรีตรวม', v:sbSumOf(rc,'concrete_m3'), unit:'ม³', dec:1 },
    { label:'เหล็กเสริมรวม', v:sbSumOf(rc,sbSteelKg), unit:'กก.', dec:0 },
    { label:'ผนังสุทธิ', v:sbSumOf(rs('walls'),'net_m2'), unit:'ม²', dec:1 },
    { label:'หลังคา (พื้นที่จริง)', v:sbSumOf(rs('roof'),'actual_area'), unit:'ม²', dec:1 },
  ].filter(c=>c.v>0);
}

// แปลงผลลัพธ์ BOQ จาก Claude (boqData.items) → rows ของตาราง
function mapBoqToRows(boqData){
  if(!boqData || !Array.isArray(boqData.items) || boqData.items.length===0) return null;
  // หมวดที่ระบบรู้จัก (ตรงกับ CAT_COLOR)
  const KNOWN = Object.keys(CAT_COLOR);
  const normCat = (c) => {
    if(!c) return 'ฐานราก';
    const s = String(c);
    const hit = KNOWN.find(k => s.includes(k));
    return hit || KNOWN[0];
  };
  return boqData.items.map((it,i)=>({
    id: 'ai'+i,
    cat: normCat(it.category),
    code: it.code || ('R-'+(i+1)),
    name: it.name || it.notes || 'รายการงาน',
    qty: Number(it.qty)||0,
    unit: it.unit || 'หน่วย',
    vol: Number(it.volume)||0,
    page: Number(it.page_num)||1,
    bbox: null,            // Claude ไม่ได้ส่งพิกัด → ไม่มีกรอบบนแบบ
    notes: it.notes || '',
  }));
}

// จัดกลุ่มคอลัมน์ (viewCols) เป็นแท็บ: ขนาด&จำนวน / (รายละเอียด) / เหล็กเสริม / ผลคำนวณ
// ‼️ คอลัมน์แรก (รหัส/ระบุตัว) ถูก pin ไว้หน้าสุดของทุกแท็บ — กันหลงแถวเวลาสลับแท็บ
// แบ่งด้วย flag เดิมล้วน (steel/steelBase/derived) → ไม่ต้องแตะ SB_SHEET_COLS
const SB_COL_SPLIT_AT = 7; // แท็บ "หลัก" (รวมรหัส) ยาวเกินจำนวนนี้ → แตก "รายละเอียด" ออก (คาน 8 คอลัมน์ก็แตก)
const SB_STEEL_SPLIT_MAX = 10; // แท็บเหล็ก (ไม่มีบน/ล่าง) ยาวเกินนี้ถึงแบ่งครึ่ง — ฐานราก X/Y+ปลอก (9) อยู่แท็บเดียว
function sbGroupCols(cols){
  const idCol = cols[0];
  const rest = cols.slice(1);
  // เหล็ก = มี steel flag หรือคีย์ขึ้นต้น rebar/ties (จับ rebar_kg ฐานราก/บันไดที่ไม่ mark derived → เคยหลุดไปแท็บหลัก)
  const isSteel = c => !!(c.steel || c.steelBase) || /^(rebar|ties|stirrup)/.test(c.steelBase || c.k);
  const steel = rest.filter(c=> !c.derived && !c.calcGroup && isSteel(c));
  const calc  = rest.filter(c=> (c.derived || c.calcGroup) && !c.mainTab);   // calcGroup = ช่องที่คิดอัตโนมัติแต่ไม่ mark derived (rebar_kg ฐานราก/บันได) → แท็บ "ผลคำนวณ" · mainTab = derived ที่อยู่แท็บหลัก
  // detail flag = บังคับเข้าแท็บ "รายละเอียด" (พารามิเตอร์รอง เช่น สเปกวัสดุ/เสาราว/ระดับบันได) ให้แท็บหลักไม่รก
  const detailForced = rest.filter(c=> !c.derived && !isSteel(c) && c.detail);
  const main  = rest.filter(c=> (!c.derived || c.mainTab) && !isSteel(c) && !c.detail);
  const tabs = [];
  let mainCols = main, detailCols = detailForced;
  if(1 + main.length > SB_COL_SPLIT_AT){
    // แท็บหลักยังยาวเกิน → แบ่งที่คอลัมน์จำนวน (ก่อน = ระบุตัว+มิติหลัก · ส่วนเกินต่อท้ายเข้ารายละเอียด)
    let cut = main.findIndex(c=> c.k==='count' || c.alt==='qty');
    if(cut < 1 || cut >= main.length-1) cut = Math.ceil(main.length/2) - 1; // ไม่เจอ/ชิดขอบ → ตัดครึ่ง
    mainCols = main.slice(0, cut+1);
    detailCols = [...main.slice(cut+1), ...detailForced];
  }
  tabs.push({ id:'main', label:'ขนาด & จำนวน', cols:[idCol,...mainCols] });
  if(detailCols.length) tabs.push({ id:'detail', label:'รายละเอียด', cols:[idCol,...detailCols] });
  // เหล็ก: ยาวเกิน → แตก "เหล็กบน"/"เหล็กล่าง" (คานมีบทบาทบน/ล่าง) หรือแบ่งครึ่ง (ฐานราก X/Y ไม่มีบน/ล่าง)
  if(steel.length){
    const isTop = c => /top/.test(c.steelBase || c.k);
    const top = steel.filter(isTop), bot = steel.filter(c=>!isTop(c));
    if(1 + steel.length > SB_COL_SPLIT_AT && top.length && bot.length){
      // มีบทบาทบน/ล่าง (คาน) → แยกแท็บตามบทบาท (สื่อความหมาย)
      tabs.push({ id:'steel',  label:'เหล็กบน',  cols:[idCol,...top] });
      tabs.push({ id:'steel2', label:'เหล็กล่าง', cols:[idCol,...bot] });
    } else if(1 + steel.length > SB_STEEL_SPLIT_MAX){
      // ยาวมากและไม่มีบน/ล่าง → แบ่งครึ่งกันตารางล้น · เลื่อนจุดตัดไปขอบช่องเหล็ก (ไม่แยกช่องย่อยของ field เดียว)
      let cut = Math.ceil(steel.length/2);
      while(cut>1 && cut<steel.length && steel[cut].steelBase && steel[cut].steelBase===steel[cut-1].steelBase) cut++;
      tabs.push({ id:'steel',  label:'เหล็กเสริม',    cols:[idCol,...steel.slice(0,cut)] });
      tabs.push({ id:'steel2', label:'เหล็กเสริม (2)', cols:[idCol,...steel.slice(cut)] });
    } else tabs.push({ id:'steel', label:'เหล็กเสริม', cols:[idCol,...steel] });   // ฐานราก (X/Y+ปลอก) อยู่แท็บเดียว
  }
  if(calc.length)  tabs.push({ id:'calc',  label:'ผลคำนวณ',   cols:[idCol,...calc] });
  return tabs;
}
// ช่องเลือก + พิมพ์เองได้ — ใช้แทน datalist: datalist กรองตามค่าในช่อง พอมีค่าอยู่แล้วกดลูกศรจึงไม่เห็นตัวเลือกอื่น
//   เปิดมาเห็นครบทุกรายการ · เริ่มกรองเมื่อพิมพ์ · portal ไป body กันตารางตัดรายการ
function SbCombo({ value, options, onChange, onFocus, placeholder, className }){
  const [pos, setPos] = useState(null);
  const [typed, setTyped] = useState(false);
  const wrap = useRef(null), list = useRef(null);
  const place = () => {
    const b = wrap.current.getBoundingClientRect();
    const below = window.innerHeight - b.bottom >= 260;
    setPos({ left:b.left, minWidth:b.width, ...(below ? { top:b.bottom+4 } : { bottom:window.innerHeight-b.top+4 }) });
  };
  const open = () => { place(); setTyped(false); };
  const close = () => setPos(null);
  useEffect(()=>{
    if(!pos) return;
    // กดช่องแล้วแถวถูกเลือก ตารางเลื่อนตาม → ขยับรายการตามช่อง ห้ามปิด ไม่งั้นรายการหายทันทีที่เปิด
    const onScroll = e => { if(wrap.current && (!list.current || !list.current.contains(e.target))) place(); };
    window.addEventListener('scroll', onScroll, true);
    return ()=>window.removeEventListener('scroll', onScroll, true);
  }, [pos]);
  const val = String(value ?? '');
  const q = val.trim().toLowerCase();
  const all = pos ? options() : [];
  const shown = typed && q ? all.filter(o=>o.toLowerCase().includes(q)) : all;
  return (
    <div className={'sb-combo '+(className||'')} ref={wrap}>
      <input className="cell-edit" value={val} placeholder={placeholder}
        onChange={e=>{ onChange(e.target.value); if(!pos) open(); setTyped(true); }}
        onFocus={onFocus} onClick={()=>{ if(!pos) open(); }} onBlur={close}
        onKeyDown={e=>{ if(e.key==='Escape') close(); }}/>
      <button type="button" className="sb-combo-arrow" tabIndex={-1} aria-label="เปิดรายการ"
        onMouseDown={e=>{ e.preventDefault(); wrap.current.querySelector('input').focus(); pos ? close() : open(); }}>▾</button>
      {pos && shown.length>0 && ReactDOM.createPortal(
        <div className="sb-combo-list" ref={list} style={pos} onMouseDown={e=>e.preventDefault()}>
          {shown.map(o=>(
            <button type="button" key={o} className={o===val.replace(/mm$/i,'')?'on':''} onClick={()=>{ onChange(o); close(); }}>{o}</button>
          ))}
        </div>, document.body)}
    </div>
  );
}
// รายการหน้าตัด: จากตารางน้ำหนัก + ตัวประกบคู่ 2C/2L (steelWeight คิดน้ำหนัก ×2 จาก prefix)
const sbSectionOptions = () => {
  const names = ((window.STEEL_SECTIONS&&window.STEEL_SECTIONS.rows)||[]).map(s=>s.name);
  return [...new Set(names.flatMap(n=>/^[CL]-/.test(n) ? [n, '2'+n] : [n]))];
};

function ResultsScreen({ project, boqData, onConfirm, onBack, isAdmin }){
  const toast = useToast();
  const aiRows = mapBoqToRows(boqData);
  const isReal = !!aiRows;
  // ข้อมูลตัวอย่าง (QUANTITIES) ใช้เฉพาะโปรเจกต์สาธิต — โปรเจกต์จริงที่ไม่มีผลถอดให้แสดง empty state แทน
  const [rows,setRows] = useState(()=> aiRows || (project?.__demo ? QUANTITIES.map(r=>({...r})) : []));
  const [sel,setSel] = useState(null);
  // โหมดสรุป (ค่าเริ่มต้น): หัวหมวดโชว์ยอดหลัก + หมวดยุบไว้ · กางแล้วโชว์เฉพาะช่องกรอก · "ตารางเต็ม" = แบบเดิมทุกคอลัมน์
  const [summary,setSummary] = useState(()=>{ try{ return localStorage.getItem('sb_results_mode')!=='full'; }catch(e){ return true; } });
  const [openG,setOpenG] = useState(()=>{ const o={}; Object.keys(CAT_COLOR).forEach(c=>o[c]=!summary); return o; });
  const switchMode = (sum)=>{
    setSummary(sum);
    const o={}; Object.keys(CAT_COLOR).forEach(c=>o[c]=!sum); setOpenG(o);
    try{ localStorage.setItem('sb_results_mode', sum?'summary':'full'); }catch(e){}
  };
  // โหมดสรุป: ชิป = แท็บ · "สรุป" = การ์ด + บรรทัดยอดรายหมวด (ไม่กางรายละเอียด)
  //   กดบรรทัดหมวดในหน้าสรุป = ไปแท็บหมวดนั้น (เหมือนกดชิปด้านบน) → โชว์ตารางของหมวดนั้น
  const qbodyRef = useRef(null);
  useEffect(()=>{ if(qbodyRef.current) qbodyRef.current.scrollTop = 0; },[catF]);
  // หน้าสรุป (catF='all') = ยุบทุกหมวด · แท็บหมวด = กางเสมอ · ตารางเต็ม = ตาม openG แบบเดิม
  const accOpen = (cat)=> summary ? catF!=='all' : !!openG[cat];
  const accClick = (cat)=>{ if(summary){ if(catF==='all') setCatF(cat); return; } setOpenG(o=>({...o,[cat]:!o[cat]})); };
  const [search,setSearch] = useState('');
  const [catF,setCatF] = useState('all');
  const [zoom,setZoom] = useState(1);
  const [page,setPage] = useState(1);
  // แบบจริง: storagePath แนบมากับ boqData (จาก screen_scope) · numPages มาจาก PdfDrawing เมื่อโหลด PDF เสร็จ
  const storagePath = boqData?.storagePath || null;
  const [numPages,setNumPages] = useState(0);
  // marker overlay บนแบบจริง — cache ต่อโปรเจกต์ (ไม่ต้องรัน CV/OCR ซ้ำทุกครั้ง)
  const MARKS_KEY = (project && project.id) ? ('sb_marks_'+project.id) : null;
  const [marks,setMarks] = useState(()=>{ if(!MARKS_KEY) return {}; try{ return JSON.parse(localStorage.getItem(MARKS_KEY)||'{}')||{}; }catch(e){ return {}; } });
  const [overlayBusy,setOverlayBusy] = useState(false);
  const [overlayMsg,setOverlayMsg]  = useState('');
  const [drawer,setDrawer] = useState(false);      // Assumption Log — เริ่มยุบ กดไอคอนค่อยกาง
  const [costOpen,setCostOpen] = useState(false);  // ค่าใช้จ่าย — เริ่มยุบ กดไอคอนค่อยกาง
  const [hideDerived,setHideDerived] = useState(false); // ซ่อนคอลัมน์ที่คำนวณอัตโนมัติ (ƒ)
  const [showEmptyCols,setShowEmptyCols] = useState(false); // เผยคอลัมน์ B2/กริด/เสริม ที่ปกติซ่อนตอนว่าง (ไว้กรอกข้อมูล)
  const [addOpen,setAddOpen] = useState(false);
  // หมวดที่ผู้ใช้กด "เพิ่มหมวด" เอง (นอกเหนือจากที่เลือกตอน scope) → โชว์หมวดเปล่าให้กรอกแม้ AI ไม่เจอ/ไม่ได้เลือก
  const [addedCats,setAddedCats] = useState([]);
  const [addCatOpen,setAddCatOpen] = useState(false);   // เปิด/ปิดเมนูเลือกหมวดที่จะเพิ่ม
  const [delId,setDelId] = useState(null);
  const [auditId,setAuditId] = useState(null);
  const [confirmOpen,setConfirmOpen] = useState(false);
  // เตือนเมื่อ AI ถอดข้อมูลได้ไม่ครบ (ผลลัพธ์ถูกตัดเพราะยาวเกินขีดจำกัด)
  //   ลูกค้า = ข้อความทางการ (sbCustomerWarning · ไม่มีอะไรต้องทำ = ไม่โชว์แถบ) · admin = ข้อความดิบเต็มไว้ตรวจงานถอด
  const rawWarning = boqData?.summary?._warning || null;
  const partialWarning = isAdmin ? rawWarning : (window.sbCustomerWarning ? window.sbCustomerWarning(rawWarning) : null);
  const [warnOpen,setWarnOpen] = useState(true);

  // resizable split
  const splitRef = useRef(null);
  const dragRef = useRef(false);
  const [rightW,setRightW] = useState(54); // percent of split width
  const [viewMode,setViewMode] = useState('split'); // 'split' (แบบ+ตาราง) | 'table' (ตารางปริมาณอย่างเดียว) | 'drawing' (แบบอย่างเดียว)
  useEffect(()=>{
    const move = (e)=>{
      if(!dragRef.current || !splitRef.current) return;
      const rect = splitRef.current.getBoundingClientRect();
      let pct = (rect.right - e.clientX) / rect.width * 100;
      setRightW(Math.max(32, Math.min(72, pct)));
    };
    const up = ()=>{ if(dragRef.current){ dragRef.current=false; document.body.style.cursor=''; document.body.style.userSelect=''; } };
    window.addEventListener('mousemove',move);
    window.addEventListener('mouseup',up);
    return ()=>{ window.removeEventListener('mousemove',move); window.removeEventListener('mouseup',up); };
  },[]);
  const startDrag = ()=>{ dragRef.current=true; document.body.style.cursor='col-resize'; document.body.style.userSelect='none'; };

  // ── ซูม + drag-to-pan แผงพรีวิวแบบ ──
  const stageRef   = useRef(null);   // .viewer-stage = scroll container
  const panRef     = useRef(null);   // {x,y,sl,st} ระหว่างลาก
  const draggedRef = useRef(false);  // เพิ่งลาก → กันคลิก bbox โดยไม่ตั้งใจ
  const zoomRef    = useRef(1);      // ค่าซูมล่าสุด (ให้ wheel handler อ่านได้โดยไม่ต้องผูก listener ใหม่ทุกครั้ง)
  const zoomAnchor = useRef(null);   // {mx,my,r} จุดที่ต้องคงไว้ใต้เมาส์หลังซูม (ใช้ใน layout effect ด้านล่าง)
  const ZOOM_MIN = 0.3, ZOOM_MAX = 6;
  // ซูมแบบ "ยึดจุด": mx,my = ตำแหน่งในกรอบ stage (ไม่ระบุ = กึ่งกลาง) → เนื้อหาใต้จุดนั้นไม่ลอยหนี
  const zoomBy = (factor, mx, my)=>{
    const st = stageRef.current;
    const cur = zoomRef.current;
    const next = Math.min(ZOOM_MAX, Math.max(ZOOM_MIN, +(cur*factor).toFixed(3)));
    if(next===cur) return;
    if(st){ if(mx==null) mx = st.clientWidth/2; if(my==null) my = st.clientHeight/2; zoomAnchor.current = { mx, my, r: next/cur }; }
    zoomRef.current = next;
    setZoom(next);
  };
  const resetZoom = ()=>{ zoomAnchor.current=null; zoomRef.current=1; setZoom(1); const st=stageRef.current; if(st){ st.scrollLeft=0; st.scrollTop=0; } };
  useEffect(()=>{ zoomRef.current = zoom; },[zoom]);
  // หลัง React วาดกรอบขนาดใหม่แล้ว (PdfDrawing ปรับขนาด canvas ใน layout effect ของมันเอง ซึ่งรันก่อนตัวนี้) → เลื่อน scroll ให้จุดเดิมอยู่ใต้เมาส์
  React.useLayoutEffect(()=>{
    const a = zoomAnchor.current, st = stageRef.current; zoomAnchor.current = null;
    if(!a || !st) return;
    const PAD = 30;   // = padding ของ .viewer-stage
    st.scrollLeft = (st.scrollLeft + a.mx - PAD) * a.r + PAD - a.mx;
    st.scrollTop  = (st.scrollTop  + a.my - PAD) * a.r + PAD - a.my;
  },[zoom]);
  // Ctrl+ล้อเมาส์ (และ pinch บนทัชแพด ซึ่งส่ง ctrlKey มาด้วย) = ซูมตามตำแหน่งเมาส์ · ล้อเปล่า = เลื่อนปกติ
  // ‼️ ต้อง addEventListener แบบ passive:false เอง — React onWheel เป็น passive → preventDefault ไม่ได้ (หน้าจะซูมทั้งเว็บแทน)
  useEffect(()=>{
    const st = stageRef.current; if(!st) return;
    const onWheel = (e)=>{
      if(!(e.ctrlKey||e.metaKey)) return;
      e.preventDefault();
      const rect = st.getBoundingClientRect();
      zoomBy(Math.exp(-e.deltaY*0.0018), e.clientX-rect.left, e.clientY-rect.top);
    };
    st.addEventListener('wheel', onWheel, { passive:false });
    return ()=>st.removeEventListener('wheel', onWheel);
  },[viewMode]);   // stage ถูก unmount/mount ตามโหมด → ผูกใหม่ทุกครั้งที่โหมดเปลี่ยน
  // ลากเลื่อน: ผูก move/up ที่ window ระหว่างลาก → เมาส์หลุดขอบกรอบแล้วยังลากต่อได้ (เดิมใช้ onMouseLeave = ลากขาดทันที)
  const onStageDown = (e)=>{ const st=stageRef.current; if(!st||e.button!==0) return;
    panRef.current={ x:e.clientX, y:e.clientY, sl:st.scrollLeft, st:st.scrollTop }; draggedRef.current=false;
    const move = (ev)=>{ const p=panRef.current; if(!p) return;
      const dx=ev.clientX-p.x, dy=ev.clientY-p.y; if(Math.abs(dx)+Math.abs(dy)>4) draggedRef.current=true;
      st.scrollLeft=p.sl-dx; st.scrollTop=p.st-dy; };
    const up = ()=>{ panRef.current=null; window.removeEventListener('mousemove',move); window.removeEventListener('mouseup',up);
      setTimeout(()=>{ draggedRef.current=false; },0); };
    window.addEventListener('mousemove',move); window.addEventListener('mouseup',up); };

  const cats = Object.keys(CAT_COLOR);
  // มีแบบจริง (storagePath แนบมา) → ใช้ PdfDrawing · โหลดพลาด PdfDrawing โชว์ error เอง (ไม่ fall back grid ปลอม)
  const hasPdf = !!storagePath;
  const pages = (hasPdf && numPages>0)
    ? Array.from({length:numPages},(_,i)=>i+1)
    : ([...new Set(rows.map(r=>r.page))].sort((a,b)=>a-b));
  // เมื่อ PDF โหลดเสร็จครั้งแรก → กระโดดไปหน้าแรกที่มีรายการ (ถ้ายังอยู่หน้า 1 default)
  const jumpedRef = useRef(false);
  useEffect(()=>{
    if(!hasPdf || numPages<=0 || jumpedRef.current) return;
    jumpedRef.current = true;
    const itemPages = [...new Set(rows.map(r=>r.page).filter(p=>p>=1 && p<=numPages))].sort((a,b)=>a-b);
    if(itemPages.length && page===1 && itemPages[0]!==1) setPage(itemPages[0]);
  },[hasPdf,numPages]);
  // รหัสแผ่น (page_ref) ของรายการในหน้าปัจจุบัน — โชว์บน viewer-bar/pagebar (แบบจริง)
  const _curPr = hasPdf ? (((boqData?.items||[]).find(it=>Number(it.page_num)===page)||{}).page_ref||'') : '';
  const curPageRef = (_curPr && _curPr!=='-') ? _curPr.replace(/,.*$/,'').trim() : '';
  const visRows = rows.filter(r =>
    (catF==='all'||r.cat===catF) &&
    (!search || r.code.toLowerCase().includes(search.toLowerCase()) || r.name.includes(search)));

  const grouped = cats.map(c=>({ cat:c, items:visRows.filter(r=>r.cat===c) })).filter(g=>g.items.length);
  const pageBoxes = rows.filter(r=>r.page===page && r.bbox);

  // ── โหมดตารางตาม sheet (คอลัมน์ตรงกับ Excel + แก้ค่าได้ + สูตรอัตโนมัติ) ──
  // สำเนาแก้ไขได้ของ sheets (clone จาก AI) — เป็น source of truth ของหน้านี้
  // ‼️ ต้องรันสูตรทุกแถว "ตั้งแต่โหลด" ไม่ใช่รอให้ผู้ใช้แตะเซลล์ก่อน:
  //    เดิมแถวที่ยังไม่ถูกแก้จะโชว์เลขดิบจาก AI ขณะที่ Excel คิดจากสูตรเสมอ → จอกับไฟล์คนละเลข
  //    (ยิ่งไปกว่านั้น sheetState คือของที่ onConfirm ส่งกลับเข้า boqData → Excel ใช้ค่านี้ต่อ
  //     ดังนั้นการ recompute ตรงนี้ = ทำให้ยอดคอนกรีต/ไม้แบบคาน-พื้น ที่ Excel ไม่มีสูตรของตัวเอง
  //     ได้ค่าที่โค้ดคิดไปด้วย)
  //    พฤติกรรมต้องเหมือน recompute ตอนแก้เซลล์เป๊ะ — ถ้า SB_RECOMPUTE ตัวไหนคิดผิด จะโผล่ที่นี่ทันที
  //    ซึ่งเป็นเรื่องดี: เห็นตั้งแต่เปิดหน้า ดีกว่าไปเจอตอน export
  const [sheetState,setSheetState] = useState(()=>{
    if(!boqData?.sheets) return null;
    const clone = JSON.parse(JSON.stringify(boqData.sheets));
    SB_OPENING_IDX = sbBuildOpeningIdx(clone); SB_FOOT_T = sbFootTref(clone); SB_ROOF_AREA = sbRoofAreaIdx(clone);   // ‼️ สร้าง index บานก่อน recompute ผนัง (ผนังใช้ค่านี้หักช่องเปิด)
    Object.keys(clone).forEach(sk=>{
      if(!SB_RECOMPUTE[sk] || !Array.isArray(clone[sk])) return;
      clone[sk].forEach(row=>{ if(row && typeof row === 'object') SB_RECOMPUTE[sk](row); });
    });
    return clone;
  });
  const [dirty,setDirty] = useState(false);
  // รัน SB_RECOMPUTE ใหม่ทั้งชีต — เรียกหลังผู้ใช้แก้ตารางน้ำหนักเหล็ก เพื่ออัปเดต น.น.โครงหลังคา
  const recomputeAllSheets = () => setSheetState(prev=>{
    if(!prev) return prev;
    const clone = JSON.parse(JSON.stringify(prev));
    SB_OPENING_IDX = sbBuildOpeningIdx(clone); SB_FOOT_T = sbFootTref(clone); SB_ROOF_AREA = sbRoofAreaIdx(clone);
    Object.keys(clone).forEach(sk=>{ if(!SB_RECOMPUTE[sk]||!Array.isArray(clone[sk])) return;
      clone[sk].forEach(row=>{ if(row&&typeof row==='object') SB_RECOMPUTE[sk](row); }); });
    return clone;
  });
  // ‼️ ตารางน้ำหนักเหล็กย้ายไปเปิดจาก sidebar (App) แล้ว — ฟังอีเวนต์ "บันทึก" เพื่อคำนวณ น.น.โครงหลังคาใหม่
  //    recomputeAllSheets ใช้ setState แบบ functional → closure เก่าปลอดภัย (ไม่อ้าง sheetState ตรง ๆ)
  useEffect(()=>{
    const h = ()=>{ recomputeAllSheets(); setDirty(true); };
    window.addEventListener('sb-steel-saved', h);
    return ()=> window.removeEventListener('sb-steel-saved', h);
  },[]);
  // ‼️ Auto-save: เขียน sheet ที่แก้ลง cache เดิม `sb_boq_<id>` (คีย์ตรงกับ BOQ_CACHE_KEY ใน app.jsx)
  //    App โหลด cache นี้กลับตอนเปิดโปรเจกต์ → รีเฟรชกลางแก้แล้วค่าไม่หาย (เดิม boqData ไม่อัปเดตจน confirm)
  //    ข้ามโปรเจกต์สาธิต · re-extract ใหม่ App จะเขียนทับ cache ด้วย boqData สด (ไม่มี stale)
  // หมวดที่ต้องโชว์แม้ว่าง = ที่เลือกตอน scope + ที่ผู้ใช้กดเพิ่มเองในหน้านี้
  const forceCats = useMemo(()=>{
    const base = Array.isArray(boqData?.selectedCats) ? boqData.selectedCats : [];
    return [...new Set([...base, ...addedCats])];
  },[boqData, addedCats]);
  // + ส่งขึ้น server ด้วย (เปิดเครื่องอื่นเห็นงานที่แก้ค้าง · ตรวจระบบ H6) — เฉพาะเมื่อแก้จริง (dirty) · รวบ 3 วิหลังแก้ครั้งสุดท้าย
  //   ออกจากหน้านี้ก่อนครบ 3 วิ = ส่งทันที · ไม่ทันจริง ๆ (ปิดแท็บ) → เปิดโปรเจกต์ครั้งหน้าในเครื่องนี้ app ส่งฉบับในเครื่องที่ใหม่กว่าขึ้นให้
  //   โปรเจกต์คนอื่น (admin เปิดดู) = เก็บในเครื่องแบบเดิม ไม่ประทับเวลา ไม่ส่งขึ้น
  const mine = !!(window.sbIsMine && window.sbIsMine(project));
  const serverSave = React.useRef({ timer:null, data:null, last:0 });
  const flushServerSave = () => {
    const s = serverSave.current; clearTimeout(s.timer); s.timer = null;
    if(s.data && project?.id && window.saveBoqData) window.saveBoqData(project.id, s.data);
    s.data = null;
  };
  const cancelServerSave = () => { const s = serverSave.current; clearTimeout(s.timer); s.timer = null; s.data = null; };
  const nextStamp = () => { const s = serverSave.current; s.last = window.sbNextStamp(window.sbSavedAt(boqData), s.last); return s.last; };
  useEffect(()=> flushServerSave, []);
  useEffect(()=>{
    if(!sheetState || project?.__demo || !project?.id) return;
    // persist หมวดที่เพิ่มเองด้วย (selectedCats รวม) → รีเฟรชแล้วหมวดเปล่าที่เพิ่งเพิ่มไม่หาย
    const save = dirty && mine;
    // _qtyEditedAt = เวลาที่ผู้ใช้แก้ตารางจริง (dirty) — หน้าส่งออกเทียบกับ pricing.ts: แก้หลังยืนยันราคา = ราคาในไฟล์เป็นของปริมาณเก่า
    const data = { ...boqData, sheets: sheetState, selectedCats: forceCats, ...(save ? { _savedAt: nextStamp(), _qtyEditedAt: Date.now() } : {}) };
    try { localStorage.setItem('sb_boq_'+project.id, JSON.stringify(data)); } catch(e){}
    if(!save) return;
    const s = serverSave.current; s.data = data; clearTimeout(s.timer);
    s.timer = setTimeout(flushServerSave, 3000);
  },[sheetState, forceCats, dirty]);

  const sheetGroups = sbBuildGroups(sheetState, boqData?.items, search, forceCats);
  const useSheets = sheetGroups.length > 0;
  const visSheetGroups = sheetGroups.filter(g => catF==='all' || g.cat===catF);
  const sheetTotalCount = sheetGroups.reduce((a,g)=>a+g.count,0);
  const sheetTotalUnits = sheetGroups.reduce((a,g)=>a+g.units,0);
  const sheetCatCount = (c) => { const g=sheetGroups.find(x=>x.cat===c); return g?g.count:0; };
  // แถวที่ "ไม่มีปริมาณ" (0/ว่าง) — ตรวจจาก sheetState เต็ม (ไม่สนช่องค้นหา) · มี = ห้ามยืนยันปริมาณ
  const qtyIss = useMemo(()=>sbQtyIssues(sheetState), [sheetState]);
  const qtyBlocked = useSheets && qtyIss.total > 0;
  // ── ตารางสัญลักษณ์ (legend) ที่ AI อ่านได้ — โชว์เป็นแท็บแยกไว้รีเช็คกับแบบ (เดิมมีแค่ใน Excel) ──
  const legendRows = Array.isArray(boqData?.legend) ? boqData.legend : [];
  const showLegend = catF === '__legend__';

  // แก้ค่าช่อง input → อัปเดต sheetState + คำนวณสูตรเรขาคณิตใหม่
  const editCell = (sk, idx, col, value) => {
    // เก็บค่าดิบ (string) เพื่อให้พิมพ์ทศนิยมได้ลื่น — สูตร recompute ใช้ Number() แปลงเอง
    setSheetState(prev=>{
      SB_OPENING_IDX = sbBuildOpeningIdx(prev); SB_FOOT_T = sbFootTref(prev); SB_ROOF_AREA = sbRoofAreaIdx(prev);   // ให้ recompute แถวนี้ใช้ขนาดบานล่าสุด (กรณีแก้ผนัง)
      const arr = (prev[sk]||[]).slice();
      const old = arr[idx];
      const row = { ...old };
      if(col.steelPart){
        // ช่องย่อยของสเปกเหล็ก → แตกค่าเดิม เปลี่ยนเฉพาะส่วนที่พิมพ์ แล้วประกอบกลับเป็นสเปกเดียว
        const parts = sbSteelSplit(addSteelType(sbBaseRaw(old,col)), col.steelMode);
        parts[col.steelPart] = value;
        // ‼️ โหมด 'both': จำนวนเส้น กับ @ระยะ ใช้ร่วมกันไม่ได้ — พิมพ์อันหนึ่งแล้วล้างอีกอัน
        //    เพราะ sbFootRebarCalc เช็คระยะเรียงก่อน → ถ้ามีทั้งคู่ จำนวนเส้นที่ผู้ใช้เห็นจะถูกเมินเงียบ ๆ
        if(col.steelMode==='both' && String(value||'').trim()){
          if(col.steelPart==='sp') parts.n = '';
          else if(col.steelPart==='n') parts.sp = '';
        }
        row[col.steelBase] = sbSteelJoin(parts);
      } else row[col.k] = value;
      // แก้ช่อง "หน้าตัด" ของสมาชิกเหล็กรูปพรรณ → ลิงก์ น.น./ม. ใหม่จากตารางหน้าตัดเหล็ก
      //   จับคู่ได้ = ทับ (relink) · จับคู่ไม่ได้ = ล้างให้กรอกมือ (กันค่าค้างจากหน้าตัดเดิม) — recompute จะไม่ทับต่อ
      if(col.secWeight && col.k==='section' && window.steelWeight){
        const w = window.steelWeight(value);
        row.unit_weight = (w!=null) ? w : '';
      }
      // แก้ "จำนวน" → scale เหล็กตามสัดส่วน (เหล็กเป็นค่าแก้มือ ไม่อยู่ในสูตรเรขาคณิต)
      // ให้เหมือน reconcile ฝั่ง Edge Function: ปรับ count แล้วปริมาณเหล็กสเกลตาม
      if(col.k==='count' || col.k==='qty'){
        const oldN = Number(old.count ?? old.qty) || 0;
        const newN = Number(value) || 0;
        if(oldN>0 && newN>0 && newN!==oldN){
          const f = newN/oldN;
          ['rebar_kg','weight_kg','rebar_bot_kg','rebar_tie_kg'].forEach(k=>{
            const cur = Number(row[k]);
            if(row[k]!=null && row[k]!=='' && !isNaN(cur)) row[k] = sbR2(cur*f);
          });
        }
      }
      if(SB_RECOMPUTE[sk]) SB_RECOMPUTE[sk](row);
      arr[idx] = row;
      const next = { ...prev, [sk]: arr };
      // แก้ฐานราก (T) → คิดเหล็กยืนตอม่อทุกต้นใหม่ (หยั่งลงตาม T ฐาน · SB_FOOT_T)
      if(sk==='footings' && Array.isArray(next.columns)){
        SB_FOOT_T = sbFootTref(next);
        next.columns = next.columns.map(c=>{ if(c&&typeof c==='object'&&sbIsPier(c)){ const cr={...c}; SB_RECOMPUTE.columns(cr); return cr; } return c; });
      }
      // แก้ผืนหลังคา (ขนาด/มุม/รหัส) → คิดสมาชิกที่เรียง @ ทุกตัวใหม่ (ความยาว = พื้นที่ผืนที่คลุม ÷ @ · SB_ROOF_AREA)
      if(sk==='roof' && Array.isArray(next.roof_members)){
        SB_ROOF_AREA = sbRoofAreaIdx(next);
        next.roof_members = next.roof_members.map(m=>{ if(m&&typeof m==='object'&&m.covers){ const mr={...m}; SB_RECOMPUTE.roof_members(mr); return mr; } return m; });
      }
      // ‼️ แก้ประตู/หน้าต่าง (ขนาด/รหัส) → รีเฟรช index บาน + คิดผนังทุกใบใหม่ (ช่องเปิดผูกกัน)
      if(sk==='doors' || sk==='windows'){
        SB_OPENING_IDX = sbBuildOpeningIdx(next); SB_FOOT_T = sbFootTref(next);
        if(Array.isArray(next.walls))
          next.walls = next.walls.map(w=>{ if(w&&typeof w==='object'){ const wr={...w}; SB_RECOMPUTE.walls(wr); return wr; } return w; });
      }
      return next;
    });
    setDirty(true);
  };

  // แถวว่างใหม่สำหรับ sheet (เติมคีย์ตาม cols + recompute สูตร)
  const sbBlankRow = (sk) => {
    const row = {};
    (SB_SHEET_COLS[sk]?.cols||[]).forEach(c=>{ row[c.k]=''; });
    row.code=''; row.count=1;
    if(SB_RECOMPUTE[sk]) SB_RECOMPUTE[sk](row);
    return row;
  };
  // เพิ่มแถวว่างท้ายชีต
  const addSheetRow = (sk) => {
    setSheetState(prev=>{ const arr=(prev[sk]||[]).slice(); arr.push(sbBlankRow(sk)); return {...prev,[sk]:arr}; });
    setDirty(true);
  };
  // แตกแถว = คัดลอกแถวนี้แทรกถัดลงไป (ใช้แยกคานหนึ่งรหัสเป็นหลายช่วง แล้วแก้ length/count แต่ละแถว)
  // แตก/ลบแถวผืนหลังคา → พื้นที่ที่สมาชิก @ คลุมเปลี่ยน → คิดสมาชิกที่มีคลุมผืนใหม่
  const sbRoofMembersSync = (sk, next) => {
    if(sk!=='roof' || !Array.isArray(next.roof_members)) return next;
    SB_ROOF_AREA = sbRoofAreaIdx(next);
    return { ...next, roof_members: next.roof_members.map(m=>{ if(m&&typeof m==='object'&&m.covers){ const mr={...m}; SB_RECOMPUTE.roof_members(mr); return mr; } return m; }) };
  };
  const dupSheetRow = (sk, idx, e) => {
    if(e) e.stopPropagation();
    setSheetState(prev=>{ const arr=(prev[sk]||[]).slice(); const copy=JSON.parse(JSON.stringify(arr[idx]||{})); arr.splice(idx+1,0,copy); return sbRoofMembersSync(sk,{...prev,[sk]:arr}); });
    setDirty(true);
  };
  // ลบแถว
  const delSheetRow = (sk, idx, e) => {
    if(e) e.stopPropagation();
    setSheetState(prev=>{ const arr=(prev[sk]||[]).slice(); arr.splice(idx,1); return sbRoofMembersSync(sk,{...prev,[sk]:arr}); });
    setDirty(true);
  };

  // selection สำหรับโหมด sheet (อ้างด้วย code)
  const [selCode,setSelCode] = useState(null);
  const [selCat,setSelCat] = useState(null);
  // แท็บกลุ่มคอลัมน์ที่เปิดอยู่ต่อ block (key=b.key → 'main'|'steel'|'calc') · ไม่มีค่า = 'main'
  const [colTab,setColTab] = useState({});
  const selectSheetRow = (cat, code) => {
    setSelCode(code); setSelCat(cat);
    const it = (boqData?.items||[]).find(i => code && String(i.code||'').includes(String(code)));
    if(it?.page_num) setPage(it.page_num);
  };

  // ── overlay marker (เฟส A: ป้อนทดสอบ · เฟส B: มาจาก CV/OCR) ──
  // คลิก marker → เลือกแถวที่รหัสตรงกัน (โยง marker↔ตาราง 2 ทาง — คลิกแถวจะไปเน้น marker ผ่าน svgHighlight)
  const onMarkClick = (mk) => {
    if(!mk.code) return;   // วงแดงของ grid marks (ป้ายในแบบที่ไม่มีแถว) — ไม่มีแถวให้เลือก
    if(useSheets){ setSelCode(mk.code); if(mk.cat!=null) setSelCat(mk.cat); }
    else { const r = rows.find(x=>String(x.code)===String(mk.code)); if(r) setSel(r.id); }
    toast('เลือกจากแบบ: '+mk.code, 'check');
  };
  // ── วาง marker แยก 4 หมวดงาน (ปุ่ม dropdown · พิ้งกำหนด) — เลือกหมวดไหน วางเฉพาะหมวดนั้น (แทนที่ marker เดิม) ──
  //   โครงสร้าง/สถาปัตย์ = OCR หารหัสในแบบ (ocr-overlay.jsx) · สุขาภิบาล = กรอบที่ AI นับ (item_marks) · ไฟฟ้า = ตัวนับเวกเตอร์ (elec-marks.jsx)
  //   หมวด → ชีต: SCOPE_ITEMS (data.jsx · disc) + SB_CAT_SHEETS
  const discSheets = (d) => (typeof SCOPE_ITEMS !== 'undefined' ? SCOPE_ITEMS : []).filter(it=>it.disc===d).flatMap(it=>SB_CAT_SHEETS[it.cat]||[]);
  const discCats = (d) => (typeof SCOPE_ITEMS !== 'undefined' ? SCOPE_ITEMS : []).filter(it=>it.disc===d).map(it=>it.cat);
  const discRowCount = useMemo(()=>{ const o={};
    MARK_DISCS.forEach(({id})=>{ o[id] = discSheets(id).reduce((n,sk)=>n+(Array.isArray(sheetState?.[sk]) ? sheetState[sk].filter(r=>r&&r.code).length : 0), 0); });
    return o;
  },[sheetState]);
  // รหัสเป้าหมายของหมวด (closed-set → OCR แมตช์แม่น) = plan_codes + sheets + items ของหมวดนั้น · หน้าที่สแกน = หน้าที่มีรหัสของหมวดนั้น
  const discTargets = (d) => {
    const sks = discSheets(d), cats = discCats(d), codes = new Set(), pages = new Set();
    const addRow = (r)=>{ if(r && r.code) codes.add(r.code); const p = Number(r && r.page_num); if(p>=1) pages.add(p); };
    sks.forEach(sk=>{ (Array.isArray(sheetState?.[sk]) ? sheetState[sk] : []).forEach(addRow);
      (Array.isArray(boqData?.plan_codes?.[sk]) ? boqData.plan_codes[sk] : []).forEach(x=>{ if(x && x.code) codes.add(x.code); }); });
    (boqData?.items||[]).filter(it=>it && cats.includes(it.category)).forEach(addRow);
    // แถวไม่มีเลขหน้า (สุขาภิบาลมีแค่ page_ref) → ใช้หน้าที่ระบบคัดหน้าให้สายนี้ (route_map) — ไม่งั้นไล่ทั้งไฟล์ (บ้านดุง 33 หน้า ~1 นาที/หน้า)
    if(!pages.size && boqData?.route_map){ const tag = d==='str' ? 'struct' : d;
      Object.entries(boqData.route_map).forEach(([p,tags])=>{ if(Array.isArray(tags) && tags.includes(tag) && Number(p)>=1) pages.add(Number(p)); }); }
    return { codes:[...codes], pages:[...pages].sort((a,b)=>a-b) };
  };
  // งานสุขาภิบาล: กรอบของทุกตัวที่ AI นับจากผัง (boqData.item_marks · บันทึกตอนถอด) → กรอบสีตามรายการ ป้ายรหัสขึ้นเมื่อชี้/เลือก
  //   ไม่ต้องอ่านแบบซ้ำ · ขึ้นเมื่อกดปุ่ม "วาง marker อัตโนมัติ" เท่านั้น (พิ้งกำหนด) · กดกรอบ = เลือกแถวรหัสนั้น
  const buildItemMarks = () => {
    const list = Array.isArray(boqData?.item_marks) ? boqData.item_marks : [];
    if(!list.length) return null;
    const rowOf = (code)=>{
      for(const [cat,keys] of Object.entries(SB_CAT_SHEETS)) for(const sk of (keys||[])){
        const r = (Array.isArray(sheetState?.[sk]) ? sheetState[sk] : []).find(x=>x && String(x.code)===String(code));
        if(r) return { cat, r };
      }
      return null;
    };
    const color = new Map(), per = new Map(), marks = {};
    for(const m of list){
      const b = m && m.b, pg = Number(m && m.page);
      if(!Array.isArray(b) || b.length!==4 || !(pg>=1)) continue;
      const code = String(m.code);
      if(!color.has(code)) color.set(code, ITEM_MARK_COLORS[color.size % ITEM_MARK_COLORS.length]);
      const hit = rowOf(code);   // ชี้แล้วขึ้นแค่รหัส — ชื่อรายการยาว บังแบบ (พิ้งกำหนด)
      (marks[pg] = marks[pg] || []).push({ code, cat: hit ? hit.cat : undefined, color: color.get(code), quiet: true, label: code,
        page: pg, nx: b[0], ny: b[1], nw: b[2]-b[0], nh: b[3]-b[1], type: 'box' });
      per.set(code, (per.get(code)||0) + 1);
    }
    // จำนวนกรอบ ≠ จำนวนในตาราง → บอกผู้ใช้ (ตาราง = ค่าที่ AI/ผู้ใช้ใส่ล่าสุด)
    const diff = [...per].map(([code,n])=>{ const hit = rowOf(code); const c = hit ? Number(hit.r.count) : NaN;
      return (Number.isFinite(c) && c!==n) ? `${code} กรอบ ${n}/ตาราง ${c}` : null; }).filter(Boolean);
    return { marks, per, diff, total: [...per.values()].reduce((a,n)=>a+n,0) };
  };
  const saveMarks = (m) => { setMarks(m); if(MARKS_KEY){ try{ localStorage.setItem(MARKS_KEY, JSON.stringify(m)); }catch(e){} } };
  const runItemMarks = (im) => {
    saveMarks(im.marks);
    const firstPage = Object.keys(im.marks).map(Number).sort((a,b)=>a-b)[0];
    if(firstPage) setPage(firstPage);
    toast(`วาง marker สุขาภิบาลแล้ว — ${im.total} จุด · ${im.per.size} รายการ (ชี้กรอบเพื่อดูรหัส)`+(im.diff.length?` · จำนวนไม่ตรง: ${im.diff.join(', ')}`:''), 'pin');
    return true;
  };
  // งานสุขาภิบาล: หาตำแหน่งกรอบใหม่แบบ 2 ขั้น (sani-locate.jsx · ช่องคร่าว ๆ → ซูมชี้กรอบ) จากรายการที่ AI นับไว้ตอนถอด
  //   ทำครั้งแรกที่กดปุ่มเท่านั้น แล้วเก็บผลแทน item_marks เดิม (+ item_marks_located) → กดครั้งต่อไปไม่เรียก AI ซ้ำ
  //   ‼️ หาไม่เจอ = ไม่วาง marker ตัวนั้น (พิ้งกำหนด 5 พ.ย.) — ไม่ใช้กรอบที่กะไว้ตอนถอดแทน
  // แถวตารางสุขาภิบาลที่นับเป็นชิ้น (สุขภัณฑ์ · บ่อ-ถัง · ปั๊ม-ถังน้ำ) → ให้ sani-locate หาครบทุกรหัสตามจำนวนในตาราง (ไม่ใช่แค่ที่ตีกรอบไว้ตอนถอด)
  const saniRows = () => ['สุขภัณฑ์','บ่อ-ถังบำบัด','ปั๊ม-ถังน้ำดี'].flatMap(cat=>(SB_CAT_SHEETS[cat]||[]))
    .flatMap(sk=>(Array.isArray(sheetState?.[sk]) ? sheetState[sk] : []).map(r=>({ r, sk })))
    .filter(({ r })=>r && r.code).map(({ r, sk })=>({ code: r.code, count: r.count, page_num: r.page_num, sheet: sk }));
  const runSaniLocate = async () => {
    if(!window.sbLocateSaniMarks){ toast('โมดูลหาตำแหน่งงานสุขาภิบาลยังไม่พร้อม (sani-locate.jsx)'); return false; }
    setOverlayBusy(true); setOverlayMsg('เริ่ม…');
    try{
      const accessToken = window.getAccessTokenFast ? await window.getAccessTokenFast() : null;
      const nameOf = (code)=>{
        for(const keys of Object.values(SB_CAT_SHEETS)) for(const sk of (keys||[])){
          const r = (Array.isArray(sheetState?.[sk]) ? sheetState[sk] : []).find(x=>x && String(x.code)===String(code));
          if(r) return r.type || r.name || '';
        }
        return '';
      };
      const res = await window.sbLocateSaniMarks({ storagePath, itemMarks: boqData.item_marks, rows: saniRows(), nameOf, accessToken, projectId: project && project.id,
        onProgress:({msg})=>setOverlayMsg(msg||'') });
      // ‼️ แก้ใน object boqData เดิม — app ถือ reference เดียวกัน ตอนกดยืนยัน/ทำราคา (merge {...boqData}) จะได้ไม่ทับกลับเป็นกรอบเก่า
      //    + บันทึกทั้ง server และ cache ในเครื่อง (app โหลด cache ก่อน server → ไม่งั้นเปิดใหม่ได้กรอบเก่าแล้วเรียก AI ซ้ำ)
      boqData.item_marks = res.marks;
      boqData.item_marks_located = { at: new Date().toISOString(), asked: res.asked, found: res.found, thb: res.thb };
      if(project && project.id && !project.__demo){
        // บันทึกพร้อมตารางที่แก้ค้าง (boqData ของ App ยังเป็นฉบับก่อนแก้) · ยกเลิก autosave ที่รออยู่ — ไม่งั้นมันส่งทีหลังแล้วทับกรอบ marker ใหม่
        const data = { ...boqData, sheets: sheetState || boqData.sheets, selectedCats: forceCats };
        if(mine){ data._savedAt = boqData._savedAt = nextStamp(); cancelServerSave(); }
        try{ localStorage.setItem('sb_boq_'+project.id, JSON.stringify(data)); }catch(e){}
        if(mine && window.saveBoqData) window.saveBoqData(project.id, data);
      }
      const miss = res.missing.map(m=>`${m.code} ${m.n} ตัว (หน้า ${m.page})`);
      const im = buildItemMarks();
      if(!im){ saveMarks({}); toast(`หาตำแหน่งไม่เจอเลย (${res.asked} ตัว) — ไม่วาง marker`, 'info'); return false; }
      runItemMarks(im);
      // รายการเยอะขึ้น (หาครบทุกรหัสในตาราง) → แสดงหาไม่เจอแค่ 6 รายการแรก กันข้อความยาวบังจอ
      if(miss.length) toast(`วาง marker สุขาภิบาลแล้ว ${res.found}/${res.asked} ตัว · หาไม่เจอ (ไม่วาง): ${miss.slice(0, 6).join(', ')}${miss.length > 6 ? ` และอีก ${miss.length - 6} รายการ` : ''}`, 'pin');
      return true;
    }catch(e){ console.warn('sani locate failed:', e); toast('หาตำแหน่งกรอบไม่สำเร็จ: '+(e.message||''), 'info'); return false; }
    finally{ setOverlayBusy(false); setOverlayMsg(''); }
  };
  const runElecMarks = async () => {
    if(!window.sbBuildElecMarks){ toast('โมดูล marker งานไฟฟ้ายังไม่พร้อม (elec-marks.jsx)'); return false; }
    setOverlayBusy(true); setOverlayMsg('เริ่ม…');
    try{
      const res = await window.sbBuildElecMarks({ storagePath, routeMap: boqData?.route_map, vectorCounts: boqData?.vector_counts, vectorMap: boqData?.vector_map, onProgress:({msg})=>setOverlayMsg(msg||'') });
      saveMarks(res.marks||{});
      const st=res.stats||{};
      if(st.legendPage) setPage(st.legendPage);   // เปิดหน้าตาราง Legend ก่อน — ป้าย "L5 = 33 จุด" บอกว่าสีไหนคือแถวไหน
      toast(`วาง marker งานไฟฟ้าแล้ว — ${st.rows?.length||0} แถว Legend · ${st.total||0} จุด (ดูป้าย L ที่ตาราง Legend หน้า ${st.legendPage})`+(st.skipped?.length?` · ข้าม ${st.skipped.join(', ')} (สัญลักษณ์เส้นตรงล้วน จับผิดได้)`:'')+(st.unmapped?.length?` · ไม่วาง ${st.unmapped.join(', ')} (AI ไม่ยืนยันว่าเป็นรายการงานไฟฟ้า)`:''), 'pin');
      return true;
    }catch(e){ console.warn('elec marks failed:',e); toast('วาง marker ไม่สำเร็จ: '+(e.message||''), 'info'); return false; }
    finally{ setOverlayBusy(false); setOverlayMsg(''); }
  };
  // base = marker ที่วางไว้แล้ว (เช่นจากกริด) → รวมกับผล OCR แทนการทับ (ใช้ตอนหารหัสเฉพาะหมวดที่กริดวางไม่ได้)
  const runOcrMarks = async (codes, pages, th, base) => {
    if(!window.sbBuildOverlayMarks){ toast('โมดูล overlay ยังไม่พร้อม (ocr-overlay.jsx)'); return false; }
    if(!codes.length){ toast(`ยังไม่มีรหัสงาน${th}จากผลถอด — วาง marker ไม่ได้`); return false; }
    setOverlayBusy(true); setOverlayMsg('เริ่ม…');
    try{
      const accessToken = window.getAccessTokenFast ? await window.getAccessTokenFast() : null;   // เฟส C: อ่านวงด้วย Claude ผ่าน Edge Function
      const res = await window.sbBuildOverlayMarks({
        storagePath, codes, pages:(pages.length?pages:undefined), accessToken, projectId: project && project.id,
        onProgress:({msg})=>setOverlayMsg(msg||'') });
      const merged = { ...(base||{}) };
      Object.entries(res.marks||{}).forEach(([p,ms])=>{ merged[p] = [...(merged[p]||[]), ...ms]; });
      saveMarks(merged);
      const st=res.stats||{};
      const firstPage = Object.keys(merged).map(Number).sort((a,b)=>a-b)[0];
      if(firstPage && !base) setPage(firstPage);
      const aiNote = st.aiFail ? ' · ‼️AI อ่านวงล้ม ใช้ Tesseract แทน' : (st.aiUsed ? ' · AI อ่านวง ✓' : '');
      toast(`วาง marker งาน${th}แล้ว — พบ ${st.codesFound||0}/${st.codesTarget||0} รหัส (ป้าย ${st.textHits||0} · วง ${st.circHits||0})${st.cvOk===false?' · ‼️OpenCV ล้ม เฉพาะป้ายข้อความ':aiNote}`, 'pin');
      return true;
    }catch(e){ console.warn('overlay failed:',e); toast('วาง marker ไม่สำเร็จ: '+(e.message||''), 'info'); return false; }
    finally{ setOverlayBusy(false); setOverlayMsg(''); }
  };
  // วางตามตำแหน่งกริดที่ AI บอก ทับเส้นกริดจริงของแบบ (grid-marks.jsx) ในการกดครั้งเดียว
  //   โครงสร้าง: พื้นหล่อ/พื้นสำเร็จ = กรอบช่อง · คาน ("E/1-2") = แถบตามเส้นกริด · ฐานราก/เสา (at "E/1") = กรอบที่จุดตัด
  //   สถาปัตย์: ห้อง (floor_finishes/ceilings grid) = กรอบช่อง · ประตู/หน้าต่าง (at "E/1-2") = จุดกลางช่วงผนัง
  //   วงแดง = ป้ายพื้นในแบบที่ไม่มีแถวในตาราง (AI ข้าม) · กรอบเส้นประ = ช่องพื้นหล่อไม่มีป้าย/หลายป้าย
  //   คืน null = กริดใช้ไม่ได้เลย → ให้ OCR ทั้งหมวดแทน · หมวดที่มีแถวแต่วางไม่ได้สักช่วง → OCR เฉพาะรหัสหมวดนั้นแล้วรวม marker
  //   ผลถอดเก่าที่ไม่มี at/grid ของหมวดเฟส 2 → หมวดนั้นข้ามเงียบ ๆ (ไม่ไล่ OCR เพิ่ม) · สถาปัตย์ไม่มีตำแหน่งเลย → null → OCR เหมือนเดิม
  const runGridMarks = async (d, th) => {
    if(!window.sbBuildGridMarks || !window.sbGridRowsFromSheets) return null;
    const groups = window.sbGridRowsFromSheets(sheetState||{}, d);
    const rowsG = groups.flatMap(g=>g.rows);
    if(!rowsG.length) return null;
    setOverlayBusy(true); setOverlayMsg('เริ่ม…');
    let res = null;
    try{
      // หน้าผังโครงสร้างจาก route_map → ใช้หาหน้าใหม่ให้แถวที่เลขหน้าไม่ตรงผัง (แทนการตกไป OCR ที่ช้ากว่ามาก)
      const candPages = d==='str' ? Object.entries(boqData?.route_map||{}).filter(([p,tags])=>Array.isArray(tags) && tags.includes('struct')).map(([p])=>Number(p)) : [];
      res = await window.sbBuildGridMarks({ storagePath, rows: rowsG, candPages, onProgress:({msg})=>setOverlayMsg(msg||'') });
    }catch(e){ console.warn('grid marks failed:',e); return null; }
    finally{ setOverlayBusy(false); setOverlayMsg(''); }
    const st = res.stats||{};
    if(!st.rects) return null;
    saveMarks(res.marks||{});
    const firstPage = Object.keys(res.marks||{}).map(Number).sort((a,b)=>a-b)[0];
    if(firstPage) setPage(firstPage);
    const by = st.byGroup||{};
    const parts = groups.filter(g=>g.total && (g.legacy || g.rows.length)).map(g=>{ const o = by[g.group]; return `${g.group} ${o ? o.rects : 0}/${o ? o.refs : 0}`; });
    // มีแถวแต่วางไม่ได้สักช่วง (หาเส้นไม่เจอ · เฟส 1 รวมแถวไม่มี grid) → หารหัสในแบบเฉพาะหมวดนั้น
    const failed = groups.filter(g=>g.total && (g.legacy || g.rows.length) && !(by[g.group] && by[g.group].rects) && g.codes.length);
    const notes = [];
    if(st.orphans) notes.push(`ป้ายในแบบที่ไม่มีแถว ${st.orphans} (วงแดง)`);
    if(st.flagged) notes.push(`ให้ดูซ้ำ ${st.flagged} (เส้นประ)`);
    if(st.moved) notes.push(`${st.moved} แถวเลขหน้าไม่ตรงผัง ย้ายไปวางบนผังที่ตรงกัน (ตรวจด้วย)`);
    if(st.unplaced?.length) notes.push(`วางไม่ได้ ${st.unplaced.length}: ${st.unplaced.slice(0,3).join(', ')}${st.unplaced.length>3?'…':''}`);
    if(failed.length) notes.push(`${failed.map(g=>g.group).join('/')} หารหัสในแบบต่อ…`);
    toast(`วาง marker ตามกริดแล้ว — ${parts.join(' · ')}`+(notes.length?' · '+notes.join(' · '):''), 'pin');
    if(failed.length){
      const codes = [...new Set(failed.flatMap(g=>g.codes))];
      const pages = [...new Set(failed.flatMap(g=>(sheetState?.[g.sheet]||[]).map(r=>Number(r && r.page_num)).filter(p=>p>=1)))].sort((a,b)=>a-b);
      await runOcrMarks(codes, pages.length ? pages : discTargets(d).pages, th, res.marks||{});
    }
    return true;
  };
  const [markMenu,setMarkMenu] = useState(false);
  const [markDisc,setMarkDisc] = useState(null);   // หมวดที่วาง marker อยู่ (ติ๊กในเมนู)
  const markMenuRef = useRef(null);
  useEffect(()=>{ if(!markMenu) return;
    const close = (e)=>{ if(markMenuRef.current && !markMenuRef.current.contains(e.target)) setMarkMenu(false); };
    document.addEventListener('mousedown', close);
    return ()=>document.removeEventListener('mousedown', close); }, [markMenu]);
  const runMarksFor = async (d) => {
    setMarkMenu(false);
    if(!storagePath){ toast('ไม่มีแบบจริงสำหรับหน้านี้'); return; }
    const th = (MARK_DISCS.find(x=>x.id===d)||{}).th || '';
    let ok = false;
    if(d==='elec') ok = await runElecMarks();
    else if(d==='sani'){
      const located = !!boqData?.item_marks_located;
      const im = located ? buildItemMarks() : null;
      const canLocate = (Array.isArray(boqData?.item_marks) && boqData.item_marks.length) || saniRows().some(r=>Number(r.page_num)>=1 && Number(r.count)>0);
      // โปรเจกต์ตัวอย่าง: การหาตำแหน่งด้วย AI ผูกกับโปรเจกต์ของผู้ใช้เอง (Edge ตรวจเจ้าของ) → แจ้งแทนการยิงแล้วล้ม
      if(!located && canLocate && project?.__demo) toast('โปรเจกต์ตัวอย่างไม่รองรับการหาตำแหน่งงานสุขาภิบาล — ลองได้ในโปรเจกต์ของคุณเอง', 'info');
      else if(!located && canLocate) ok = await runSaniLocate();
      else if(im) ok = runItemMarks(im);
      else if(located) toast('หาตำแหน่งไว้แล้วแต่ไม่เจอสักตัว — ไม่วาง marker', 'info');
      else {   // ผลถอดก่อนมี item_marks → OCR หารหัสแบบเดิม
        const t = discTargets('sani');
        toast('ผลถอดนี้ยังไม่มีตำแหน่งที่ AI นับ — ใช้การหารหัสในแบบแทน (กดถอดสุขาภิบาลใหม่เพื่อได้กรอบ)', 'info');
        ok = await runOcrMarks(t.codes, t.pages, th);
      }
    } else if(d==='str' || d==='arch'){
      const r = await runGridMarks(d, th);   // ตามกริด (เร็ว/ตรง) · ไม่มีตำแหน่งหรือหาเส้นกริดไม่เจอ → OCR หารหัสแบบเดิม
      if(r==null){ const t = discTargets(d); ok = await runOcrMarks(t.codes, t.pages, th); } else ok = r;
    } else { const t = discTargets(d); ok = await runOcrMarks(t.codes, t.pages, th); }
    if(ok) setMarkDisc(d);
  };

  // (ปุ่ม "ทดสอบ" วาง marker ปลอม 3 จุด ของเฟส A — ถอดออกจากหน้าลูกค้าแล้ว 2026-11-15)

  const selRow = rows.find(r => r.id === sel);
  // ส่ง highlightCode ไป DrawingPlan เฉพาะ row ที่ไม่มี bbox เดิม (AI/Demo rows)
  // row ที่มี bbox อยู่แล้วจะใช้ระบบ .bbox overlay overlay ตามเดิม
  const svgHighlight = useSheets ? selCode : ((selRow && !selRow.bbox) ? selRow.code : null);
  const svgHighlightCat = useSheets ? selCat : ((selRow && !selRow.bbox) ? selRow.cat : null);

  const selectRow = r => {
    setSel(r.id);
    setPage(r.page);
  };
  const selectBox = r => { setSel(r.id); };

  const editQty = (id,val) => {
    const v = val==='' ? '' : Math.max(0, parseFloat(val)||0);
    setRows(rs=>rs.map(r=>r.id===id?{...r,qty:v}:r));
  };
  const commitEdit = () => toast('บันทึกแล้ว ✓');

  const addRow = (data) => {
    setRows(rs=>[...rs,{ id:'n'+Date.now(), bbox:null, page, vol:0, ...data }]);
    setAddOpen(false); toast('เพิ่มรายการแล้ว ✓');
  };
  const doDelete = () => { setRows(rs=>rs.filter(r=>r.id!==delId)); setDelId(null); toast('ลบรายการแล้ว ✓'); };

  const totalRows = rows.reduce((a,r)=>a+(Number(r.qty)||0),0);

  // โปรเจกต์จริงแต่ไม่มีผลถอดให้แสดง (เช่น เปิดจากเครื่องอื่น/ล้างข้อมูลเบราว์เซอร์)
  // → แจ้งตรง ๆ ไม่แสดงข้อมูลตัวอย่างแทนของจริง (ต้องอยู่หลัง hooks ทั้งหมดตามกฎ React)
  if(!isReal && !useSheets && !project?.__demo){
    return (
      <div className="content scrollthin" style={{display:'flex',alignItems:'center',justifyContent:'center'}}>
        <div className="card" style={{maxWidth:500,width:'100%',padding:'40px 36px',textAlign:'center'}}>
          <div className="eic" style={{margin:'0 auto 16px'}}><Icon name="search" size={26}/></div>
          <div style={{fontSize:17,fontWeight:600}}>ไม่พบข้อมูลผลถอดปริมาณ</div>
          <div style={{fontSize:13.5,color:'var(--ink-3)',marginTop:8,lineHeight:1.7}}>
            ผลถอดถูกเก็บไว้ในเครื่อง/เบราว์เซอร์ที่ใช้ถอด — หากเปลี่ยนเครื่องหรือล้างข้อมูลเบราว์เซอร์ ข้อมูลจะไม่ติดมา<br/>
            กรุณาถอดปริมาณใหม่จากไฟล์แบบเดิม
          </div>
          {onBack && <button className="btn btn-primary" style={{marginTop:22}} onClick={onBack}>กลับหน้าแดชบอร์ด</button>}
        </div>
      </div>
    );
  }

  return (
    <div className="content flush">
      {/* top toolbar */}
      <div className="res-toolbar" style={{padding:'7px 22px',display:'flex',alignItems:'center',gap:14,flexWrap:'wrap'}}>
        <div style={{marginLeft:0}}>
          <div style={{fontWeight:600,fontSize:16,display:'flex',alignItems:'center',gap:8}}>
            ผลลัพธ์ปริมาณงาน
          </div>
          <div style={{fontSize:12.5,color:'var(--ink-3)'}}>{project.name}</div>
        </div>
        {/* ‼️ ชิปหมวดย้ายไปบรรทัดแยกใต้ทูลบาร์ (เดิมเบียดกับหัวข้อ/ปุ่มบนแถวเดียว) */}
        <div style={{marginLeft:'auto',display:'flex',gap:10,alignItems:'center'}}>
          <div className="viewseg">
            <button className={viewMode==='split'?'on':''} onClick={()=>setViewMode('split')} title="แบบซ้าย · ตารางขวา (ลากเส้นกลางปรับได้)"><Icon name="panel" size={15}/></button>
            <button className={viewMode==='table'?'on':''} onClick={()=>setViewMode('table')} title="ตารางปริมาณวัสดุอย่างเดียว (ซ่อนแบบ)"><Icon name="table" size={15}/></button>
            <button className={viewMode==='drawing'?'on':''} onClick={()=>setViewMode('drawing')} title="แบบอย่างเดียว (เต็มจอ · Ctrl+ล้อเมาส์ซูม · ลากเพื่อเลื่อน)"><Icon name="file" size={15}/></button>
          </div>
          {viewMode!=='drawing' && useSheets && !showLegend && (
            <div className="viewseg textseg">
              <button className={summary?'on':''} onClick={()=>switchMode(true)} title="ยอดหลักรายหมวด · กดหมวดเพื่อดู/แก้ไขเฉพาะช่องที่กรอก">สรุป</button>
              <button className={!summary?'on':''} onClick={()=>switchMode(false)} title="ตารางทุกคอลัมน์ รวมช่องที่ระบบคำนวณ (ƒ)">ตารางเต็ม</button>
            </div>
          )}
          {viewMode!=='drawing' && useSheets && !showLegend && !summary && (
            <button className={'btn '+(hideDerived?'btn-primary':'btn-soft')} onClick={()=>setHideDerived(v=>!v)}
              title={hideDerived?'แสดงคอลัมน์ที่คำนวณอัตโนมัติ (ƒ)':'ซ่อนคอลัมน์ที่คำนวณอัตโนมัติ (ƒ) ให้ตารางสั้นลง'}>
              <Icon name="filter" size={16}/> {hideDerived?'แสดงคอลัมน์ ƒ':'ซ่อนคอลัมน์ ƒ'}
            </button>
          )}
          {viewMode!=='drawing' && useSheets && !showLegend && !summary && (
            <button className={'btn '+(showEmptyCols?'btn-primary':'btn-soft')} onClick={()=>setShowEmptyCols(v=>!v)}
              title={showEmptyCols?'ซ่อนช่องว่างกลับ (B2/กริด/คอลัมน์เสริมที่ไม่มีข้อมูล)':'แสดงช่องที่ซ่อนอยู่ (B2/กริด/คอลัมน์เสริม) ไว้กรอกข้อมูลเพิ่ม'}>
              <Icon name={showEmptyCols?'eyeOff':'eye'} size={16}/> {showEmptyCols?'ซ่อนช่องว่าง':'แสดงช่องที่ซ่อน'}
            </button>
          )}
          {viewMode!=='drawing' && useSheets && !showLegend && (()=>{
            // หมวดที่ยัง "เพิ่มได้" = หมวดที่ยังไม่โผล่ในผลลัพธ์ + เป็นหมวดที่กรอกในตารางได้ (มี SB_CAT_SHEETS)
            const shownSet = new Set(sheetGroups.map(g=>g.cat));
            const addable = cats.filter(c=>!shownSet.has(c) && SB_CAT_SHEETS[c]);
            return (
              <div style={{position:'relative'}}>
                <button className="btn btn-soft" onClick={()=>setAddCatOpen(v=>!v)}
                  title="เพิ่มหมวดงานที่ยังไม่มีในผลลัพธ์ (AI ไม่เจอ/ไม่ได้เลือก) แล้วกรอกเอง">
                  <Icon name="plus" size={16}/> เพิ่มหมวด
                </button>
                {addCatOpen && (
                  <>
                    <div onClick={()=>setAddCatOpen(false)} style={{position:'fixed',inset:0,zIndex:40}}/>
                    <div className="card" style={{position:'absolute',top:'calc(100% + 6px)',right:0,zIndex:41,minWidth:220,maxHeight:340,overflowY:'auto',padding:6,boxShadow:'0 10px 30px rgba(0,0,0,.16)'}}>
                      {addable.length===0
                        ? <div style={{padding:'10px 12px',fontSize:12.5,color:'var(--ink-3)'}}>ทุกหมวดถูกแสดงแล้ว</div>
                        : addable.map(c=>(
                          <button key={c}
                            onClick={()=>{ setAddedCats(a=>a.includes(c)?a:[...a,c]); setOpenG(o=>({...o,[c]:true})); setCatF('all'); setAddCatOpen(false); toast('เพิ่มหมวด '+c+' แล้ว — กรอกข้อมูลได้เลย ✓'); }}
                            style={{display:'flex',alignItems:'center',gap:9,width:'100%',padding:'9px 11px',border:'none',background:'none',cursor:'pointer',fontSize:13.5,textAlign:'left',borderRadius:7,color:'var(--ink-1)'}}
                            onMouseEnter={e=>e.currentTarget.style.background='var(--surface-2)'}
                            onMouseLeave={e=>e.currentTarget.style.background='none'}>
                            <span style={{width:9,height:9,borderRadius:3,background:CAT_COLOR[c],flex:'0 0 auto'}}></span>{c}
                          </button>
                        ))}
                    </div>
                  </>
                )}
              </div>
            );
          })()}
          {viewMode!=='drawing' && (
            <div className="search" style={{padding:'9px 14px',width:280}}>
              <Icon name="search" size={16}/>
              <input value={search} onChange={e=>setSearch(e.target.value)} placeholder="ค้นหารหัสหรือชื่อรายการ…"/>
            </div>
          )}
          {viewMode!=='drawing' && !useSheets && <button className="btn btn-soft" onClick={()=>setAddOpen(true)}><Icon name="plus" size={16}/> เพิ่มรายการ</button>}
        </div>
      </div>

      {/* ── แถวหมวด (แยกจากทูลบาร์ → ไม่เบียดกับหัวข้อ/ปุ่ม) ── */}
      {/* ‼️ flex:'0 0 auto' บังคับทับ .chips-1row{flex:1} — ที่นี่เป็นลูกของ .content.flush (flex คอลัมน์)
          ถ้าปล่อย flex:1 แถวจะยืดสูงกินพื้นที่ + align-items:center ดันชิปไปกลาง = ช่องว่างใหญ่ (เคสเดียวกับ styles.css:643) */}
      {viewMode!=='drawing' && (
      <div className="chips scrollthin chips-1row res-chips" style={{flex:'0 0 auto',padding:'7px 22px'}}>
        <button className={'chip '+(catF==='all'?'active':'')} onClick={()=>setCatF('all')}>
          {(summary && useSheets) ? 'สรุป' : 'ทั้งหมด'}<span className="ct">{useSheets ? sheetTotalCount : rows.length}</span>
        </button>
        {cats.map(c=>{
          const n = useSheets ? sheetCatCount(c) : rows.filter(r=>r.cat===c).length;
          if(!n) return null;
          const miss = useSheets ? (qtyIss.byCat[c]||0) : 0;
          return <button key={c} className={'chip '+(catF===c?'active':'')} onClick={()=>setCatF(c)}
            title={miss ? `ยังไม่มีปริมาณ ${miss} รายการ — กรอกหรือลบแถวก่อนยืนยัน` : undefined}>
            {/* หมวดที่ยังมีแถวไม่มีปริมาณ → จุดสีหมวดเรืองแสง (สีเดียวกับหมวด) จนกว่าจะแก้ครบ */}
            <span className={miss ? 'cat-dot glow' : 'cat-dot'} style={{background:CAT_COLOR[c], '--dc':CAT_COLOR[c]}}></span>{c}<span className="ct">{n}</span>
          </button>;
        })}
        {legendRows.length>0 && (
          <button className={'chip '+(showLegend?'active':'')} onClick={()=>setCatF('__legend__')}
            title="ตารางสัญลักษณ์ที่ SwiftBill อ่านได้ — ใช้รีเช็คกับแบบจริง">
            <Icon name="info" size={12}/>สัญลักษณ์ในแบบ<span className="ct">{legendRows.length}</span>
          </button>
        )}
      </div>
      )}

      {/* ── แถบเตือนข้อมูลไม่ครบ (ผลลัพธ์ถูกตัดเพราะแบบยาว/ซับซ้อน) ── */}
      {partialWarning && warnOpen && (
        <div className="res-warn" style={{padding:'11px 22px',
          display:'flex',alignItems:'flex-start',gap:12,fontSize:13,color:'#92400e',lineHeight:1.6}}>
          <span style={{fontSize:16,flex:'0 0 auto'}}>⚠️</span>
          <div style={{flex:1}}>
            <b>ข้อมูลบางส่วนอาจไม่ครบ</b> — {partialWarning}
          </div>
          <button className="btn btn-ghost btn-sm" style={{flex:'0 0 auto',color:'#92400e'}}
            onClick={()=>setWarnOpen(false)}>ปิด</button>
        </div>
      )}

      <div className="split" ref={splitRef}>
        {viewMode!=='table' && (<>
        {/* LEFT: drawing viewer */}
        <div className="split-l">
          <div className="viewer-bar">
            <span className="vt"><Icon name="file" size={15} style={{verticalAlign:'-3px',marginLeft:4}}/> {hasPdf ? (curPageRef ? `แบบ ${curPageRef}` : `แบบ (หน้า ${page})`) : `แบบ S-0${page} · โครงสร้าง`}</span>
            <div style={{marginLeft:'auto'}}></div>
            {hasPdf && (<>
              <div ref={markMenuRef} style={{position:'relative',marginLeft:8}}>
                <button className="btn btn-soft btn-sm" disabled={overlayBusy} onClick={()=>setMarkMenu(o=>!o)}
                  title="วาง marker อัตโนมัติ — เลือกหมวดงาน">
                  {overlayBusy
                    ? <><span className="spin" style={{width:13,height:13}}></span> {overlayMsg||'กำลังวาง…'}</>
                    : <><Icon name="pin" size={14}/> วาง marker{markDisc ? ` · ${(MARK_DISCS.find(x=>x.id===markDisc)||{}).th}` : ' อัตโนมัติ'}
                        <Icon name="chevD" size={13} style={{marginRight:-2,opacity:.7}}/></>}
                </button>
                {markMenu && (
                  <div className="cfm-menu">
                    <div className="cfm-head">วาง marker หมวดงาน</div>
                    {MARK_DISCS.map(o=>(
                      <button key={o.id} className="cfm-item" disabled={!discRowCount[o.id]} onClick={()=>runMarksFor(o.id)}
                        title={discRowCount[o.id] ? `วาง marker งาน${o.th} (แทนที่ marker เดิม)` : `ผลถอดนี้ไม่มีงาน${o.th}`}>
                        <span className="cfm-l">{markDisc===o.id ? <Icon name="check" size={13}/> : <span style={{width:13,display:'inline-block'}}></span>}{o.th}</span>
                        <span className="cfm-n">{discRowCount[o.id]||0}</span>
                      </button>
                    ))}
                  </div>
                )}
              </div>
            </>)}
            <div className="zoomctl">
              <button onClick={()=>zoomBy(1/1.25)} title="ซูมออก"><Icon name="zoomOut" size={16}/></button>
              <span className="zv" onClick={resetZoom} style={{cursor:'pointer'}} title="คลิกเพื่อรีเซ็ตเป็น 100%">{Math.round(zoom*100)}%</span>
              <button onClick={()=>zoomBy(1.25)} title="ซูมเข้า"><Icon name="zoomIn" size={16}/></button>
            </div>
          </div>
          <div className="viewer-stage scrollthin" ref={stageRef}
            onMouseDown={onStageDown}>
            {/* ‼️ ห้ามใช้ transform:scale ลอย ๆ — transform ไม่ทำให้กล่อง layout โต (เนื้อหาล้นไปทางซ้าย/บนที่เลื่อนไปไม่ถึง = ซูมแล้ว pan ไม่ได้)
                · PDF จริง: zoom จัดการใน PdfDrawing (canvas ขนาดจริง → กล่องโต)
                · placeholder (SVG 720×540): ให้ .drawing กว้าง/สูงตามซูมเอง แล้ว scale เนื้อในจากมุมซ้ายบน */}
            <div className="drawing" style={hasPdf ? undefined : {width:720*zoom,height:540*zoom}}>
              {hasPdf
                ? <PdfDrawing storagePath={storagePath} page={page} zoom={zoom} stageRef={stageRef} onNumPages={setNumPages} onError={(e)=>console.warn('pdf load error:',e?.message||e)}
                    marks={marks[page]||[]} highlightCode={svgHighlight} onMarkClick={onMarkClick}/>
                : <div style={{width:720,height:540,transform:`scale(${zoom})`,transformOrigin:'0 0'}}>
                    <DrawingPlan page={page} highlightCode={svgHighlight} highlightCat={svgHighlightCat}/>
                  </div>}
              {pageBoxes.map(r=>(
                <div key={r.id} className={'bbox '+(sel===r.id?'on':'')}
                  style={{left:r.bbox.x+'%',top:r.bbox.y+'%',width:r.bbox.w+'%',height:r.bbox.h+'%'}}
                  onClick={()=>{ if(draggedRef.current) return; selectBox(r); }} title={r.code+' · '+r.name}>
                  <span className="tag">{r.code}</span>
                </div>
              ))}
            </div>
          </div>
          <div className="pagebar">
            {/* ‼️ pill ตำแหน่งคงที่: ปุ่มติดขอบกลุ่ม · ป้ายกลาง min-width คงที่ → เปลี่ยนหน้าแล้วปุ่มไม่ขยับ (ก่อนหน้านี้ justify-center + span กว้างไม่เท่า ทำปุ่มเด้ง) */}
            <div className="pagenav">
              <button className="pagenav-btn" disabled={page<=pages[0]} onClick={()=>setPage(p=>Math.max(pages[0],p-1))} title="หน้าก่อนหน้า" aria-label="หน้าก่อนหน้า"><Icon name="chevL" size={17}/></button>
              <div className="pagenav-label">
                {hasPdf
                  ? <>{curPageRef && <span className="sheet">{curPageRef}</span>}<span className="pg">หน้า <input key={page} className="pg-in" type="number" inputMode="numeric" defaultValue={page}
                        min={pages[0]} max={pages[pages.length-1]} title="พิมพ์เลขหน้าแล้วกด Enter" aria-label="เลขหน้า"
                        onFocus={e=>e.target.select()} onKeyDown={e=>{ if(e.key==='Enter') e.target.blur(); if(e.key==='Escape'){ e.target.value=page; e.target.blur(); } }}
                        onBlur={e=>{ const n=parseInt(e.target.value,10); const v=Number.isFinite(n) ? Math.min(pages[pages.length-1], Math.max(pages[0], n)) : page;
                          e.target.value=v;   // ‼️ เขียนค่าที่ปัดแล้วกลับช่องเสมอ — ถ้าปัดแล้วได้หน้าเดิม key ไม่เปลี่ยน ช่องจะค้างเลขที่พิมพ์ผิด
                          if(v!==page) setPage(v); }}/><i>/</i>{numPages||pages.length}</span></>
                  : <><span className="sheet">S-0{page}</span><span className="pg"><b>{pages.indexOf(page)+1}</b><i>/</i>{pages.length}</span></>}
              </div>
              <button className="pagenav-btn" disabled={page>=pages[pages.length-1]} onClick={()=>setPage(p=>Math.min(pages[pages.length-1],p+1))} title="หน้าถัดไป" aria-label="หน้าถัดไป"><Icon name="chevR" size={17}/></button>
            </div>
          </div>
        </div>

        {/* draggable divider (เฉพาะโหมดซ้าย-ขวา) */}
        {viewMode==='split' && <div className="gutter" onMouseDown={startDrag} title="ลากเพื่อปรับขนาด"><span className="grip"></span></div>}
        </>)}

        {/* RIGHT: quantity table */}
        {/* โหมดแบบอย่างเดียว: ซ่อนด้วย display:none (ไม่ unmount) → ค่าที่กำลังแก้ในตารางไม่หาย */}
        <div className="split-r" style={{width: viewMode==='split' ? rightW+'%' : '100%', display: viewMode==='drawing' ? 'none' : undefined}}>
          <div className="qbody scrollthin" ref={qbodyRef}>
           {/* ‼️ qbwrap = width:max-content → ทุกบล็อก (เสา/คาน...) กว้างเท่ากับบล็อกที่กว้างสุด
               กันที่ว่างด้านขวา/เลื่อนเข้าที่ว่าง เวลาซ่อนคอลัมน์แล้วบล็อกกว้างไม่เท่ากัน
               (ไม่มี overflow → sticky header ยังยึด .qbody ปกติ) */}
           <div className="qbwrap">
            {/* ── แท็บสัญลักษณ์ในแบบ (legend) — ตารางที่ AI อ่านได้ ไว้รีเช็คกับแบบจริง ── */}
            {showLegend && (
              <div style={{padding:'12px 14px'}}>
                <div style={{fontSize:12.5,color:'var(--ink-3)',lineHeight:1.6,marginBottom:12,display:'flex',gap:8,alignItems:'flex-start'}}>
                  <Icon name="info" size={14} style={{flex:'0 0 auto',marginTop:2}}/>
                  <span>ตารางสัญลักษณ์/รายการประกอบแบบ ที่ SwiftBill อ่านได้ — ใช้ <b>รีเช็คกับแบบจริง</b>: ถ้า “สเปกตามแบบ” ไม่ตรงแบบ = SwiftBill แต่งเอง โปรดแก้ในตารางหมวดนั้น · รายการที่นับในผังไม่เจอจะถูกเติมแถว count 0 พร้อมตีธงในหมวดของมัน</span>
                </div>
                <div className="legendtbl" style={{overflowX:'auto'}}>
                  <table className="qtable">
                    <thead><tr>
                      <th style={{whiteSpace:'nowrap'}}>รหัส/สัญลักษณ์</th>
                      <th>ความหมายตามแบบ</th>
                      <th>สเปกตามแบบ (คำต่อคำ)</th>
                      <th style={{whiteSpace:'nowrap'}}>หมวด</th>
                      <th style={{whiteSpace:'nowrap'}}>แผ่น</th>
                    </tr></thead>
                    <tbody>
                      {legendRows.map((r,i)=>(
                        <tr key={(r.code||'')+'-'+i} className="qrow">
                          <td className="code" style={{fontWeight:600,whiteSpace:'nowrap'}}>{r.code||'-'}</td>
                          <td>{r.meaning||'-'}</td>
                          <td style={{color:'var(--ink-3)'}}>{r.spec||'-'}</td>
                          <td style={{whiteSpace:'nowrap',color:'var(--ink-3)'}}>{(SB_SHEET_COLS[r.sheet_key]?.label)||r.sheet_key||'-'}</td>
                          <td style={{whiteSpace:'nowrap',color:'var(--ink-3)'}}>{r.page_ref||'-'}</td>
                        </tr>
                      ))}
                    </tbody>
                  </table>
                </div>
              </div>
            )}
            {!showLegend && useSheets && dirty && (
              <div style={{padding:'8px 14px',fontSize:12,display:'flex',alignItems:'center',gap:8,borderBottom:'1px solid var(--border)'}}>
                <span className="badge b-orange" style={{fontSize:11}}>มีการแก้ไขรายการ — ระบบจะใช้ค่าล่าสุดในไฟล์ Excel เมื่อยืนยันปริมาณ</span>
              </div>
            )}
            {/* ── โหมด sheet: คอลัมน์ตรงกับ Excel ── */}
            {!showLegend && useSheets && visSheetGroups.length===0 &&
              <div className="empty"><div className="eic"><Icon name="search" size={26}/></div><div>ไม่พบรายการที่ตรงกับการค้นหา</div></div>}
            {!showLegend && useSheets && summary && catF==='all' && !search && (()=>{
              const tops = sbTopTotals(sheetState);
              return tops.length>0 && (
                <div className="sum-cards">
                  {tops.map(c=>(
                    <div className="sum-card" key={c.label}>
                      <div className="sl">{c.label}</div>
                      <div className="sv">{fmt(c.v,c.dec)} <span>{c.unit}</span></div>
                    </div>
                  ))}
                </div>
              );
            })()}
            {!showLegend && useSheets && visSheetGroups.map(g=>(
              <div className="acc" key={g.cat} data-acc={g.cat}>
                <div className={'acc-head '+(accOpen(g.cat)?'open':'')} onClick={()=>accClick(g.cat)}>
                  <span className="acc-cat" style={{background:g.color}}></span>
                  <span className="nm">{g.cat}</span>
                  {(()=>{
                    const sm = summary ? sbCatSummary(g) : [];
                    if(!sm.length) return summary ? <span className="ct" style={{flex:1}}>{g.count} รายการ</span> : <span className="ct">{g.units} หน่วย · {g.count} รายการ</span>;
                    return <span className="acc-sum">{sm.map((x,i)=>(
                      <React.Fragment key={i}>{i>0 && ' · '}{x.label && x.label+' '}<b>{fmt(x.v,x.dec)}</b> {x.unit}</React.Fragment>
                    ))}</span>;
                  })()}
                  {g.missing && (addedCats.includes(g.cat)
                    ? <span className="badge" style={{fontSize:11,background:'#e0e7ff',color:'#3730a3'}}>เพิ่มเอง</span>
                    : <span className="badge b-orange" style={{fontSize:11}}>AI ไม่พบในแบบ</span>)}
                  {qtyIss.byCat[g.cat]>0 && <span className="badge qty-miss-badge" title="ช่องที่เรืองแสงสีส้ม = ต้องกรอกปริมาณ (หรือลบแถวถ้าไม่มีงานนี้จริง)">ไม่มีปริมาณ {qtyIss.byCat[g.cat]} รายการ</span>}
                  {!summary && g.vol>0 && <span className="vol">รวม {fmt(g.vol,2)} ลบ.ม.</span>}
                  <Icon name="chevR" size={16} className="chev"/>
                </div>
                {accOpen(g.cat) && g.missing && (
                  <div style={{margin:'8px 14px',padding:'9px 12px',borderRadius:8,background:'var(--warn-bg,#fff7ed)',border:'1px solid var(--warn-bd,#fed7aa)',fontSize:12.5,color:'var(--ink-2)',display:'flex',gap:8,alignItems:'flex-start',lineHeight:1.5}}>
                    <Icon name="info" size={15}/>
                    <span>{addedCats.includes(g.cat)
                      ? <>หมวดที่<b>เพิ่มเอง</b> — ยังไม่มีข้อมูล กด <b>“เพิ่มแถว”</b> ด้านล่างเพื่อกรอกรายการ (ค่าจะไหลไป Excel เมื่อยืนยัน)</>
                      : <>คุณเลือกหมวดนี้ไว้ แต่ AI ถอดปริมาณ<b>ไม่พบในแบบ</b> — โปรดตรวจว่าแบบมีงานหมวดนี้จริงหรือไม่ ถ้ามี กด <b>“เพิ่มแถว”</b> ด้านล่างเพื่อกรอกเอง</>}</span>
                  </div>
                )}
                {accOpen(g.cat) && g.blocks.map(b=>{
                  // ซ่อนคอลัมน์ ƒ (derived) เมื่อผู้ใช้กดซ่อน — ให้ตารางสั้นลง (ค่ายังคำนวณ/ไหลไป Excel ปกติ)
                  // + auto-ซ่อนคอลัมน์ที่ไม่เกี่ยว/ว่างทั้งคอลัมน์ ให้ตารางสบายตา:
                  //   · B2 บน (m) = ใช้เฉพาะฐานรากคางหมู/สามเหลี่ยมตัดมุม → ไม่มีแถวคางหมู (และไม่มีค่า) = ซ่อน
                  //   · ตำแหน่ง (กริด) = ถ้าทุกแถวว่าง = ซ่อน (ครอบ เสา/คาน/พื้น/สุขาภิบาล ด้วย label เดียวกัน)
                  const cols = ((summary||hideDerived) ? b.cols.filter(c=>!c.derived || c.mainTab) : b.cols).filter(c=>{
                    if(showEmptyCols) return true;   // กด "แสดงช่องที่ซ่อน" → โชว์ทุกคอลัมน์ (ไว้กรอกข้อมูลในช่องที่ปกติซ่อน)
                    if(c.k==='B2') return b.rows.some(r=> /trap|คางหมู|ตัดมุม/i.test(String(r.shape||'')) || String(sbRaw(r,c)).trim()!=='');
                    // กริด (จับด้วย label ครอบทุกหมวด) + คอลัมน์เสริม/ตามชนิด → ซ่อนเมื่อว่างทั้งคอลัมน์
                    if(c.label==='ตำแหน่ง (กริด)' || SB_AUTOHIDE_EMPTY.has(c.k)) return b.rows.some(r=> String(sbRaw(r,c)).trim()!=='');
                    return true;
                  });
                  // แท็บกลุ่มคอลัมน์ (table right) — ตารางกว้างแตกเป็นแท็บ: ขนาด&จำนวน / รายละเอียด / เหล็ก / ผลคำนวณ
                  const tabs = sbGroupCols(cols);
                  const active = tabs.find(t=>t.id===(colTab[b.key]||(tabs[0]&&tabs[0].id))) || tabs[0];
                  const dcols = active ? active.cols : cols;
                  // คีย์ช่องที่ต้องเรืองแสงในบล็อกนี้ — ใช้ติดจุดส้มที่แท็บ (ช่องอาจอยู่แท็บที่ไม่ได้เปิด)
                  const missKeys = new Set();
                  b.rows.forEach(r=>{ const ks = qtyIss.byRow[r._sk+'-'+r._idx]; if(ks) ks.forEach(k=>missKeys.add(k)); });
                  return (
                  <div key={b.key}>
                    {b.label && <div style={{padding:'8px 14px 2px',fontSize:12.5,fontWeight:600,color:'var(--ink-3)'}}>{b.label}</div>}
                    {tabs.length>1 && (
                      <div className="col-tabs">
                        {tabs.map(t=>(
                          <button key={t.id} className={'col-tab'+(active.id===t.id?' active':'')}
                            onClick={()=>setColTab(m=>({...m,[b.key]:t.id}))}>
                            {t.label}<span className="ct">{t.cols.length-1}</span>
                            {t.cols.some(c=>missKeys.has(c.k)) && <span className="miss-dot" title="แท็บนี้มีช่องที่ต้องกรอกปริมาณ"></span>}
                          </button>
                        ))}
                      </div>
                    )}
                    <div className="qtwrap">
                      <table className="qtable">
                        <thead><tr>{dcols.map(c=><th key={c.k} style={{textAlign:c.num||c.int?'right':'left',whiteSpace:'nowrap'}}>{c.label}{c.derived?<span title="คำนวณอัตโนมัติ" style={{color:'var(--primary)',marginLeft:3}}>ƒ</span>:''}</th>)}{b.editable && <th style={{width:58}}></th>}</tr></thead>
                        <tbody>
                          {b.rows.map((r,ri)=>(
                            // ‼️ key คงที่ตามตำแหน่งข้อมูล (_sk+_idx) — ห้ามผูกกับ r.code เพราะแก้รหัสแล้ว key เปลี่ยน → remount → โฟกัสหลุด
                            <tr key={r._sk+'-'+r._idx} className={'qrow '+(selCode!=null&&selCode===(r.code||r.room)&&selCat===g.cat?'on':'')}
                              onClick={()=>selectSheetRow(g.cat, r.code)}>
                              {dcols.map((c,ci)=>{
                                const na = !!(c.naIf && c.naIf(r));
                                const lock = !!(c.lockIf && c.lockIf(r));   // คิดอัตโนมัติได้ (เช่น rebar_kg ฐานราก/บันไดที่อ่านสเปกได้) → ล็อกเหมือน derived
                                const editable = b.editable && !c.derived && !na && !lock;
                                // alignR = ช่องย่อยเหล็ก (จำนวน/@) — ชิดขวาเหมือนตัวเลข แต่ยัง type=text
                                // ‼️ จำนวนเส้นพิมพ์ "5+5" ได้ และระยะพิมพ์ "0.15" ลื่นกว่าเมื่อไม่ใช่ number input
                                const alignNum = c.num||c.int||c.alignR;
                                const numInput = !!(c.num||c.int);
                                const val = c.steelPart
                                  ? sbSteelSplit(addSteelType(sbBaseRaw(r,c)), c.steelMode)[c.steelPart]
                                  : (c.steel ? addSteelType(sbRaw(r,c)) : sbRaw(r,c));
                                const inner = editable
                                  ? (c.opts
                                      // คอลัมน์ที่มีตัวเลือกตายตัว (เช่น ชนิดคาน) = ดรอปดาวน์จาก c.opts
                                      ? <select className="cell-edit cell-sel" value={val||''}
                                          onChange={e=>editCell(r._sk,r._idx,c,e.target.value)}
                                          onFocus={()=>selectSheetRow(g.cat, r.code)}>
                                          {c.opts.map(o=><option key={o.v} value={o.v}>{o.t}</option>)}
                                          {val!=null && val!=='' && !c.opts.some(o=>String(o.v)===String(val)) && <option value={val}>{val}</option>}
                                        </select>
                                      : c.steelPart==='d'
                                      // ช่อง "ขนาด/ปลอก" = ดรอปดาวน์เหล็กมาตรฐาน (ค่าเดิมที่ไม่อยู่ในลิสต์ เช่น Ø/WIREMESH เก็บเป็นตัวเลือกท้าย)
                                      ? <select className="cell-edit cell-sel" value={val||''}
                                          onChange={e=>editCell(r._sk,r._idx,c,e.target.value)}
                                          onFocus={()=>selectSheetRow(g.cat, r.code)}>
                                          <option value="">—</option>
                                          {SB_REBAR_SIZES.map(s=><option key={s} value={s}>{s}</option>)}
                                          {val && !SB_REBAR_SIZES.includes(val) && <option value={val}>{val}</option>}
                                        </select>
                                      : c.secList
                                      // ช่อง "หน้าตัด" เหล็กรูปพรรณ = พิมพ์ได้ + datalist แนะนำจากตารางน้ำหนักเหล็ก (เลือกตามที่พิมพ์)
                                      ? <SbCombo className="cell-sec" value={val} options={sbSectionOptions} onChange={v=>editCell(r._sk,r._idx,c,v)} onFocus={()=>selectSheetRow(g.cat, r.code)}/>
                                      : c.coverList
                                      ? <SbCombo className="cell-sec" value={val} placeholder="เลือกผืน" options={()=>['ทั้งหมด', ...new Set(((sheetState&&sheetState.roof)||[]).map(x=>String((x&&x.code)||'').trim()).filter(Boolean))]} onChange={v=>editCell(r._sk,r._idx,c,v)} onFocus={()=>selectSheetRow(g.cat, r.code)}/>
                                      : (!numInput && !c.steelPart)
                                      // ช่องตัวอักษร (ชนิด/วัสดุ/หมายเหตุ) = textarea ตัดบรรทัด · ค่ายาว wrap เห็นครบ
                                      ? <textarea className={'cell-edit cell-text'+(c.wide?' wide':'')} rows={1}
                                          value={val} onChange={e=>editCell(r._sk,r._idx,c,e.target.value)}
                                          onFocus={()=>selectSheetRow(g.cat, r.code)}/>
                                      : <input className={'cell-edit'+(alignNum?' num':'')} type={numInput?'number':'text'}
                                          inputMode={c.steelPart==='n'?'numeric':undefined}
                                          value={val} onChange={e=>{
                                            // ช่องจำนวนเส้น (steelPart 'n') รับแค่ตัวเลข + "+" (เผื่อ "5+5") — กันตัวอักษรหลุดเข้า
                                            const v = c.steelPart==='n' ? e.target.value.replace(/[^\d+]/g,'') : e.target.value;
                                            editCell(r._sk,r._idx,c,v);
                                          }}
                                          onFocus={()=>selectSheetRow(g.cat, r.code)}/>)
                                  : na
                                    ? <input className="cell-edit num" value="-" readOnly tabIndex={-1} title="ไม่ใช้กับรายการนี้"
                                        style={{color:'var(--ink-3)',background:'#f8fafc',cursor:'not-allowed',textAlign:'center'}}/>
                                  : (c.derived || lock)
                                    ? <span className="cell-derived" title={lock?'คำนวณอัตโนมัติจากสเปกเหล็ก — แก้สเปกเพื่อเปลี่ยน (อ่านสเปกไม่ได้เมื่อไหร่ช่องนี้จะเปิดให้กรอกเอง)':'คำนวณอัตโนมัติจากสูตร'}>{sbCell(r,c)}</span>
                                    : (c.steelPart ? (val||'-') : sbCell(r,c));
                                // ‼️ คอลัมน์แรก (รหัส): ถ้ารหัสเป็น "ป้ายจากแบบที่ไม่สื่อความหมาย" (ขึ้นต้น [ / ตัวเลข / +ระดับ
                                //    เช่น "[1]+0.10") → โชว์ชื่อที่อ่านได้เป็นหลัก แล้ววางรหัสเป็นตัวเล็กอ้างอิงไว้ใต้ (ยังแก้ค่าได้)
                                //    รหัสจริงที่ขึ้นต้นตัวอักษร (B2/DL/F1/SS) ไม่เข้าเงื่อนไข → เรนเดอร์ปกติ ไม่กระทบสายอื่น
                                const codeStr = String(r.code||'').trim();
                                // ชื่อที่อ่านได้ = ชนิด + (การติดตั้ง/ตำแหน่ง) เช่น "หลอดประหยัด LED TUBE (ติดผนัง)"
                                const nm0 = String(r.type||r.name||'').trim();
                                // ‼️ ตัด (การติดตั้ง/ตำแหน่ง) ทิ้งถ้าชีตนี้มีคอลัมน์ของค่านั้นอยู่แล้ว — ซ้ำ ทำให้ช่องรหัสยาวเกิน
                                //    (เจ้าของ 2026-10-07: "(ห้องน้ำ1, ห้องน้ำ2…)" ในรหัสไม่ต้องมี เพราะมีคอลัมน์ตำแหน่งแล้ว)
                                const qualKey = r.mount ? 'mount' : 'location';
                                const qualShown = b.cols.some(c=>c.k===qualKey);
                                const qual0 = qualShown ? '' : String(r.mount||r.location||'').trim();
                                const readable = (ci===0 && nm0 && nm0!==codeStr)
                                  ? (qual0 && qual0!==nm0 ? nm0+' ('+qual0+')' : nm0) : null;
                                const nameFirst = !!readable && /^[[\d+]/.test(codeStr);
                                // ช่องที่ทำให้แถวนี้ "ไม่มีปริมาณ" → กรอบส้มเรืองแสง (เฉพาะช่องที่แก้ได้)
                                const rowMiss = qtyIss.byRow[r._sk+'-'+r._idx];
                                const needCell = editable && !!(c.needIf && c.needIf(r));   // ช่องที่ผู้ใช้ต้องกรอกเอง (เช่น จำนวนเส้นเมื่อแบบไม่ระบุสเปก)
                                const missCell = (editable && !!rowMiss && rowMiss.has(c.k)) || needCell;
                                return (
                                  <td key={c.k} className={(ci===0?'code':'')+(missCell?' qty-miss':'')}
                                    title={needCell ? (c.needMsg||'กรุณากรอก') : missCell ? 'ยังไม่มีปริมาณ — กรอกค่า หรือลบแถวถ้าไม่มีงานนี้จริง' : undefined}
                                    style={alignNum?{textAlign:'right',whiteSpace:'nowrap'}:{whiteSpace:'normal'}}>
                                    {nameFirst
                                      ? <div><div style={{fontWeight:600,lineHeight:1.35}}>{readable}</div>
                                          {/* รหัส/สัญลักษณ์ตามแบบ = ช่องแก้ได้ (มี label + ไม่จาง เพื่อให้เห็นว่าแก้ได้ · เช่น ประตู-หน้าต่าง) */}
                                          <div style={{marginTop:3,display:'flex',alignItems:'center',gap:5}} title="รหัส/สัญลักษณ์ตามแบบ — แก้ได้">
                                            <span style={{fontSize:10.5,color:'var(--ink-4)',flex:'0 0 auto'}}>รหัส</span>{inner}</div></div>
                                      : inner}
                                  </td>
                                );
                              })}
                              {b.editable && (
                                <td className="row-act" onClick={e=>e.stopPropagation()}>
                                  <button className="ra-btn" title="แตกแถว (คัดลอกแถวนี้ — ใช้แยกคานเป็นหลายช่วง)" onClick={e=>dupSheetRow(r._sk,r._idx,e)}><Icon name="layers" size={14}/></button>
                                  <button className="ra-btn del" title="ลบแถวนี้" onClick={e=>delSheetRow(r._sk,r._idx,e)}><Icon name="trash" size={14}/></button>
                                </td>
                              )}
                            </tr>
                          ))}
                        </tbody>
                      </table>
                    </div>
                    {b.editable && (
                      <div style={{padding:'4px 14px 12px'}}>
                        <button className="add-row-btn" onClick={()=>addSheetRow(b.key)}>
                          <Icon name="plus" size={13}/> เพิ่มแถว{b.label?' ('+b.label+')':''}
                        </button>
                      </div>
                    )}
                  </div>
                  );
                })}
              </div>
            ))}

            {/* ── โหมดเดิม (fallback ไม่มี sheets): items ── */}
            {!showLegend && !useSheets && grouped.length===0 && <div className="empty"><div className="eic"><Icon name="search" size={26}/></div><div>ไม่พบรายการที่ตรงกับการค้นหา</div></div>}
            {!showLegend && !useSheets && grouped.map(g=>{
              const tVol = g.items.reduce((a,r)=>a+r.vol*(Number(r.qty)||0)/(r.qty||1),0);
              const tQty = g.items.reduce((a,r)=>a+(Number(r.qty)||0),0);
              const sumVol = g.items.reduce((a,r)=>a+r.vol,0);
              return (
                <div className="acc" key={g.cat}>
                  <div className={'acc-head '+(openG[g.cat]?'open':'')} onClick={()=>setOpenG(o=>({...o,[g.cat]:!o[g.cat]}))}>
                    <span className="acc-cat" style={{background:CAT_COLOR[g.cat]}}></span>
                    <span className="nm">{g.cat}</span>
                    <span className="ct">{tQty} หน่วย · {g.items.length} รายการ</span>
                    <span className="vol">รวม {fmt(sumVol,2)} ลบ.ม.</span>
                    <Icon name="chevR" size={16} className="chev"/>
                  </div>
                  {openG[g.cat] && (
                    <table className="qtable">
                      <thead><tr>
                        <th>รหัส</th><th>รายการ</th><th>จำนวน</th><th>หน่วย</th><th>ที่มา</th><th></th>
                      </tr></thead>
                      <tbody>
                        {g.items.map(r=>(
                          <tr key={r.id} className={'qrow '+(sel===r.id?'on':'')} onClick={()=>selectRow(r)}>
                            <td className="code">{r.code}</td>
                            <td>{r.name}</td>
                            <td onClick={e=>e.stopPropagation()}>
                              <input className="qedit" value={r.qty} onChange={e=>editQty(r.id,e.target.value)} onBlur={commitEdit}/>
                            </td>
                            <td style={{color:'var(--ink-3)'}}>{r.unit}</td>
                            <td onClick={e=>{e.stopPropagation(); selectRow(r);}}>
                              {r.bbox
                                ? <span className="src">S-0{r.page} ↗</span>
                                : <span className="src" style={{opacity:.7}}>↗ ดูแบบ</span>}
                            </td>
                            <td onClick={e=>e.stopPropagation()}>
                              <div className="rowact">
                                <button className="minibtn" title="ประวัติการแก้ไข" onClick={()=>setAuditId(r.id)}><Icon name="clock" size={15}/></button>
                                <button className="minibtn del" title="ลบ" onClick={()=>setDelId(r.id)}><Icon name="trash" size={15}/></button>
                              </div>
                            </td>
                          </tr>
                        ))}
                      </tbody>
                    </table>
                  )}
                </div>
              );
            })}
           </div>
          </div>

          {/* ‼️ ชิป สมมติฐาน + ค่าใช้จ่าย ย้ายไปอยู่ในแถบยืนยันด้านล่าง (ประหยัดพื้นที่ทำงาน) */}
          {/* assumption body — โผล่เมื่อกดชิป (เด้งขึ้นเหนือแถบยืนยัน) */}
          {drawer && (
            <div className="drawer-body scrollthin">
              {isReal && boqData?.summary?.key_findings && (
                <div className="logline">
                  <span className="tk">🤖</span>
                  <span><span className="em">[SwiftBill]</span> {boqData.summary.key_findings}</span>
                </div>
              )}
              {isReal
                ? rows.filter(r=>r.notes).map((r,i)=>(
                    <div className="logline" key={i}>
                      <span className="tk">📝</span>
                      <span><span className="em">[{r.code}]</span> {r.notes}</span>
                    </div>
                  ))
                : ASSUMPTIONS.map((a,i)=>(
                    <div className="logline" key={i}>
                      <span className="tk">📝</span>
                      <span><span className="em">[{a.tag}]</span> {a.txt}</span>
                    </div>
                  ))}
            </div>
          )}
          {/* cost body — โผล่เมื่อกดชิป */}
          {costOpen && isAdmin && isReal && boqData?.summary?._cost && (
            <CostDrawerBody cost={boqData.summary._cost} />
          )}

          {/* sticky confirm bar — ค่าใช้จ่าย (admin เท่านั้น · ต้นทุน AI ไม่ใช่เรื่องของลูกค้า) / สมมติฐาน / ยืนยัน จัดกลุ่มขวา · บรรทัดนับรายการ/ฉบับ/หน่วยถอดออกแล้ว 2026-11-15 */}
          <div className="confirm-bar">
            <div style={{display:'flex',alignItems:'center',gap:8,marginLeft:'auto'}}>
              {isAdmin && isReal && boqData?.summary?._cost && (
                <button className={'chip '+(costOpen?'active':'')} onClick={()=>setCostOpen(o=>!o)}
                  title="ค่าใช้จ่าย SwiftBill ต่อการถอด 1 ครั้ง (เห็นเฉพาะผู้ดูแลระบบ)">
                  <Icon name="money" size={13}/> ค่าใช้จ่าย {sbBaht(boqData.summary._cost.total_thb)}
                </button>
              )}
              <button className={'chip '+(drawer?'active':'')} onClick={()=>setDrawer(d=>!d)}
                title="สมมติฐานที่ระบบใช้ในการถอดปริมาณ">
                <Icon name="info" size={13}/> สมมติฐาน
                <span className="ct">{isReal ? rows.filter(r=>r.notes).length : ASSUMPTIONS.length}</span>
              </button>
              {/* ยังมีแถวไม่มีปริมาณ → ปุ่มยืนยันกดไม่ได้ (ช่อง/จุดหมวดเรืองแสงบอกที่ต้องแก้แล้ว) */}
              <button className="btn btn-primary" disabled={qtyBlocked}
                title={qtyBlocked ? `ยืนยันไม่ได้ — ยังมี ${qtyIss.total} รายการที่ปริมาณเป็น 0 หรือว่าง` : undefined}
                onClick={()=>{ if(!qtyBlocked) setConfirmOpen(true); }}>ยืนยันปริมาณ <Icon name="arrowR" size={16}/></button>
            </div>
          </div>
        </div>
      </div>

      {/* modals — ‼️ ตารางน้ำหนักเหล็ก (SteelTableModal) เปิดจาก sidebar ที่ระดับ App แล้ว */}
      {addOpen && <AddRowModal cats={cats} onClose={()=>setAddOpen(false)} onAdd={addRow}/>}
      {delId && (
        <Modal title="ลบรายการนี้?" sub="การลบไม่สามารถย้อนกลับได้" onClose={()=>setDelId(null)}
          foot={<><button className="btn btn-ghost" onClick={()=>setDelId(null)}>ยกเลิก</button>
            <button className="btn btn-primary" style={{background:'var(--red)'}} onClick={doDelete}>ลบรายการ</button></>}>
          <div style={{fontSize:14,color:'var(--ink-2)'}}>
            ยืนยันการลบ <b style={{color:'var(--ink)'}}>{rows.find(r=>r.id===delId)?.code} · {rows.find(r=>r.id===delId)?.name}</b> ออกจากรายการปริมาณ
          </div>
        </Modal>
      )}
      {auditId && <AuditModal id={auditId} row={rows.find(r=>r.id===auditId)} onClose={()=>setAuditId(null)}/>}
      {confirmOpen && (
        <Modal title="ยืนยันปริมาณทั้งหมด?" onClose={()=>setConfirmOpen(false)}
          foot={<><button className="btn btn-ghost" onClick={()=>setConfirmOpen(false)}>กลับไปแก้ไข</button>
            <button className="btn btn-primary" onClick={()=>{ setConfirmOpen(false); cancelServerSave(); onConfirm(useSheets ? sheetState : undefined, useSheets ? undefined : rows); }}>ยืนยัน {project.pricing?'→ ประเมินราคา':'→ ส่งออก'}</button></>}>
          <div style={{fontSize:14,color:'var(--ink-2)',lineHeight:1.6}}>
            ยืนยันปริมาณทั้งหมด <b style={{color:'var(--ink)'}}>{rows.length} รายการ</b>?
            หลังยืนยันจะไม่สามารถแก้ไขในขั้นนี้ได้
            {project.pricing
              ? <div style={{marginTop:12}} className="badge b-orange"><Icon name="money" size={13}/> ขั้นต่อไป: ประเมินราคา</div>
              : <div style={{marginTop:12}} className="badge b-green"><Icon name="excel" size={13}/> ขั้นต่อไป: ส่งออกไฟล์</div>}
          </div>
        </Modal>
      )}
    </div>
  );
}

// ── ตารางน้ำหนักหน้าตัดเหล็ก (แก้ไขได้ · เก็บใน localStorage) — เติม น.น./เมตร ให้โครงหลังคา/โครงถักอัตโนมัติ ──
function SteelTableModal({ onClose, onSaved }){
  const [tab,setTab]   = useState('sec');   // 'sec' = หน้าตัด (kg/m) · 'len' = ความยาวเส้นที่สั่ง
  const [rows,setRows] = useState(()=> ((window.STEEL_SECTIONS&&window.STEEL_SECTIONS.rows)||[]).map(r=>({...r})));
  // แท็บความยาว: เก็บเป็น array {k,v} เพื่อให้แก้ชื่อ/เพิ่ม/ลบขนาดได้ (save แปลงกลับเป็น object)
  const [bars,setBars] = useState(()=> {
    const src = window.SB_BARLEN||{};
    const keys = [...new Set([...(window.SB_BARLEN_KEYS||[]), ...Object.keys(src)])];
    return keys.map(k=>({ k, v: src[k]!=null ? src[k] : 10 }));
  });
  const secScrollRef = useRef(null);
  const upd = (i,k,v)=> setRows(rs=> rs.map((r,j)=> j===i?{...r,[k]:v}:r));
  const add = ()=>{
    setRows(rs=> [...rs,{type:'',name:'',kg_m:''}]);
    requestAnimationFrame(()=>{ const el=secScrollRef.current; if(el) el.scrollTo({ top:el.scrollHeight, behavior:'smooth' }); });
  };
  const del = (i)=> setRows(rs=> rs.filter((_,j)=>j!==i));
  const lenScrollRef = useRef(null);
  const updBar = (i,f,v)=> setBars(bs=> bs.map((b,j)=> j===i?{...b,[f]:v}:b));
  const addBar = ()=>{
    setBars(bs=> [...bs, { k:'', v:(window.SB_BARLEN_OPTS||[10])[0] }]);
    requestAnimationFrame(()=>{ const el=lenScrollRef.current; if(el) el.scrollTo({ top:el.scrollHeight, behavior:'smooth' }); });
  };
  const delBar = (i)=> setBars(bs=> bs.filter((_,j)=>j!==i));
  const reset = ()=> tab==='sec'
    ? setRows((window.resetSteel?window.resetSteel():[]).map(r=>({...r})))
    : setBars(Object.entries(window.resetBarLen?window.resetBarLen():{}).map(([k,v])=>({k, v:Number(v)||10})));
  const save = ()=>{
    const clean = rows.filter(r=> String(r.name||'').trim())
      .map(r=>({ type:String(r.type||'').trim(), name:String(r.name||'').trim(), kg_m:Number(r.kg_m)||0 }));
    if(window.saveSteel) window.saveSteel(clean);
    const blenObj = {}; bars.forEach(b=>{ const k=String(b.k||'').trim(); if(k) blenObj[k]=Number(b.v)||10; });
    if(window.saveBarLen) window.saveBarLen(blenObj);
    if(onSaved) onSaved();
    onClose();
  };
  const barOpts = window.SB_BARLEN_OPTS || [10,12];
  const STEEL_TYPE_OPTS = ['ตัวซี (C)','ฉาก (L)','กล่อง','กลมกลวง (Ø)','ราง ([)','H-beam','ประกบคู่ 2C','ประกบคู่ 2L'];
  const tabBtn = (id,ic,label,count)=>(
    <button onClick={()=>setTab(id)} className={'steel-tab'+(tab===id?' active':'')}>
      <Icon name={ic} size={16}/>{label}<span className="steel-tab-ct">{count}</span>
    </button>
  );
  return (
    <Modal title="ตารางเหล็ก (แก้ไขได้)" icon="ruler" xwide
      sub="หน้าตัด = น้ำหนัก/เมตร สำหรับโครงหลังคา/เสาเหล็ก · ความยาวเส้น = ใช้แปลงเมตร→จำนวนเส้นตอนสั่งของ · ค่าเก็บในเครื่องนี้ (localStorage)"
      onClose={onClose}
      foot={<>
        <button className="btn btn-ghost" onClick={reset}>รีเซ็ตค่าตั้งต้น</button>
        <div style={{marginLeft:'auto',display:'flex',gap:8}}>
          <button className="btn btn-ghost" onClick={onClose}>ยกเลิก</button>
          <button className="btn btn-primary" onClick={save}><Icon name="check" size={15}/> บันทึก</button>
        </div>
      </>}>
      <div className="steel-tabs">
        {tabBtn('sec','weight','น้ำหนักหน้าตัด (กก./ม.)',rows.length)}
        {tabBtn('len','ruler','ความยาวเหล็กเส้นที่สั่ง',bars.length)}
      </div>

      {tab==='sec' ? (<>
      <div ref={secScrollRef} style={{maxHeight:'52vh',overflow:'auto'}} className="scrollthin steeltbl">
        <table className="qtable" style={{width:'100%'}}>
          <thead><tr>
            <th style={{width:190}}>ชนิด</th><th>ชื่อหน้าตัด</th>
            <th style={{width:120}}>กก./ม.</th><th style={{width:44}}></th>
          </tr></thead>
          <tbody>
            {rows.map((r,i)=>(
              <tr key={i}>
                <td onClick={e=>e.stopPropagation()}>
                  <select className="qedit cell-sel" value={r.type||''} onChange={e=>upd(i,'type',e.target.value)}>
                    <option value="">— เลือกชนิด —</option>
                    {r.type && !STEEL_TYPE_OPTS.includes(r.type) && <option value={r.type}>{r.type}</option>}
                    {STEEL_TYPE_OPTS.map(t=><option key={t} value={t}>{t}</option>)}
                  </select>
                </td>
                <td onClick={e=>e.stopPropagation()}><input className="qedit" value={r.name||''} onChange={e=>upd(i,'name',e.target.value)} placeholder="เช่น C-100x50x20x2.3"/></td>
                <td onClick={e=>e.stopPropagation()}><input className="qedit" value={r.kg_m==null?'':r.kg_m} onChange={e=>upd(i,'kg_m',e.target.value)} inputMode="decimal"/></td>
                <td onClick={e=>e.stopPropagation()}><button className="minibtn del" title="ลบ" onClick={()=>del(i)}><Icon name="trash" size={14}/></button></td>
              </tr>
            ))}
          </tbody>
        </table>
      </div>
      <button className="steel-add" onClick={add}><Icon name="plus" size={14}/> เพิ่มหน้าตัด</button>
      <div className="steel-note">
        <b>⚠ ค่าตั้งต้นเป็นค่าประมาณ</b> — ตรวจกับ มอก.1227/1228 หรือผู้ผลิตก่อนสั่งจริง · prefix <b>2C/2L</b> = ประกบคู่ ระบบคูณ 2 ให้เอง · จับคู่ชื่อไม่ได้ = ปล่อยให้กรอกน้ำหนักเองในตารางหลังคา
      </div>
      </>) : (<>
      <div ref={lenScrollRef} style={{maxHeight:'52vh',overflow:'auto'}} className="scrollthin steeltbl">
        <table className="qtable" style={{width:'100%'}}>
          <thead><tr>
            <th style={{textAlign:'left'}}>ขนาดเหล็กเสริม</th><th style={{textAlign:'left',width:240}}>ความยาว/เส้น ที่สั่ง</th><th style={{width:40}}></th>
          </tr></thead>
          <tbody>
            {bars.map((b,i)=>(
              <tr key={i}>
                <td onClick={e=>e.stopPropagation()}><input className="qedit" style={{fontWeight:600,fontFamily:'var(--mono)',width:160}} value={b.k} onChange={e=>updBar(i,'k',e.target.value)} placeholder="เช่น DB12"/></td>
                <td onClick={e=>e.stopPropagation()}>
                  <select className="qedit cell-sel" style={{minWidth:150}} value={b.v}
                    onChange={e=>updBar(i,'v',Number(e.target.value))}>
                    {barOpts.map(o=> <option key={o} value={o}>{o} เมตร</option>)}
                  </select>
                </td>
                <td onClick={e=>e.stopPropagation()}><button className="minibtn del" title="ลบ" onClick={()=>delBar(i)}><Icon name="trash" size={14}/></button></td>
              </tr>
            ))}
          </tbody>
        </table>
      </div>
      <button className="steel-add" onClick={addBar}><Icon name="plus" size={14}/> เพิ่มขนาดเหล็ก</button>
      <div className="steel-note blue">
        ใช้ตอนแปลง <b>ความยาวรวม (เมตร) → จำนวนเส้นที่สั่ง</b> ในชีต “สรุปวัสดุสั่งซื้อ” · ปริมาณหลัก (เมตร/กก.) ไม่เปลี่ยนตามค่านี้<br/>
        ‼️ จำนวนเส้น = ปัดขึ้นจากเมตรรวม (รวมเผื่อ 7%) หาร ความยาวเส้น — <b>ยังไม่ได้คิดเศษจากการตัดจริง</b> เช่น เหล็กท่อนละ 6 ม. ตัดจากเส้น 10 ม. จะเหลือเศษ 4 ม.ต่อเส้น (คิดเศษตัดจริง = งานเฟสถัดไป)
      </div>
      </>)}
    </Modal>
  );
}

// ── ฟอร์แมตบาท (ใช้ร่วมทั้งชิปและตัวกาง) ──
function sbBaht(n){ return '฿'+(Number(n)||0).toLocaleString('th-TH',{minimumFractionDigits:2,maximumFractionDigits:2}); }

// ── ค่าใช้จ่าย AI ต่อการถอด 1 ครั้ง (จาก summary._cost) — เนื้อในอย่างเดียว หัวเป็นชิปที่ parent คุม open ──
function CostDrawerBody({ cost }){
  const perCat = Array.isArray(cost.per_category) ? cost.per_category : [];
  return (
    <div className="drawer-body scrollthin" style={{fontSize:13}}>
      <div style={{display:'flex',flexWrap:'wrap',gap:'6px 18px',marginBottom:10,color:'var(--ink-3)'}}>
        <span>รวม <b>{sbBaht(cost.total_thb)}</b> <small style={{color:'var(--ink-4)'}}>(~${(Number(cost.total_usd)||0).toFixed(3)})</small></span>
        <span>input (PDF+prompt): <b className="mono">{(cost.input_tokens||0).toLocaleString()}</b> tok</span>
        <span>output: <b className="mono">{(cost.output_tokens||0).toLocaleString()}</b> tok</span>
        <span>โมเดล: {cost.model}</span>
      </div>
      <div className="logline">
        <span className="tk">🌐</span>
        <span><span className="em">[ต้นทุนกลาง]</span> ค่าอ่าน PDF+prompt {sbBaht(cost.shared_input_thb)} — แชร์ทุกหมวด (ถ้าแยกถอดทีละหมวดจะเสียก้อนนี้ซ้ำทุกครั้ง)</span>
      </div>
      {perCat.map((c,i)=>(
        <div className="logline" key={i}>
          <span className="tk">📊</span>
          <span><span className="em">[{c.category}]</span> {c.rows} รายการ · output ~{sbBaht(c.thb_est)}</span>
        </div>
      ))}
      <div style={{marginTop:8,fontSize:12,color:'var(--ink-4)',lineHeight:1.6}}>
        {cost._note}
      </div>
    </div>
  );
}

function AddRowModal({ cats, onClose, onAdd }){
  const [f,setF] = useState({ cat:cats[0], code:'', name:'', qty:1, unit:'ต้น' });
  const ok = f.code.trim() && f.name.trim();
  return (
    <Modal title="เพิ่มรายการปริมาณ" sub="กรอกข้อมูลรายการใหม่" onClose={onClose}
      foot={<><button className="btn btn-ghost" onClick={onClose}>ยกเลิก</button>
        <button className="btn btn-primary" disabled={!ok} onClick={()=>onAdd(f)}>เพิ่มรายการ</button></>}>
      <div style={{display:'grid',gridTemplateColumns:'1fr 1fr',gap:14}}>
        <div className="field"><label>หมวดงาน</label>
          <select className="sel" value={f.cat} onChange={e=>setF({...f,cat:e.target.value})}>
            {cats.map(c=><option key={c}>{c}</option>)}</select></div>
        <div className="field"><label>รหัส</label>
          <input className="inp" value={f.code} onChange={e=>setF({...f,code:e.target.value})} placeholder="เช่น C3"/></div>
      </div>
      <div className="field"><label>รายการ</label>
        <input className="inp" value={f.name} onChange={e=>setF({...f,name:e.target.value})} placeholder="รายละเอียดรายการ"/></div>
      <div style={{display:'grid',gridTemplateColumns:'1fr 1fr',gap:14}}>
        <div className="field"><label>จำนวน</label>
          <input className="inp mono" type="number" value={f.qty} onChange={e=>setF({...f,qty:e.target.value})}/></div>
        <div className="field"><label>หน่วย</label>
          <input className="inp" value={f.unit} onChange={e=>setF({...f,unit:e.target.value})}/></div>
      </div>
    </Modal>
  );
}

function AuditModal({ id, row, onClose }){
  const trail = AUDIT[id] || [{by:'ระบบ', t:'10:24', act:'ถอดจากแบบอัตโนมัติ'}];
  return (
    <Modal title="ประวัติการแก้ไข" sub={row ? row.code+' · '+row.name : ''} onClose={onClose}
      foot={<button className="btn btn-ghost" onClick={onClose}>ปิด</button>}>
      <div style={{display:'flex',flexDirection:'column',gap:0}}>
        {trail.map((t,i)=>(
          <div key={i} style={{display:'flex',gap:13,paddingBottom:16,position:'relative'}}>
            <div style={{display:'flex',flexDirection:'column',alignItems:'center'}}>
              <div style={{width:11,height:11,borderRadius:'50%',background:i===trail.length-1?'var(--primary)':'var(--border-2)',flex:'0 0 11px',marginTop:4}}></div>
              {i<trail.length-1 && <div style={{width:2,flex:1,background:'var(--border)'}}></div>}
            </div>
            <div>
              <div style={{fontSize:13.5,color:'var(--ink)'}}>{t.act}</div>
              <div style={{fontSize:12,color:'var(--ink-4)',marginTop:2}}>{t.by} · {t.t} น.</div>
            </div>
          </div>
        ))}
      </div>
    </Modal>
  );
}
window.ResultsScreen = ResultsScreen;
