/* ===================== Grid marks — วางช่องพื้นตามเส้นกริดของแบบ (งานโครงสร้าง) =====================
   แนวคิด: AI บอก "ช่องกริด" ของแต่ละแผ่นพื้น (คอลัมน์ grid ในชีต slabs_cip เช่น "A-B/1-2", "B+2-C/1-2")
           → โค้ดหาเส้นกริดจริงในหน้า → วาดกรอบช่องพื้นตรงตำแหน่งเป๊ะ (ไม่ต้องให้ AI เดาพิกัด)
   หาเส้นกริด 2 ทาง (พอร์ตจาก tools/grid-marks/):
     (1) ข้อความ — ป้ายกริด 1,2,3/A,B,C เป็นตัวอักษรจริงใน PDF (บ้านดุง) + สเกลจากตัวเลขระยะ (4.00, 2.50…)
     (2) เวกเตอร์ — ไฟล์ที่ตัวอักษรเป็นเส้น (แบบกรมโยธาฯ): วงกลมป้ายกริดจาก path + Tesseract อ่านตัวในวง + เดาสเกลมาตรฐาน
   ตรวจทาน: วงป้ายพื้นในแบบ (เวกเตอร์) ที่ไม่มีช่องไหนครอบ = วงแดง (AI ข้าม) · ช่องที่ไม่มีป้าย/หลายป้าย = เส้นประ
   คาน: grid "E/1-2" (แนว + ช่วง) → แถบบางตามเส้นกริด (ไม่ตรวจป้าย) · พื้นสำเร็จ = ช่องแบบเดียวกับพื้นหล่อ
   เฟส 2: ฐานราก/เสา at "E/1,E/3" (จุดตัด → สี่เหลี่ยมขนาด B×L/หน้าตัด) · ห้อง (floor_finishes/ceilings) grid ช่อง
          · ประตู/หน้าต่าง at "E/1-2" (ช่วงผนัง → จุดกลางช่วง · หลายบานช่วงเดียวกระจายตามลำดับ)
   เฟส 3: ผนัง (walls) runs "E/1-4,1/A-E,D+1/2-2+2.5" (แนวผนังรูปแบบเดียวกับคาน → แถบตามแนว · สีตามรหัส · lenM ต่อช่วง)
   API:  window.sbBuildGridMarks({ storagePath, rows, candPages, onProgress })
         rows = แถวที่มีตำแหน่ง ({code,grid,page_num,count, kind,cat,group}) จาก window.sbGridRowsFromSheets(sheets, 'str'|'arch')
         → { marks:{<page>:[...]}, stats (byGroup = สรุปแยกหมวด) }
         window.sbGridGeom(ref, grid) = ตำแหน่ง → pt + เมตร (lenM ช่วงคาน · wM×hM ช่องพื้น)
   พิกัด = pt ของหน้าหลังหมุน (viewport scale 1, มุมซ้ายบน) → marks เป็นสัดส่วนหน้า (0–1) แบบเดียวกับ ocr-overlay */
(function(){
  const TESS_CDN     = 'https://cdn.jsdelivr.net/npm/tesseract.js@5.1.1/dist/tesseract.min.js';
  const PDFJS_SRC    = 'https://unpkg.com/pdfjs-dist@3.11.174/build/pdf.min.js';
  const PDFJS_WORKER = 'https://unpkg.com/pdfjs-dist@3.11.174/build/pdf.worker.min.js';
  const COLORS = ['#2563eb','#16a34a','#ea580c','#9333ea','#0891b2','#db2777','#ca8a04','#0d9488'];
  const ORPHAN = '#dc2626';
  const loadScript = (src)=> window.sbLoadScript ? window.sbLoadScript(src) : new Promise((res,rej)=>{
    const el=document.createElement('script'); el.src=src; el.async=true; el.onload=res; el.onerror=()=>rej(new Error('โหลดสคริปต์ไม่ได้: '+src)); document.head.appendChild(el);
  });
  const median = (a) => { const s=[...a].sort((x,y)=>x-y); return s.length ? s[s.length>>1] : 0; };
  const mul = (m,n) => [m[0]*n[0]+m[2]*n[1], m[1]*n[0]+m[3]*n[1], m[0]*n[2]+m[2]*n[3], m[1]*n[2]+m[3]*n[3], m[0]*n[4]+m[2]*n[5]+m[4], m[1]*n[4]+m[3]*n[5]+m[5]];

  /* ── (1) กริดจากข้อความ ── */
  const NUM = /^\d{1,2}$/, LET = /^[A-Z]$/;
  // ข้อความแนวนอนตั้งตรง (ตามที่ผู้ใช้เห็น) ของหน้า — ใช้หากริด + หาป้ายเสา/ประตู/หน้าต่าง
  async function flatTexts(page){
    const vp = page.getViewport({ scale:1 });
    const tc = await page.getTextContent();
    // ใช้ transform ของ viewport → หน้าที่ตั้ง /Rotate (หมุนตอนอัปโหลด #106) ได้พิกัดตามที่เห็นจริง
    return tc.items.filter(i=>i.str && i.str.trim()).map(i=>{
      const m = mul(vp.transform, i.transform);
      const flat = Math.abs(m[1]) < 0.01*Math.abs(m[0]) && m[0] > 0;
      return { s:i.str.trim(), w:i.width, h:i.height, flat, cx:m[4]+i.width/2, cy:m[5]-i.height*0.3 };
    }).filter(i=>i.flat);
  }
  async function textGrid(page, flat){
    flat = flat || await flatTexts(page);
    if(!flat.length) return null;
    const grp = (list, keyOf, posOf, valOf) => {
      const out = [];
      for(const it of [...list].sort((a,b)=>keyOf(a)-keyOf(b))){
        const g = out.find(g=>Math.abs(g.key-keyOf(it))<=3 && Math.abs(g.h-it.h)<=1.5);
        if(g){ g.items.push(it); g.key = median(g.items.map(keyOf)); } else out.push({ key:keyOf(it), h:it.h, items:[it] });
      }
      return out.map(g=>{ const m = new Map(); g.items.forEach(it=>{ if(!m.has(valOf(it))) m.set(valOf(it), it); });
        const L = [...m.entries()].map(([v,it])=>({ v, s:it.s, pos:posOf(it) })).sort((a,b)=>a.v-b.v);
        const d = L.slice(1).map((x,i)=>Math.sign(x.pos-L[i].pos)); return { L, ok: L.length>=3 && d.every(s=>s===d[0] && s!==0) };
      }).filter(g=>g.ok).sort((a,b)=>b.L.length-a.L.length)[0] || null;
    };
    const gx = grp(flat.filter(i=>NUM.test(i.s)), i=>i.cy, i=>i.cx, i=>Number(i.s));
    const gy = grp(flat.filter(i=>LET.test(i.s) && !/^[IO]$/.test(i.s)), i=>i.cx, i=>i.cy, i=>i.s.charCodeAt(0));
    if(!gx || !gy) return null;
    const num = Object.fromEntries(gx.L.map(g=>[g.s, g.pos])), let_ = Object.fromEntries(gy.L.map(g=>[g.s, g.pos]));
    // สเกล: ตัวเลขระยะที่อยู่กึ่งกลางระหว่างป้ายตัวเลขคู่ติดกัน → pt/ม. ที่ตรงกันมากสุด
    const dims = flat.filter(i=>/^\d{1,3}\.\d{1,2}$/.test(i.s)).map(i=>({ ...i, v:Number(i.s) }));
    const est = [];
    for(let i=0;i+1<gx.L.length;i++){
      const a=gx.L[i].pos, b=gx.L[i+1].pos, mid=(a+b)/2, span=Math.abs(b-a);
      dims.filter(t=>Math.abs(t.cx-mid)<span*0.2).forEach(t=>est.push(span/t.v));
    }
    let best = null;
    for(const s of est){ const votes = est.filter(o=>Math.abs(o-s)/s<0.03).length; if(!best || votes>best.votes) best={ s, votes }; }
    if(!best) return null;
    return { method:'ข้อความ', axes:{ num, let:let_ }, numAxis:'x', ptPerM:best.s, texts:flat };
  }

  /* ── (2) กริดจากเวกเตอร์: วงกลม (moveTo + curveTo ≥4 · กว้าง≈สูง) ── */
  async function vectorCircles(page){
    const OPS = window.pdfjsLib.OPS;
    const vp = page.getViewport({ scale:1 });
    const ol = await page.getOperatorList();
    const ap = (m,x,y) => [m[0]*x+m[2]*y+m[4], m[1]*x+m[3]*y+m[5]];
    let ctm = vp.transform.slice(); const stack = [], out = [], tris = [], glyphs = [], hexes = [], polys = [];
    for(let i=0;i<ol.fnArray.length;i++){
      const fn = ol.fnArray[i], a = ol.argsArray[i];
      if(fn===OPS.save) stack.push(ctm.slice());
      else if(fn===OPS.restore) ctm = stack.pop() || ctm;
      else if(fn===OPS.transform) ctm = mul(ctm, a);
      else if(fn===OPS.constructPath){
        const ops = a[0], coords = a[1]; let k = 0, cur = null;
        // วง = curveTo ≥4 ล้วน (แบบโครงสร้างกรมฯ) หรือ เส้นตรงสั้นปนโค้ง ≥6 ท่อนปิดรอบจุดเดียว (แบบสถาปัตย์กรมฯ "MLLCLLCLL" + closePath)
        const flush = () => {
          if(!cur) return;
          // สามเหลี่ยมเล็ก (เส้นตรงล้วน 3 มุม) + เส้นเล็ก (ตัวเลขที่เป็นเส้น) — ไว้หาป้ายชนิดผนัง ▷1◁ (wallTagsOf)
          if(cur.pts.length>=2 && cur.pts.length<=48){   // ≤48 จุด: เลขโค้ง (3, 8) จุดเยอะ — ใช้ทั้งตรวจป้ายผนังและจัดกลุ่มเลขในป้ายประตู/หน้าต่าง
            const xs = cur.pts.map(p=>p[0]), ys = cur.pts.map(p=>p[1]);
            if(Math.max(Math.max(...xs)-Math.min(...xs), Math.max(...ys)-Math.min(...ys)) <= 12) glyphs.push(cur.pts);
          }
          if(cur.curves===0 && cur.lines>=2 && cur.lines<=4){
            const u = cur.pts.filter((p,j)=>!cur.pts.slice(0,j).some(o=>Math.hypot(o[0]-p[0],o[1]-p[1])<0.3));
            if(u.length===3){
              const xs = u.map(p=>p[0]), ys = u.map(p=>p[1]), size = Math.max(Math.max(...xs)-Math.min(...xs), Math.max(...ys)-Math.min(...ys));
              if(size>=3 && size<=25) tris.push({ pts:u, cx:(xs[0]+xs[1]+xs[2])/3, cy:(ys[0]+ys[1]+ys[2])/3, size });
            }
          }
          // รูปปิดเส้นตรงล้วน 3–8 มุม → (ก) ⬡ ป้ายหน้าต่าง (6 มุม อ้วน) (ข) กรอบฐานราก/เสาที่วาดในแบบ (ไว้ให้ marker ทับรูปจริง)
          if(cur.curves===0 && cur.lines>=3 && cur.lines<=8){
            const a0 = cur.pts[0], aN = cur.pts[cur.pts.length-1];
            if(cur.closed || Math.hypot(a0[0]-aN[0], a0[1]-aN[1]) < 0.5){
              const u = cur.pts.filter((p,j)=>!cur.pts.slice(0,j).some(o=>Math.hypot(o[0]-p[0],o[1]-p[1])<0.3));
              const xs = u.map(p=>p[0]), ys = u.map(p=>p[1]), x0 = Math.min(...xs), x1 = Math.max(...xs), y0 = Math.min(...ys), y1 = Math.max(...ys);
              const w = x1-x0, h = y1-y0, size = Math.max(w,h);
              if(u.length===6 && size>=4 && size<=40 && Math.min(w,h)/size > 0.7) hexes.push({ cx:(x0+x1)/2, cy:(y0+y1)/2, size });
              if(u.length>=3 && size>=4 && size<=250 && Math.min(w,h)>=2) polys.push({ x0, y0, x1, y1, n:u.length });
            }
          }
          const curveCircle = cur.curves>=4 && cur.lines===0, polyCircle = cur.lines>0 && cur.curves+cur.lines>=6;
          if(!curveCircle && !polyCircle) return;
          const xs = cur.pts.map(p=>p[0]), ys = cur.pts.map(p=>p[1]);
          const w = Math.max(...xs)-Math.min(...xs), h = Math.max(...ys)-Math.min(...ys);
          if(!(w>1 && Math.abs(w-h)/w<0.08)) return;
          const cx = (Math.max(...xs)+Math.min(...xs))/2, cy = (Math.max(...ys)+Math.min(...ys))/2, r = (w+h)/4;
          if(polyCircle){   // ทุกจุดห่างศูนย์กลางเท่ากัน (±6%) + ปิดรอบ — กันสี่เหลี่ยม/รูปหกเหลี่ยมป้ายหน้าต่าง
            const ds = cur.pts.map(p=>Math.hypot(p[0]-cx, p[1]-cy));
            if(Math.min(...ds) < r*0.94 || Math.max(...ds) > r*1.06) return;
            const a = cur.pts[0], b = cur.pts[cur.pts.length-1];
            if(!cur.closed && Math.hypot(a[0]-b[0], a[1]-b[1]) > r*0.3) return;
          }
          out.push({ cx, cy, r });
        };
        for(const op of ops){
          if(op===OPS.moveTo){ flush(); cur = { pts:[ap(ctm,coords[k],coords[k+1])], curves:0, lines:0 }; k+=2; }
          else if(op===OPS.lineTo){ if(cur){ cur.lines++; cur.pts.push(ap(ctm,coords[k],coords[k+1])); } k+=2; }
          // เก็บจุดกึ่งกลางโค้ง (t=0.5) ด้วย — วงที่วาดด้วยโค้ง 2 ท่อนบน/ล่าง จุดปลายอยู่แค่ด้านข้าง กรอบจากจุดปลายจะแบนผิด
          else if(op===OPS.curveTo || op===OPS.curveTo2 || op===OPS.curveTo3){
            const n = op===OPS.curveTo ? 6 : 4;
            if(cur){
              const p0 = cur.pts[cur.pts.length-1], end = ap(ctm,coords[k+n-2],coords[k+n-1]);
              const c1 = op===OPS.curveTo2 ? p0 : ap(ctm,coords[k],coords[k+1]);
              const c2 = op===OPS.curveTo ? ap(ctm,coords[k+2],coords[k+3]) : op===OPS.curveTo2 ? ap(ctm,coords[k],coords[k+1]) : end;
              cur.curves++; cur.pts.push([(p0[0]+3*c1[0]+3*c2[0]+end[0])/8, (p0[1]+3*c1[1]+3*c2[1]+end[1])/8], end);
            }
            k+=n;
          }
          else if(op===OPS.rectangle){
            flush(); cur = null;
            const c4 = [[0,0],[1,0],[0,1],[1,1]].map(([i,j])=>ap(ctm, coords[k]+i*coords[k+2], coords[k+1]+j*coords[k+3]));
            const xs = c4.map(p=>p[0]), ys = c4.map(p=>p[1]), x0 = Math.min(...xs), x1 = Math.max(...xs), y0 = Math.min(...ys), y1 = Math.max(...ys);
            if(Math.max(x1-x0, y1-y0)>=4 && Math.max(x1-x0, y1-y0)<=250 && Math.min(x1-x0, y1-y0)>=2) polys.push({ x0, y0, x1, y1, n:4 });
            k+=4;
          }
          else if(op===OPS.closePath){ if(cur) cur.closed = true; }
        }
        flush();
      }
    }
    const uniq = [];
    for(const c of out) if(!uniq.some(u=>Math.hypot(u.cx-c.cx,u.cy-c.cy)<1 && Math.abs(u.r-c.r)<0.5)) uniq.push(c);
    uniq.tris = tris; uniq.glyphs = glyphs; uniq.hexes = hexes; uniq.polys = polys;
    return uniq;
  }
  // ป้ายชนิดผนัง = สามเหลี่ยมอ้วนที่มี "ตัวเลข" (เส้นเล็ก) อยู่ข้างใน · ฐานขนานผนัง ปลายชี้เข้าผนัง
  //   ผนังภายใน = คู่ ▷1◁ (ผนังคั่นกลาง) · ผนังภายนอก = ตัวเดียว ▽1 ชี้จากด้านนอก → ตรวจทีละตัว
  //   หัวลูกศรเส้นบอกระยะ (ผอม · ไม่มีเลขข้างใน) · สามเหลี่ยมที่ติดวงกลม (สัญลักษณ์รูปตัด Ⓑ / เข็มทิศ) ตัดทิ้ง
  //   คืน [{ x,y = ปลาย · dx,dy = ทิศที่ชี้ (หน่วย) · size }]
  function wallTagsOf(tris, glyphs, circles){
    const inTri = (p, T, m) => { const [a,b,c] = T, s = (p1,p2,p3)=>(p1[0]-p3[0])*(p2[1]-p3[1])-(p2[0]-p3[0])*(p1[1]-p3[1]);
      const d1 = s(p,a,b), d2 = s(p,b,c), d3 = s(p,c,a), neg = d1<-m || d2<-m || d3<-m, pos = d1>m || d2>m || d3>m; return !(neg && pos); };
    const C = 15, bins = new Map(), bin = (x,y)=>Math.floor(x/C)+','+Math.floor(y/C);
    (glyphs||[]).forEach(g=>{ const k = bin(g[0][0], g[0][1]); if(!bins.has(k)) bins.set(k, []); bins.get(k).push(g); });
    const out = [];
    for(const t of tris){
      const xs = t.pts.map(p=>p[0]), ys = t.pts.map(p=>p[1]);
      const w = Math.max(...xs)-Math.min(...xs), h = Math.max(...ys)-Math.min(...ys);
      if(Math.min(w,h)/Math.max(w,h) < 0.6 || t.size < 5) continue;
      if((circles||[]).some(c=>c.r>=3 && t.pts.some(p=>Math.hypot(p[0]-c.cx, p[1]-c.cy) <= c.r*1.15))) continue;
      // ฐาน = ด้านที่ขนานแกนมากสุด → ปลาย = มุมตรงข้าม
      const E = [[0,1,2],[1,2,0],[2,0,1]].map(([i,j,k])=>{ const p = t.pts[i], q = t.pts[j];
        return { k, tilt: Math.min(Math.abs(p[0]-q[0]), Math.abs(p[1]-q[1])) / (Math.hypot(p[0]-q[0], p[1]-q[1])||1), mid:[(p[0]+q[0])/2,(p[1]+q[1])/2] }; })
        .sort((a,b)=>a.tilt-b.tilt)[0];
      if(E.tilt > 0.1) continue;
      const apex = t.pts[E.k], L = Math.hypot(apex[0]-E.mid[0], apex[1]-E.mid[1]); if(!(L>0)) continue;
      // มีตัวเลขข้างใน: เส้นเล็กที่ทุกจุดอยู่ในสามเหลี่ยม และไม่ใช่ขอบสามเหลี่ยมเอง
      const gx = Math.floor(t.cx/C), gy = Math.floor(t.cy/C); let digit = false;
      for(let i=-1; i<=1 && !digit; i++) for(let j=-1; j<=1 && !digit; j++) for(const g of (bins.get((gx+i)+','+(gy+j))||[])){
        if(g.every(p=>t.pts.some(v=>Math.hypot(v[0]-p[0], v[1]-p[1])<0.5))) continue;
        if(g.every(p=>inTri(p, t.pts, 0.05))){ digit = true; break; }
      }
      if(!digit) continue;
      out.push({ x:apex[0], y:apex[1], dx:(apex[0]-E.mid[0])/L, dy:(apex[1]-E.mid[1])/L, size:t.size });
    }
    return out;
  }
  // วงป้ายกริด = วงรัศมีเดียวกันที่เรียงแนว ≥3 (ใหญ่สุด) · คืนแนวแถว (y เท่ากัน) + แนวคอลัมน์ (x เท่ากัน)
  function gridBubbleLines(circles){
    const byR = {};
    circles.filter(c=>c.r>=3).forEach(c=>{ const k=c.r.toFixed(1); (byR[k]=byR[k]||[]).push(c); });
    const lines = [];
    for(const [rk,list] of Object.entries(byR)){
      for(const axis of ['row','col']){
        const key = c => axis==='row' ? c.cy : c.cx;
        const used = new Set();
        for(const c of list){
          if(used.has(c)) continue;
          const g = list.filter(o=>Math.abs(key(o)-key(c))<1.5);
          if(g.length>=3){ g.forEach(o=>used.add(o)); lines.push({ axis, r:Number(rk), key:median(g.map(key)), items:g }); }
        }
      }
    }
    const pick = (axis) => lines.filter(l=>l.axis===axis).sort((a,b)=>b.r-a.r || b.items.length-a.items.length)[0] || null;
    const row = pick('row'), col = pick('col');
    if(row && col && Math.abs(row.r-col.r)>0.6) return null;   // ต้องเป็นป้ายกริดชุดเดียวกัน
    return (row && col) ? { row, col } : null;
  }
  // อ่านตัวในวง: เรนเดอร์เฉพาะแถบป้าย (scale 8) → ครอปในวง (ตัดเส้นวงทิ้ง) → Tesseract ลอง 4 ทิศ เลือกทิศที่มั่นใจสุดทั้งแนว
  async function renderRegion(page, x0, y0, x1, y1, S){
    const vp = page.getViewport({ scale:S, offsetX:-x0*S, offsetY:-y0*S });
    const cv = document.createElement('canvas'); cv.width = Math.ceil((x1-x0)*S); cv.height = Math.ceil((y1-y0)*S);
    const x = cv.getContext('2d'); x.fillStyle='#fff'; x.fillRect(0,0,cv.width,cv.height);
    await page.render({ canvasContext:x, viewport:vp }).promise;
    return cv;
  }
  function cropRot(src, cx, cy, r, rot){
    const R = r*0.78, size = Math.ceil(R*2), pad = 24;
    const o = document.createElement('canvas'); o.width = o.height = size+pad*2;
    const x = o.getContext('2d'); x.fillStyle='#fff'; x.fillRect(0,0,o.width,o.height);
    x.save(); x.translate(o.width/2, o.height/2); x.rotate(rot*Math.PI/2);
    x.beginPath(); x.arc(0,0,R,0,Math.PI*2); x.clip();
    x.drawImage(src, cx-R, cy-R, size, size, -R, -R, size, size);
    x.restore();
    return o;
  }
  // ทิศตัวอักษรในวง: ทั้งไฟล์มักหมุนเท่ากัน → ทิศที่เจอแล้ว (rotHint.rot) ลองก่อน · อ่านชัดทุกวง = ไม่ต้องลองทิศอื่น
  async function readBubbleLabels(page, line, worker, rotHint){
    const S = 8, pad = line.r+2;
    const xs = line.items.map(c=>c.cx), ys = line.items.map(c=>c.cy);
    const X0 = Math.min(...xs)-pad, Y0 = Math.min(...ys)-pad;
    const cv = await renderRegion(page, X0, Y0, Math.max(...xs)+pad, Math.max(...ys)+pad, S);
    const order = rotHint.rot==null ? [0,1,2,3] : [rotHint.rot, ...[0,1,2,3].filter(r=>r!==rotHint.rot)];
    let best = null;
    for(const rot of order){
      const reads = [];
      for(const c of line.items){
        const { data } = await worker.recognize(cropRot(cv, (c.cx-X0)*S, (c.cy-Y0)*S, c.r*S, rot));
        reads.push({ c, s:(data.text||'').trim().replace(/[^A-Z0-9]/g,''), conf:data.confidence||0 });
      }
      const ok = (r)=>r.s.length>=1 && r.s.length<=2;
      const score = reads.reduce((a,r)=>a+(ok(r) ? r.conf : 0), 0);
      if(!best || score>best.score) best = { rot, score, reads };
      if(rot===rotHint.rot && reads.every(r=>ok(r) && r.conf>=60)) break;
    }
    rotHint.rot = best.rot;
    return best;
  }
  // ป้ายที่อ่านได้ → ตำแหน่งต่อชื่อ · ซ่อมตัวที่อ่านพลาดด้วยลำดับ (ตัวเลข/ตัวอักษรเรียงต่อเนื่อง)
  function labelAxis(line, best){
    const posOf = c => line.axis==='row' ? c.cx : c.cy;
    const items = best.reads.map(r=>({ pos:posOf(r.c), s:r.s })).sort((a,b)=>a.pos-b.pos);
    const isNum = items.filter(i=>/^\d+$/.test(i.s)).length >= items.length/2;
    const val = s => isNum ? (/^\d+$/.test(s) ? Number(s) : NaN) : (/^[A-Z]$/.test(s) ? s.charCodeAt(0) : NaN);
    let b2 = null;
    for(let i=0;i<items.length;i++){
      const v = val(items[i].s); if(!Number.isFinite(v)) continue;
      for(const dir of [1,-1]){
        const start = v-dir*i, hit = items.filter((it,j)=>val(it.s)===start+dir*j).length;
        if(!b2 || hit>b2.hit) b2 = { start, dir, hit };
      }
    }
    if(!b2 || b2.hit < Math.ceil(items.length/2)) return null;   // อ่านตรงลำดับไม่ถึงครึ่ง = ไม่เชื่อ
    const name = v => isNum ? String(v) : String.fromCharCode(v);
    return { isNum, map:Object.fromEntries(items.map((it,j)=>[name(b2.start+b2.dir*j), it.pos])) };
  }
  // สเกลเมื่อไม่มีตัวเลขระยะ: ระยะกริดบ้านมักเป็นทวีคูณ 0.05 ม. → ลองสเกลมาตรฐาน ให้ "ลงตัว" มากสุด (เสมอ → 1:100 กระดาษเต็ม)
  function guessScale(axisMaps){
    const gaps = [];
    for(const m of axisMaps){ const p = Object.values(m).sort((a,b)=>a-b); for(let i=1;i<p.length;i++) gaps.push(p[i]-p[i-1]); }
    const PT_PER_MM = 72/25.4, cands = [];
    for(const sc of [50,75,100,125,150,200]) for(const shrink of [1,0.7071,0.5]) cands.push({ sc, shrink, ptPerM:1000/sc*PT_PER_MM*shrink });
    const score = (ptPerM) => gaps.reduce((a,g)=>{ const m=g/ptPerM, err=Math.abs(m-Math.round(m/0.05)*0.05); return a+(m>=0.5 && m<=12 && err<0.02 ? 1 : 0); }, 0);
    const PREF = [100,50,75,125,150,200];
    return cands.map(c=>({ ...c, fit:score(c.ptPerM) }))
      .sort((a,b)=>b.fit-a.fit || Math.abs(a.shrink-1)-Math.abs(b.shrink-1) || PREF.indexOf(a.sc)-PREF.indexOf(b.sc))[0];
  }
  async function vectorGrid(page, circles, getWorker, rotHint){
    const lines = gridBubbleLines(circles);
    if(!lines) return null;
    const worker = await getWorker();
    const ax = {};
    for(const line of [lines.row, lines.col]){
      const a = labelAxis(line, await readBubbleLabels(page, line, worker, rotHint));
      if(!a) return null;
      ax[line.axis] = a;
    }
    if(ax.row.isNum===ax.col.isNum) return null;
    const numLine = ax.row.isNum ? 'row' : 'col';
    const sc = guessScale([ax.row.map, ax.col.map]);
    return { method:'เวกเตอร์', axes:{ num:ax[numLine].map, let:ax[numLine==='row'?'col':'row'].map },
      numAxis: numLine==='row' ? 'x' : 'y', ptPerM:sc.ptPerM, bubbleR:lines.row.r };
  }

  /* ── ตำแหน่ง grid → เรขาคณิต (pt ของหน้า + ขนาดจริงเป็นเมตร) ──
     ช่อง (พื้น):  "B-C/1-2" · "2-3/D+1.2-E" (ครึ่งไหนก่อนก็ได้) · "+d" = เดิน d ม. ไปทางป้ายถัดไป · "A+-1.6" = ยื่นออกนอกกริด
     เส้น (คาน):  "E/1-2" = แนว E ช่วง 1→2 · "3/D-E" · "1+-1.1/C-D" (แนวเยื้องจากกริด) · "D/1+-1.1-1" (คานยื่น) · "3/D-D+0.3"
     ไม่รับรูปแบบที่ AI ตั้งเอง ("B'", "1.5", "2-2.5") → วางไม่ได้ (นับใน stats.unplaced)
     จุดตัด (ฐานราก/เสา):  "E/1" · "B+2/3"
     คืน { kind:'cell', x0,x1,y0,y1, wM,hM,areaM2 } | { kind:'line', p0,p1, lenM, x0,x1,y0,y1 = แถบบางตามแนวคาน } | { kind:'point', x,y } | null
     ใช้ซ้ำได้ (เช่น "AI บอกตำแหน่ง → โค้ดวัดระยะ": lenM = ความยาวช่วงคาน · wM×hM = ขนาดช่องพื้น) */
  const BEAM_BAND_M = 0.25, BEAM_BAND_MIN_PT = 4;
  function geomOfGrid(ref, g){
    const halves = String(ref).split('/').map(s=>s.trim());
    if(halves.length!==2) return null;
    const endPos = (tok) => {
      const m = String(tok).trim().match(/^([A-Z]|\d{1,2})(?:\+(-?\d+(?:\.\d+)?))?$/i);
      if(!m) return null;
      const isNum = /^\d/.test(m[1]), axis = isNum ? g.axes.num : g.axes.let, lab = m[1].toUpperCase();
      if(axis[lab]==null) return null;
      const nextLab = isNum ? String(Number(lab)+1) : String.fromCharCode(lab.charCodeAt(0)+1);
      const prevLab = isNum ? String(Number(lab)-1) : String.fromCharCode(lab.charCodeAt(0)-1);
      const dir = axis[nextLab]!=null ? Math.sign(axis[nextLab]-axis[lab]) : axis[prevLab]!=null ? -Math.sign(axis[prevLab]-axis[lab]) : 1;
      let d = m[2] ? Number(m[2]) : 0;
      // "+-d" = ยื่นออกนอกกริด (prompt) · ป้ายสุดท้าย (ไม่มีกริดถัดไป เช่น "E+-1.5") dir ชี้ออกนอกอยู่แล้ว → ใช้ |d|
      //   ไม่งั้นช่องยื่นหน้าบ้านเหนือแนว E กลับเข้ามาทับช่อง D-E (ไทยร่วมสมัย3 S0)
      if(d<0 && axis[nextLab]==null) d = -d;
      return { isNum, pos: axis[lab] + dir*d*g.ptPerM };
    };
    const ends = halves.map(h=>h.split(/(?<!\+)-/).map(endPos));
    if(ends.some(e=>!e.length || e.length>2 || e.some(v=>!v))) return null;
    if(ends.some(e=>e.length===2 && e[0].isNum!==e[1].isNum)) return null;
    const axisOf = isNum => (isNum === (g.numAxis==='x')) ? 'x' : 'y';   // ป้ายตัวเลขเรียงตามแกน x → เส้นกริดตัวเลขเป็นแนวตั้ง (ค่า x)
    // จุดตัด (ฐานราก/เสา): "E/1" · "B+2/3" — ป้ายเดียวทั้ง 2 ครึ่ง คนละแกน
    if(ends[0].length===1 && ends[1].length===1){
      if(ends[0][0].isNum===ends[1][0].isNum) return null;
      const n = ends.find(e=>e[0].isNum)[0].pos, l = ends.find(e=>!e[0].isNum)[0].pos;
      const [x, y] = axisOf(true)==='x' ? [n, l] : [l, n];
      return { kind:'point', x, y, x0:x, x1:x, y0:y, y1:y };
    }
    if(ends[0].length===2 && ends[1].length===2){
      const numHalf = ends.find(e=>e[0].isNum), letHalf = ends.find(e=>!e[0].isNum);
      if(!numHalf || !letHalf) return null;
      const nPos = numHalf.map(e=>e.pos).sort((a,b)=>a-b), lPos = letHalf.map(e=>e.pos).sort((a,b)=>a-b);
      const [xs, ys] = axisOf(true)==='x' ? [nPos, lPos] : [lPos, nPos];
      if(xs[1]-xs[0] < 1 || ys[1]-ys[0] < 1) return null;
      const wM = (xs[1]-xs[0])/g.ptPerM, hM = (ys[1]-ys[0])/g.ptPerM;
      return { kind:'cell', x0:xs[0], x1:xs[1], y0:ys[0], y1:ys[1], wM, hM, areaM2:wM*hM };
    }
    // เส้น: ครึ่งหนึ่ง = แนว (ป้ายเดียว) · อีกครึ่ง = ช่วง (2 ป้าย แกนตรงข้าม)
    const line = ends.find(e=>e.length===1), span = ends.find(e=>e.length===2);
    if(!line || !span || line[0].isNum===span[0].isNum) return null;
    const at = line[0].pos, [s0, s1] = span.map(e=>e.pos).sort((a,b)=>a-b);
    if(s1-s0 < 1) return null;
    const half = Math.max(BEAM_BAND_M*g.ptPerM, BEAM_BAND_MIN_PT)/2;
    const vertical = axisOf(line[0].isNum)==='x';   // แนวเป็นค่า x → คานวิ่งแนวตั้ง
    const p0 = vertical ? { x:at, y:s0 } : { x:s0, y:at }, p1 = vertical ? { x:at, y:s1 } : { x:s1, y:at };
    return { kind:'line', p0, p1, lenM:(s1-s0)/g.ptPerM,
      x0: vertical ? at-half : s0, x1: vertical ? at+half : s1, y0: vertical ? s0 : at-half, y1: vertical ? s1 : at+half };
  }
  // เดิม (PR #107) = ช่องพื้นเท่านั้น · ตอนนี้คืนแถบคานด้วย — ผู้เรียกที่ต้องการชนิดเดียวเช็ก .kind
  const rectOfGrid = (ref, g) => geomOfGrid(ref, g);

  // ชีตที่วางตามกริดได้ (ปุ่ม marker โครงสร้าง) — cat = หมวดใน SB_CAT_SHEETS (คลิก marker แล้วเลือกแถวถูกหมวด) · group = ชื่อในสรุป
  //   precast = ช่องเหมือนพื้นแต่ไม่ตรวจป้าย (ป้ายพื้นสำเร็จมักเป็นตัวอักษร+ลูกศร ไม่ใช่วงกลม → ตรวจแล้วเส้นประทุกช่อง = แจ้งเตือนหลอก)
  //   field = คอลัมน์ตำแหน่ง (grid ช่อง/เส้น · at จุดตัด/ช่วงผนัง เฟส 2) · legacy = เฟส 1: มีแถวแต่ไม่มีตำแหน่ง → หารหัส (OCR) แทน
  //   หมวดเฟส 2 ในผลถอดเก่า (ไม่มี at/grid) = ข้ามเงียบ ๆ เหมือนเดิม (ไม่ไล่ OCR เพิ่ม)
  const GRID_SHEETS = [
    { disc:'str',  sheet:'slabs_cip',      kind:'slab',    field:'grid', cat:'พื้นโครงสร้าง', group:'พื้นหล่อ', legacy:true },
    { disc:'str',  sheet:'slabs_precast',  kind:'precast', field:'grid', cat:'พื้นโครงสร้าง', group:'พื้นสำเร็จ', legacy:true },
    { disc:'str',  sheet:'beams',          kind:'beam',    field:'grid', cat:'คาน',          group:'คาน', legacy:true },
    { disc:'str',  sheet:'footings',       kind:'footing', field:'at',   cat:'ฐานราก',       group:'ฐานราก' },
    { disc:'str',  sheet:'columns',        kind:'column',  field:'at',   cat:'เสา',          group:'เสา' },
    { disc:'str',  sheet:'steel_columns',  kind:'column',  field:'at',   cat:'เสา',          group:'เสาเหล็ก' },
    { disc:'arch', sheet:'walls',          kind:'wall',    field:'runs', cat:'ผนัง',         group:'ผนัง' },
    { disc:'arch', sheet:'floor_finishes', kind:'room',    field:'grid', cat:'พื้นสถาปัตย์', group:'พื้น' },
    { disc:'arch', sheet:'ceilings',       kind:'room',    field:'grid', cat:'ฝ้าเพดาน',     group:'ฝ้า' },
    { disc:'arch', sheet:'doors',          kind:'opening', field:'at',   cat:'ประตู-หน้าต่าง', group:'ประตู' },
    { disc:'arch', sheet:'windows',        kind:'opening', field:'at',   cat:'ประตู-หน้าต่าง', group:'หน้าต่าง' },
  ];
  // sheets (sheetState / boqData.sheets) → แถวพร้อมวาง (มีตำแหน่ง + เลขหน้า) · คืนทุกแถวของชีต (ไว้นับว่าหมวดไหนวางไม่ได้)
  //   ห้อง (floor_finishes) ไม่มี code → ใช้ชื่อห้อง (room) เป็นป้าย
  function gridRowsFromSheets(sheets, disc){
    return GRID_SHEETS.filter(G=>!disc || G.disc===disc).map(G=>{
      const all = (Array.isArray(sheets && sheets[G.sheet]) ? sheets[G.sheet] : []).filter(r=>r && (r.code || r.room));
      const pos = r => r[G.field] || (G.field==='grid' ? r.gridline : '') || '';
      const rows = all.filter(r=>String(pos(r)).trim() && String(pos(r)).trim()!=='-' && Number(r.page_num)>=1)
        .map(r=>({ ...r, code: r.code || r.room, grid: pos(r), kind:G.kind, cat:G.cat, group:G.group, _src:{ sheet:G.sheet, idx:sheets[G.sheet].indexOf(r) } }));
      return { ...G, total: all.length, rows, codes: [...new Set(all.map(r=>r.code).filter(Boolean))] };
    });
  }
  // ขนาดที่จุดตัด (ม.) → ใช้ด้านสั้นเป็นจัตุรัส: ฐานราก = B×L ของแถว · เสา = หน้าตัด "0.30×0.40" · อ่านไม่ได้ → ค่ากลาง
  function pointSizeM(x){
    const r = x.r, num = v => { const n = Number(v); return Number.isFinite(n) && n>0 && n<10 ? n : null; };
    if(x.kind==='footing'){ const B = num(r.B), L = num(r.L) || B; return B ? [B, L] : [1.0, 1.0]; }
    const m = String(r.section||'').match(/(\d*\.?\d+)\s*[x×*]\s*(\d*\.?\d+)/i);
    if(m){ let a = Number(m[1]), b = Number(m[2]); const k = a>=50 ? 1000 : a>5 ? 100 : 1; return [a/k, b/k]; }   // "30x40" ซม. · "H-150x150" มม.
    return [0.3, 0.3];
  }

  /* ══════════ main ══════════ */
  // rows = แถวที่มี grid · แต่ละแถวบอกชนิดได้ด้วย kind:'slab'|'precast'|'beam' · cat (หมวดใน SB_CAT_SHEETS) · group (ชื่อในสรุป)
  //        ไม่บอก = แผ่นพื้นหล่อ (เหมือน PR #107) · ได้จาก gridRowsFromSheets()
  //   พื้นหล่อ = กรอบช่อง + ตรวจป้ายพื้นในช่อง (เส้นประ/วงแดง) · พื้นสำเร็จ = กรอบช่อง (ไม่ตรวจป้าย) · คาน = แถบตามเส้นกริด (ไม่ตรวจป้าย)
  // candPages = หน้าผังโครงสร้าง (route_map) ใช้หาหน้าใหม่ให้แถวพื้นที่เลขหน้าไม่ตรงผัง (คาน/พื้นสำเร็จย้ายตามพื้นหล่อหน้าเดิมเดียวกัน)
  async function sbBuildGridMarks({ storagePath, rows, candPages, onProgress }){
    const prog = (msg)=>{ try{ onProgress && onProgress({ msg }); }catch(e){} };
    if(!storagePath) throw new Error('ไม่มีไฟล์แบบ (storagePath) สำหรับวาง marker');
    const list = (rows||[]).map((r,ri)=>({ r, ri, kind: (r && ['beam','precast','footing','column','room','opening','wall'].includes(r.kind)) ? r.kind : 'slab',
        cat: (r && r.cat) || 'พื้นโครงสร้าง', group: (r && r.group) || 'พื้น',
        refs:String((r && r.grid)||'').split(/\s*,\s*/).filter(Boolean) }))
      .filter(x=>x.r && x.refs.length);
    const empty = { marks:{}, geom:[], stats:{ pages:0, gridPages:0, noGrid:[], rects:0, refs:0, unplaced:[], orphans:0, flagged:0, countDiff:[], moved:0, byGroup:{} } };
    if(!list.length) return empty;

    prog('ขอลิงก์ไฟล์แบบ…');
    if(!window.fetchSignedUrl) throw new Error('ยังโหลดตัวช่วยแบบไม่ครบ (fetchSignedUrl)');
    const url = await window.fetchSignedUrl(storagePath);
    if(!window.pdfjsLib) await loadScript(PDFJS_SRC);
    if(!window.pdfjsLib) throw new Error('โหลดตัวอ่าน PDF (pdf.js) ไม่ได้');
    window.pdfjsLib.GlobalWorkerOptions.workerSrc = window.pdfjsLib.GlobalWorkerOptions.workerSrc || PDFJS_WORKER;
    const doc = await window.pdfjsLib.getDocument({ url, isEvalSupported: false }).promise; // isEvalSupported:false = ปิดช่องโหว่ CVE-2024-4367 ของ pdf.js 3.x (ฟอนต์ใน PDF สั่งรันโค้ดได้)

    let worker = null;   // Tesseract โหลดเฉพาะเมื่อหน้าไม่มีป้ายกริดเป็นข้อความ (ครั้งแรกดาวน์โหลดสักครู่ · ครั้งต่อไปเบราว์เซอร์จำไว้)
    const getWorker = async () => {
      if(worker) return worker;
      prog('โหลด Tesseract (อ่านป้ายกริดในวง)…');
      if(!window.Tesseract) await loadScript(TESS_CDN);
      if(!window.Tesseract) throw new Error('โหลด Tesseract ไม่ได้');
      worker = await window.Tesseract.createWorker('eng');
      await worker.setParameters({ tessedit_char_whitelist:'ABCDEFGHJKLMNPQRSTUVWXYZ0123456789', tessedit_pageseg_mode:'10' });
      return worker;
    };
    const rotHint = { rot:null };
    const within = (c,q) => c.cx>q.x0 && c.cx<q.x1 && c.cy>q.y0 && c.cy<q.y1;

    // วงป้ายพื้น = กลุ่มวงรัศมีเดียวกัน (3pt ≤ r < วงกริด) ที่มีวง "กลางช่องกริด" มากสุด
    //   (ป้ายพื้นอยู่กลางช่อง · ป้ายเสา/ฐานรากอยู่บนจุดตัดเส้นกริด → แยกผังพื้นออกจากผังเสา/ฐานรากได้โดยไม่ต้อง OCR)
    //   คืนทุกวงของรัศมีนั้น — ป้ายพื้นบางป้ายวางทับเส้นกริด (บ้านดุง GS1 โรงจอดรถอยู่บนแนว C) ต้องนับด้วย
    const slabLabels = (circles, gridR, xs, ys) => {
      const inCell = c => xs.every(x=>Math.abs(c.cx-x)>c.r*1.5) && ys.every(y=>Math.abs(c.cy-y)>c.r*1.5);
      const byR = {};
      circles.filter(c=>c.r>=3 && c.r<gridR-0.5).forEach(c=>{ const k=c.r.toFixed(1); (byR[k]=byR[k]||{ all:[], inCell:0 }).all.push(c); if(inCell(c)) byR[k].inCell++; });
      const top = Object.values(byR).filter(o=>o.inCell>0).sort((a,b)=>b.inCell-a.inCell)[0];
      return top ? Object.assign(top.all, { inCell: top.inCell }) : Object.assign([], { inCell: 0 });
    };
    // วิเคราะห์หน้า (ครั้งเดียวต่อหน้า): เส้นกริด + วงป้ายพื้น
    //   quick = ตอนค้นหน้าใหม่: ไฟล์ไม่มีข้อความต้องมีวงป้ายกริด + ป้ายกลางช่อง ≥2 ก่อน ถึงจะ OCR (OCR หน้าละ ~1 วิ)
    const cache = new Map();
    const analyze = async (pn, quick) => {
      if(cache.has(pn)) return cache.get(pn);
      if(!(pn>=1 && pn<=doc.numPages)) return null;
      const page = await doc.getPage(pn);
      const vp = page.getViewport({ scale:1 });
      const circles = await vectorCircles(page);
      const texts = await flatTexts(page);
      let g = await textGrid(page, texts);
      if(!g){
        if(quick){
          const L = gridBubbleLines(circles);
          if(!L || slabLabels(circles, L.row.r, L.row.items.map(c=>c.cx), L.col.items.map(c=>c.cy)).inCell < 2){ cache.set(pn, null); return null; }
        }
        prog(`หน้า ${pn} — อ่านป้ายกริดในวง…`);
        g = await vectorGrid(page, circles, getWorker, rotHint);
      }
      let res = null;
      if(g){
        if(!g.texts) g.texts = texts;   // กริดจากวงเวกเตอร์ แต่ป้ายเสา/ประตูเป็นข้อความ → ใช้หาป้ายได้
        const numPos = Object.values(g.axes.num), letPos = Object.values(g.axes.let);
        const [xs, ys] = g.numAxis==='x' ? [numPos, letPos] : [letPos, numPos];
        res = { pn, g, vp, page, labels: slabLabels(circles, g.bubbleR || Infinity, xs, ys), wallTags: wallTagsOf(circles.tris || [], circles.glyphs, circles),
          circles, hexes: circles.hexes || [], polys: circles.polys || [] };
      }
      cache.set(pn, res);
      return res;
    };
    // แถวพื้นรับเฉพาะช่อง · แถวคานรับเฉพาะเส้น (คานเขียนเป็นช่อง/พื้นเขียนเป็นเส้น = วางไม่ได้)
    //   ฐานราก/เสา = จุดตัด · ประตู/หน้าต่าง = ช่วงผนัง (เส้น) · ห้อง/พื้นสำเร็จ = ช่อง
    const GEOM_OF = { slab:'cell', precast:'cell', room:'cell', beam:'line', wall:'line', opening:'line', footing:'point', column:'point' };
    const placeOn = (x, A) => x.refs.map(ref=>{ const q = geomOfGrid(ref, A.g);
      return { ref, q: (q && q.kind===GEOM_OF[x.kind]) ? q : null }; });
    const cover = (x, A) => x.kind!=='slab' ? 0 : placeOn(x, A).filter(p=>p.q && A.labels.some(c=>within(c,p.q))).length;
    // ช่วงผนัง (เส้น) → แนว + ช่วง · ป้ายอยู่ข้างแนวไม่เกิน maxOffM · ในช่วง ±0.3 ม.
    const spanOf = (q) => { const vert = Math.abs(q.p0.x-q.p1.x) < Math.abs(q.p0.y-q.p1.y);
      return { vert, line: vert ? q.p0.x : q.p0.y, s0: Math.min(vert ? q.p0.y : q.p0.x, vert ? q.p1.y : q.p1.x), s1: Math.max(vert ? q.p0.y : q.p0.x, vert ? q.p1.y : q.p1.x) }; };
    const OPEN_TAG_OFF_M = 1.5;
    // ป้ายประตู/หน้าต่างแบบเส้น: ⬡ (หน้าต่าง) / ◯ (ประตู) ขนาดป้าย 0.25–0.8 ม. ที่อยู่ข้างช่วงผนังของแถวประตู/หน้าต่างในหน้านี้ → อ่านเลขในป้าย
    //   เลข = รหัสในตาราง (W1 ↔ ⬡1 · D2 ↔ ◯2 · prompt #158 ทำรหัสเลขล้วนเป็น D{n}/W{n}) · อ่านไม่ออก = digit null (ยังใช้ได้ตามระยะ)
    const glyphNN = (a, b) => a.reduce((s,p)=>s+Math.min(...b.map(q=>Math.hypot(p[0]-q[0], p[1]-q[1]))), 0)/a.length;
    const sameGlyph = (a, b) => Math.abs(a.length-b.length) <= Math.max(3, 0.2*a.length) && glyphNN(a, b) <= 0.35 && glyphNN(b, a) <= 0.35;
    async function openTagsOf(A, opens, getWorker){
      const m = A.g.ptPerM, bubR = A.g.bubbleR || Infinity;
      const spans = opens.flatMap(x=>placeOn(x, A).map(p=>p.q).filter(Boolean)).map(spanOf);
      const near = t => spans.some(S=>{ const off = (S.vert ? t.cx : t.cy) - S.line, along = S.vert ? t.cy : t.cx;
        return Math.abs(off) <= OPEN_TAG_OFF_M*m && along >= S.s0-0.3*m && along <= S.s1+0.3*m; });
      const cands = [
        ...(A.hexes||[]).filter(h=>h.size>=0.25*m && h.size<=0.8*m).map(h=>({ kind:'hex', cx:h.cx, cy:h.cy, r:h.size/2 })),
        ...(A.circles||[]).filter(c=>c.r>=0.12*m && c.r<=0.4*m && c.r<bubR-0.5).map(c=>({ kind:'circ', cx:c.cx, cy:c.cy, r:c.r })),
      ].filter(near).filter((t,i,arr)=>!arr.slice(0,i).some(o=>o.kind===t.kind && Math.hypot(o.cx-t.cx, o.cy-t.cy) < t.r*0.5));
      if(!cands.length) return [];
      // ลายเส้นเลขในป้าย (เทียบจากจุดศูนย์กลาง ปัด 0.25 pt) — ป้ายเลขเดียวกันในแบบ = ก๊อปบล็อกเดียวกัน ลายเส้นตรงกันเป๊ะ
      //   → จัดกลุ่มแล้วโหวตเลขทั้งกลุ่ม: แก้ตัวที่ OCR อ่านพลาด (ฟอนต์ CAD เลข 3 หัวตัด → "5") + เติมตัวที่อ่านไม่ออก
      const glyphs = (A.circles && A.circles.glyphs) || [];
      //   จุดของเส้นเลขเทียบจากจุดกึ่งกลางของเส้นเลขเอง (ศูนย์กลางป้ายคลาดกันเศษ pt) · เหมือนกัน = ระยะจุดใกล้สุดเฉลี่ย ≤0.35 pt ทั้งสองทาง
      cands.forEach(t=>{
        const R = t.r*0.85;
        const pts = glyphs.filter(g=>{ const xs = g.map(p=>p[0]), ys = g.map(p=>p[1]);
            return Math.max(Math.max(...xs)-Math.min(...xs), Math.max(...ys)-Math.min(...ys)) < t.r*1.4 && g.every(p=>Math.hypot(p[0]-t.cx, p[1]-t.cy) <= R); }).flat();
        if(pts.length < 3){ t.sig = null; return; }
        const mx = pts.reduce((a,p)=>a+p[0],0)/pts.length, my = pts.reduce((a,p)=>a+p[1],0)/pts.length;
        t.sig = pts.map(p=>[p[0]-mx, p[1]-my]);
      });
      let worker = null;
      try{ worker = await getWorker(); }catch(e){ return cands; }   // ไม่มี OCR → ใช้ตามระยะอย่างเดียว
      // อ่านเฉพาะตัวเลข (ชุดตัวอักษรเดิมอ่าน 5 เป็น S · 1 เป็น J) → คืนชุดเดิมหลังอ่าน (ป้ายกริดใช้ตัวอักษร)
      try{ await worker.setParameters({ tessedit_char_whitelist:'0123456789' }); }catch(e){}
      try{
        for(const t of cands){
          try{
            const R = t.r*1.15, S = Math.max(4, Math.min(16, 70/t.r));
            const cv = await renderRegion(A.page, t.cx-R, t.cy-R, t.cx+R, t.cy+R, S);
            // ครอปวงในป้าย 2 ขนาด: เส้นผนัง/ขอบวงที่พาดเข้ามาทำให้อ่านพลาด → ลองวงแคบลง
            //   อ่าน 2 ขนาดเสมอ → ใช้เมื่อ 2 ขนาดอ่านตรงกัน หรือขนาดใดขนาดหนึ่งมั่นใจ ≥80
            //   (อ่านผิดแย่กว่าอ่านไม่ออก: เลขผิด = ไปเกาะป้ายบานอื่น · ตรวจจริง ร่วมสมัย5: "2" มีเส้นผนังพาด → "21" · "3" → "5")
            //   เลข 2 หลักต้องมั่นใจ ≥80 (เส้นพาดข้างเลขมักกลายเป็น "1" ต่อท้าย)
            const reads = [];
            for(const k of [1, 0.75]){
              const crop = cropRot(cv, R*S, R*S, t.r*S*k, 0);
              const { data } = await worker.recognize(crop);
              const d = String(data.text||'').replace(/[^0-9]/g,''), conf = data.confidence||0;
              reads.push({ d: (d.length===1 || (d.length===2 && conf>=80)) ? String(Number(d)) : null, conf });
            }
            const [a, b] = reads;
            t.digit = (a.d && a.d===b.d) ? a.d : (a.d && a.conf>=80 && !(b.d && b.d!==a.d)) ? a.d : (b.d && b.conf>=80 && !(a.d && a.d!==b.d)) ? b.d : null;
          }catch(e){ t.digit = null; }
        }
      } finally {
        try{ await worker.setParameters({ tessedit_char_whitelist:'ABCDEFGHJKLMNPQRSTUVWXYZ0123456789' }); }catch(e){}
      }
      cands.forEach(t=>{ t.digit0 = t.digit; });
      return cands;
    }
    // โหวตเลขข้ามทุกหน้า (แบบชุดเดียวกันใช้บล็อกป้ายเดียวกันทุกผัง): กลุ่มลายเส้นเดียวกัน + ชนิดป้ายเดียวกัน
    //   เลขที่ได้เสียงข้างมากเกินครึ่งของตัวที่อ่านได้ → ใช้กับทุกตัวในกลุ่ม (แก้ 3 ที่อ่านเป็น 5 · เติมตัวที่อ่านไม่ออก) · เสมอ = คงค่าที่อ่านเอง
    function voteTagDigits(tags){
      const groups = [];
      tags.filter(t=>t.sig).forEach(t=>{ const g = groups.find(g=>g[0].kind===t.kind && sameGlyph(g[0].sig, t.sig)); if(g) g.push(t); else groups.push([t]); });
      for(const g of groups){
        const votes = new Map(); g.forEach(t=>{ if(t.digit0) votes.set(t.digit0, (votes.get(t.digit0)||0)+1); });
        const total = [...votes.values()].reduce((a,n)=>a+n, 0), top = [...votes.entries()].sort((a,b)=>b[1]-a[1]);
        if(top.length && top[0][1]*2 > total) g.forEach(t=>{ t.digit = top[0][0]; });
      }
      if(window.__SB_TAGS) window.__SB_TAGS.push(...tags);   // เครื่องมือตรวจ (tools/grid-marks) ใช้ดูผลอ่านเลข
    }
    // ป้ายแบบเส้นของบานนี้: ชนิดป้ายตรงกลุ่ม (หน้าต่าง ⬡ · ประตู ◯) · เลขต้องตรงรหัส (อ่านได้แต่ไม่ตรง = ไม่ใช่) · ใกล้แนวสุด · ป้ายใช้ครั้งเดียว
    const openVecTag = (A, x, q, used) => {
      const tags = A.openTags || []; if(!tags.length) return null;
      const want = x.group==='หน้าต่าง' ? 'hex' : 'circ', num = (String(x.r.code||'').match(/(\d+)\s*$/) || [])[1];
      const S = spanOf(q), m = A.g.ptPerM;
      let best = null;
      for(const t of tags){
        if(t.kind!==want || used.has(t)) continue;
        if(t.digit && num && t.digit!==String(Number(num))) continue;
        const off = (S.vert ? t.cx : t.cy) - S.line, along = S.vert ? t.cy : t.cx;
        if(Math.abs(off) > OPEN_TAG_OFF_M*m || along < S.s0-0.3*m || along > S.s1+0.3*m) continue;
        const score = Math.abs(off) + (along < S.s0 || along > S.s1 ? 10*m : 0) - (t.digit && num ? 0.5*m : 0);
        if(!best || score < best.score) best = { t, off, along, vert:S.vert, line:S.line, score };
      }
      if(best) used.add(best.t);
      return best;
    };
    // กรอบฐานรากที่วาดในแบบ ณ จุดตัด: รูปปิดที่ครอบจุด + ขนาด ≈ B×L ของแถว (±25% สลับแกนได้) → marker ทับรูปจริง (F6 ผืนผ้า · F10 หกเหลี่ยม)
    //   ไม่เจอ = null → จัตุรัสด้านสั้นแบบเดิม
    const outlineAt = (A, q, [B, L]) => {
      const m = A.g.ptPerM, tol = 0.15*m; let best = null;
      for(const p of (A.polys||[])){
        if(q.x < p.x0-tol || q.x > p.x1+tol || q.y < p.y0-tol || q.y > p.y1+tol) continue;
        const w = (p.x1-p.x0)/m, h = (p.y1-p.y0)/m;
        const err = Math.min(Math.max(Math.abs(w-B)/B, Math.abs(h-L)/L), Math.max(Math.abs(w-L)/L, Math.abs(h-B)/B));
        if(err <= 0.25 && (!best || err < best.err)) best = { ...p, err };
      }
      return best;
    };

    const marks = {}, unplaced = [], countDiff = [], byGroup = {};
    let rectsN = 0, refsN = 0, orphansN = 0, flagged = 0, moved = 0;
    // snap = วาง marker ตามอะไร (ไว้ตรวจความแม่น): ป้ายข้อความ / ป้ายเส้นอ่านเลขได้ / ป้ายเส้นตามระยะ / จุดกลางช่วง · กรอบฐานรากในแบบ / จัตุรัส
    const geom = [];   // ขนาดที่วัดจากกริดต่อช่องที่วางได้ { ri, ref, kind, wM, hM, lenM, page } — ใช้แก้ขนาดพื้นที่ AI กรอก (sbFixSlabsFromGrid)
    const snap = { openText:0, openTagDigit:0, openTagNear:0, openMid:0, footOutline:0, footSquare:0 };
    const ownPages = [...new Set(list.map(x=>Number(x.r.page_num)).filter(p=>p>=1))].sort((a,b)=>a-b);
    const byA = new Map();
    try{
      // 1) หน้าตามผลถอด (page_num) — วางได้อย่างน้อย 1 ช่อง = อยู่หน้านั้น
      for(let i=0;i<ownPages.length;i++){
        prog(`หน้า ${ownPages[i]} (${i+1}/${ownPages.length}) — หาเส้นกริด…`);
        await analyze(ownPages[i], false);
      }
      const assigned = new Map(), lost = [];
      list.forEach(x=>{
        const A = cache.get(Number(x.r.page_num));
        if(A && placeOn(x, A).some(p=>p.q)) assigned.set(x, A); else lost.push(x);
      });
      // แถวซ้ำ (ชนิด + รหัส + ตำแหน่งเดียวกัน) ที่ชี้หน้าไม่มีกริด ขณะที่อีกแถววางได้แล้ว → ข้ามเงียบ ๆ
      //   ร่วมสมัย5: AI ออกเสาชุดเดียวกัน 3 หน้า (31 · 34 · 37) — หน้า 37 ไม่มีกริด → เคยถูกย้ายไปซ้อนหน้าอื่น / แจ้ง "วางไม่ได้" หลอก
      //   ไม่ใช้กับพื้นหล่อ (ข้อ 2 ย้ายหน้าด้วยป้ายพื้นได้แม่นกว่า — S1 ชั้น 2 ที่ grid เดียวกับชั้น 1 ต้องไปผังชั้น 2 ไม่ใช่หาย)
      //   "ชั้น N" ใน location ต่างกัน = คนละแถวจริง (ประตู D1 "E/1-2" ชั้น 1 กับชั้น 2) → ไม่นับว่าซ้ำ
      const floorOf = x => { const m = String(x.r.location||'').match(/ชั้น\s*(\d)/); return m ? m[1] : ''; };
      const sigOf = x => x.kind+'|'+x.r.code+'|'+x.refs.join(',')+'|'+floorOf(x);
      const placedSig = new Set([...assigned.keys()].map(sigOf));
      for(let i=lost.length-1; i>=0; i--) if(lost[i].kind!=='slab' && placedSig.has(sigOf(lost[i]))){ lost[i].dup = true; lost.splice(i, 1); }
      // 2) แถวที่เลขหน้าไม่ตรงผัง (เช่นถอดไฟล์ตะแคง) → ลองหน้าผังโครงสร้างอื่น เลือกหน้าที่ช่องครอบป้ายพื้นได้มากสุด
      //    เสมอกัน → ใช้ "ชั้น N" ในตำแหน่ง เลือกหน้าลำดับที่ N (ผังพื้นมักเรียงชั้น 1, 2, …)
      const lostSlab = lost.filter(x=>x.kind==='slab'), lostBeam = lost.filter(x=>x.kind!=='slab');
      if(lostSlab.length){
        // หน้าที่วิเคราะห์แล้ว (หน้าของแถวอื่น) ครอบป้ายได้ครบทุกช่อง → ไม่ต้องไล่หน้าอื่น (ไฟล์ 40 หน้า ไล่ทั้งชุดหลายวินาที)
        const fullHere = (x) => [...cache.values()].some(A=>A && A.labels.length && cover(x, A)===x.refs.length);
        if(!lostSlab.every(fullHere)){
          const cands = [...new Set((candPages||[]).map(Number))].filter(p=>p>=1 && p<=doc.numPages && !cache.has(p)).sort((a,b)=>a-b);
          for(let i=0;i<cands.length;i++){ prog(`หาหน้าผังพื้น (${i+1}/${cands.length})…`); await analyze(cands[i], true); }
        }
        const found = [...cache.values()].filter(A=>A && A.labels.length).sort((a,b)=>a.pn-b.pn);
        lostSlab.forEach(x=>{
          const sc = found.map(A=>({ A, n: cover(x, A) })).filter(o=>o.n>0);
          if(!sc.length) return;
          const top = Math.max(...sc.map(o=>o.n)), tied = sc.filter(o=>o.n===top).map(o=>o.A);
          const fl = String(x.r.location||'').match(/ชั้น\s*(\d)/);
          assigned.set(x, (fl && tied[Number(fl[1])-1]) || tied[0]); moved++;
        });
      }
      // คาน/พื้นสำเร็จ/ฐานราก/เสา/ห้อง/ประตู ไม่มีป้ายให้เทียบ → ย้ายตามแถวพื้นหล่อที่เลขหน้าเดิมเดียวกัน (AI ใส่เลขหน้าผิดทั้งชั้นพร้อมกัน เช่นไฟล์ตะแคง)
      if(lostBeam.length){
        const remap = new Map();
        assigned.forEach((A, x)=>{ const p = Number(x.r.page_num); if(x.kind==='slab' && A.pn!==p){
          const m = remap.get(p) || new Map(); m.set(A, (m.get(A)||0)+1); remap.set(p, m); } });
        lostBeam.forEach(x=>{
          const m = remap.get(Number(x.r.page_num)); if(!m) return;
          const A = [...m.entries()].sort((a,b)=>b[1]-a[1])[0][0];
          if(placeOn(x, A).some(p=>p.q)){ assigned.set(x, A); moved++; }
        });
      }
      // 3) ยังไม่มีหน้า (เลขหน้าชี้หน้ารายละเอียด/หน้าไม่มีกริด แต่พื้นอยู่หน้าถูก → ข้อ 2 ไม่ย้าย · บ้านดุง-8: คานทั้งชุด page 24)
      //    → เลือกผังชั้นจากหน้าที่พื้นวางได้ (เรียงชั้นล่าง→บน): "ชั้น N" ในตำแหน่ง → ชั้น N · ไม่บอก → เดาจากรหัส/ชนิด
      //    GB/ฐานราก/เสา = ชั้นล่าง · RB = ผังถัดจากชั้นบนสุด (ผังคานหลังคา ถ้ามีกริด) · คานอื่น/พื้นสำเร็จ = ชั้น 2 (ถ้ามี)
      //    ชั้นที่เดาวางไม่ได้ → ลองชั้นใกล้สุดถัดไป
      const still = lostBeam.filter(x=>!assigned.has(x));
      if(still.length){
        const slabPage = new Set(), floors = [];
        assigned.forEach((A, x)=>{ if((x.kind==='slab' || x.kind==='precast') && !slabPage.has(A)){ slabPage.add(A); floors.push(A); } });
        if(!floors.length){
          // ไม่มีพื้นให้อ้าง → หน้ากริดที่วิเคราะห์แล้ว · ยังไม่มีเลย → ไล่หน้าผังโครงสร้าง (route_map)
          if(![...cache.values()].some(Boolean)){
            const cands = [...new Set((candPages||[]).map(Number))].filter(p=>p>=1 && p<=doc.numPages && !cache.has(p)).sort((a,b)=>a-b);
            for(let i=0;i<cands.length;i++){ prog(`หาหน้าผัง (${i+1}/${cands.length})…`); await analyze(cands[i], true); }
          }
          [...cache.values()].filter(Boolean).forEach(A=>floors.push(A));
        } else if(floors.length===1){
          // พื้นทุกแถวอยู่หน้าเดียว (อารย3 รอบแรก) → หน้ากริดที่ถัดขึ้นไป (วิเคราะห์ไว้แล้ว) = ผังชั้นบน/หลังคา
          [...cache.values()].filter(A=>A && A.pn>floors[0].pn).forEach(A=>floors.push(A));
        }
        floors.sort((a,b)=>a.pn-b.pn);
        if(floors.length){
          const top = floors[floors.length-1];
          let roof = null, roofTried = false;
          const roofPage = async () => {
            if(!roofTried){ roofTried = true; const R = await analyze(top.pn+1, false); roof = (R && R!==top) ? R : null; }
            return roof;
          };
          // ฐานราก: หน้าที่เสาวางได้ตามเลขหน้าของตัวเอง (= ผังฐานราก-เสาตอม่อ) มาก่อนหน้าพื้น
          //   ร่วมสมัย5: ฐานรากชี้หน้ารูปขยาย 43–45 · พื้นมีแค่ผังคานอะเส (หน้า 34) → เดิมฐานรากไปลงผังอะเส · เสาอยู่หน้า 31 = ผังฐานราก
          const colPages = [...new Set([...assigned.entries()].filter(([x2, A2])=>x2.kind==='column' && A2.pn===Number(x2.r.page_num)).map(([, A2])=>A2))];
          for(const x of still){
            const fl = String(x.r.location||'').match(/ชั้น\s*(\d)/), code = String(x.r.code||'').toUpperCase();
            let idx = fl ? Number(fl[1])-1
              : (x.kind==='footing' || x.kind==='column' || /^GB/.test(code)) ? 0
              : /^RB/.test(code) ? floors.length
              : 1;
            const order = [];
            if(x.kind==='footing' && !fl){
              // วางได้มากสุดก่อน
              //   เสมอ → หน้าที่มีพื้น/คานน้อยกว่าก่อน (ผังฐานราก-เสาตอม่อไม่มีพื้น) → หน้าต่ำสุด
              const busy = A2 => [...assigned.entries()].filter(([x2, A3])=>A3===A2 && (x2.kind==='slab' || x2.kind==='precast' || x2.kind==='beam')).length;
              colPages.map(A2=>({ A2, n: placeOn(x, A2).filter(p=>p.q).length, b: busy(A2) })).filter(o=>o.n>0)
                .sort((a,b)=>b.n-a.n || a.b-b.b || a.A2.pn-b.A2.pn).forEach(o=>order.push(o.A2));
            }
            if(idx>=floors.length && /^RB/.test(code)){ const R = await roofPage(); if(R) order.push(R); }
            idx = Math.max(0, Math.min(idx, floors.length-1));
            floors.map((A,i)=>({ A, d:Math.abs(i-idx) })).sort((a,b)=>a.d-b.d).forEach(o=>order.push(o.A));
            const A = order.find(A=>placeOn(x, A).some(p=>p.q));
            if(A){ assigned.set(x, A); moved++; }
          }
        }
      }
      // ป้ายประตู/หน้าต่างที่เป็นเส้น (แบบกรมฯ: หน้าต่าง = ⬡ มีเลข · ประตู = ◯ มีเลข ข้างบาน) — อ่านเลขก่อนปิด Tesseract
      //   ใช้เมื่อหาป้ายข้อความ "W2"/"D2" ไม่เจอ (openLabel) → วางที่ป้ายจริงแทนจุดกลางช่วง
      for(const A of new Set(assigned.values())){
        if(!A || A.openTags) continue;
        const opens = list.filter(x=>x.kind==='opening' && assigned.get(x)===A);
        if(!opens.length || (A.g.texts||[]).some(t=>/^[DW]\d{1,2}$/i.test(String(t.s).trim()))) { A.openTags = []; continue; }
        prog(`หน้า ${A.pn} — อ่านเลขป้ายประตู/หน้าต่าง…`);
        A.openTags = await openTagsOf(A, opens, getWorker);
      }
      voteTagDigits([...new Set(assigned.values())].flatMap(A=>(A && A.openTags) || []));
      list.forEach(x=>{
        if(x.dup) return;   // แถวซ้ำที่วางแล้วอีกแถว — ไม่นับ ไม่แจ้ง
        refsN += x.refs.length;
        const G = byGroup[x.group] || (byGroup[x.group] = { kind:x.kind, cat:x.cat, rows:0, refs:0, rects:0, unplaced:0 });
        G.rows++; G.refs += x.refs.length;
        const n = Number(x.r.count);
        if(x.kind!=='wall' && Number.isFinite(n) && n>0 && x.refs.length!==n) countDiff.push(`${x.r.code} ${x.refs.length} ${x.kind==='beam'?'ช่วง':x.kind==='footing'||x.kind==='column'?'จุด':x.kind==='opening'?'บาน':'ช่อง'}/จำนวน ${n}`);
        const A = assigned.get(x);
        if(!A){ x.refs.forEach(ref=>unplaced.push(`${x.r.code} "${ref}"`)); G.unplaced += x.refs.length; return; }
        if(!byA.has(A)) byA.set(A, []);
        byA.get(A).push(x);
      });
    } finally {
      try{ worker && await worker.terminate(); }catch(e){}
      try{ doc.destroy && doc.destroy(); }catch(e){}
    }

    // คาน/ฐานราก/เสา/ประตู-หน้าต่าง: สีตามรหัส (B2 ทุกช่วงสีเดียวกัน) · พื้น/ห้อง: สีตามแถวเหมือนเดิม
    // สี (ตามภาพตัวอย่างเจ้าของ 2026-11-04): ฐานราก = ฟ้าอมเขียว · เสา = วงแดงรอบป้าย · พื้น = สีตามรหัส
    //   (พื้นบนดิน G…/S0 ฟ้า · พื้นสำเร็จ SP/PS ชมพู · S1 ส้ม · S2 ม่วง · ST บันได แดง) ทึบขึ้น + หดเข้าจากแนวคาน
    //   คาน/ผนัง/ประตู: สีตามรหัสจากชุด COLORS เหมือนเดิม · ห้อง: สีตามแถวเหมือนเดิม
    //   2026-11-05 เจ้าของ: สีเดิมฐานรากฟ้า 5 เฉดกลืนกัน ไม่สวย → ชุดสีต่างโทนชัด (คราม/เขียวหัวเป็ด/อำพัน/ม่วง/ฟ้า/เขียวมะนาว) + พื้นทึบ 0.24 ให้เห็นเส้นแบบใต้ marker
    const FOOT_COLORS = ['#4f46e5','#0d9488','#d97706','#7c3aed','#0284c7','#65a30d'], COL_COLOR = '#dc2626';
    const footColor = new Map(), footColorOf = (code) => { if(!footColor.has(code)) footColor.set(code, FOOT_COLORS[footColor.size % FOOT_COLORS.length]); return footColor.get(code); };
    // ป้ายรหัสเสาใกล้จุดตัด: ข้อความแนวนอนที่มีรหัสตรงตัว ("F1,C1" · "C1") ห่าง ≤1.5 ม. → ตำแหน่งตัวรหัสในข้อความ + รัศมีตามความสูงตัวอักษร
    const labelNear = (A, code, q, used) => {
      const texts = A.g.texts || [], c = String(code||'').trim(); if(!texts.length || !c) return null;
      const esc = c.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
      const re = new RegExp('(^|[^A-Z0-9])' + esc + "(?![A-Z0-9'’])", 'i');   // C1 ≠ C10 / C1'
      let best = null;
      for(const t of texts){
        const m = String(t.s).match(re); if(!m) continue;
        const idx = m.index + m[1].length, n = String(t.s).length || 1;
        const x = (t.cx - t.w/2) + t.w*(idx + c.length/2)/n, y = t.cy, d = Math.hypot(x-q.x, y-q.y);
        if(d > 1.5*A.g.ptPerM || (best && d >= best.d) || used.has(t.cx+','+t.cy+','+idx)) continue;
        best = { x, y, d, r: Math.max(t.h*0.9, t.w*c.length/n*0.65), key: t.cx+','+t.cy+','+idx };
      }
      if(best) used.add(best.key);
      return best;
    };
    const SLAB_COLOR = [[/^ST/i,'#dc2626'], [/^(SP|PS)/i,'#ec4899'], [/^(G|S-?0)/i,'#3b82f6'], [/^S-?1/i,'#f97316'], [/^S-?2/i,'#a855f7'], [/^S-?3/i,'#16a34a']];
    const slabColor = new Map(), slabColorOf = (code) => {
      if(!slabColor.has(code)){ const hit = SLAB_COLOR.find(([re])=>re.test(String(code||''))); slabColor.set(code, hit ? hit[1] : COLORS[slabColor.size % COLORS.length]); }
      return slabColor.get(code);
    };
    // คาน = โทนเข้ม (ไม่ชนสีพื้นที่ทับอยู่ เช่น B2 ชมพูกลืน SP)
    const BEAM_COLORS = ['#1e3a8a','#065f46','#9a3412','#581c87','#155e75','#713f12','#334155','#14532d'];
    const codeColor = new Map(), BY_CODE = new Set(['beam','wall','opening']);
    // ประตู/หน้าต่าง: สีตามรหัส (ภาพตัวอย่างเจ้าของ 2026-11-04: W2 แดง · W1 เขียว · W4 ฟ้า · D2 ส้ม …)
    const OPEN_COLORS = ['#dc2626','#16a34a','#2563eb','#ea580c','#ca8a04','#db2777','#9333ea','#0891b2','#c084fc','#65a30d'];
    const openColor = new Map(), openColorOf = (code) => { if(!openColor.has(code)) openColor.set(code, OPEN_COLORS[openColor.size % OPEN_COLORS.length]); return openColor.get(code); };
    // ป้ายประตู/หน้าต่างในแบบ (ข้อความ "W2"/"D2" ตรงตัว) ที่อยู่ข้างช่วงผนัง at: ห่างแนว ≤1.2 ม. · อยู่ในช่วง ±0.3 ม. · ป้ายหนึ่งใช้ครั้งเดียว
    //   คืน { t, along = ตำแหน่งบนแนว, off = ระยะป้ายจากแนว (มีเครื่องหมาย), vert } · ไม่มีข้อความ/ไม่เจอ = null → วางจุดกลางช่วงแบบเดิม
    const openLabel = (A, code, q, used) => {
      const texts = A.g.texts || [], c = String(code||'').trim().toUpperCase(); if(!texts.length || !c) return null;
      const vert = Math.abs(q.p0.x-q.p1.x) < Math.abs(q.p0.y-q.p1.y), m = A.g.ptPerM;
      const line = vert ? q.p0.x : q.p0.y, s0 = Math.min(vert ? q.p0.y : q.p0.x, vert ? q.p1.y : q.p1.x), s1 = Math.max(vert ? q.p0.y : q.p0.x, vert ? q.p1.y : q.p1.x);
      let best = null;
      for(const t of texts){
        if(used.has(t) || String(t.s).trim().toUpperCase()!==c) continue;
        const off = (vert ? t.cx : t.cy) - line, along = vert ? t.cy : t.cx;
        if(Math.abs(off) > 1.2*m || along < s0-0.3*m || along > s1+0.3*m) continue;
        const score = Math.abs(off) + (along < s0 || along > s1 ? 10*m : 0);   // ป้ายในช่วงมาก่อน — ป้ายปลายช่วงข้างเคียงไม่ถูกแย่ง
        if(!best || score < best.score) best = { t, off, along, vert, line, score };
      }
      if(best) used.add(best.t);
      return best;
    };
    const LAYER = { slab:0, precast:0, room:0, beam:1, wall:1, footing:2, column:3, opening:3 };
    for(const [A, xs] of byA){
      const { pn, vp, labels } = A, pageMarks = [], rects = [], wallRuns = [];
      // ประตู/หน้าต่างหลายบานบนช่วงผนังเดียวกัน → กระจายตามลำดับ (บานที่ k จาก n อยู่ที่ (k+1)/(n+1) ของช่วง)
      const spanN = new Map(), spanK = new Map(), usedLab = new Set();
      xs.filter(x=>x.kind==='opening').forEach(x=>x.refs.forEach(ref=>spanN.set(ref, (spanN.get(ref)||0)+1)));
      // พื้นก่อน คานทีหลัง จุดบนสุด → แถบคาน/จุดเล็กอยู่บนกรอบใหญ่ (กดโดนได้)
      [...xs].sort((a,b)=>(LAYER[a.kind]||0)-(LAYER[b.kind]||0)).forEach(x=>{
        const G = byGroup[x.group];
        const checked = x.kind==='slab';
        if(BY_CODE.has(x.kind) && !codeColor.has(x.r.code)) codeColor.set(x.r.code, (x.kind==='beam' ? BEAM_COLORS : COLORS)[codeColor.size % (x.kind==='beam' ? BEAM_COLORS : COLORS).length]);
        const color = x.kind==='footing' ? footColorOf(x.r.code) : x.kind==='column' ? COL_COLOR
          : (x.kind==='slab' || x.kind==='precast') ? slabColorOf(x.r.code)
          : BY_CODE.has(x.kind) ? codeColor.get(x.r.code) : COLORS[x.ri % COLORS.length];
        const solid = x.kind==='slab' || x.kind==='precast' || x.kind==='footing';
        placeOn(x, A).forEach(({ ref, q })=>{
          if(!q){ unplaced.push(`${x.r.code} "${ref}"`); G.unplaced++; return; }
          rectsN++; G.rects++;
          geom.push({ ri:x.ri, ref, kind:q.kind, wM:q.wM, hM:q.hM, lenM:q.lenM, page:pn, scaleGuessed: A.g.method!=='ข้อความ' });
          const base = { code:x.r.code, cat:x.cat, color, quiet:true, label:`${x.r.code} ${ref}`, page:pn };
          // ช่องพื้น: หดเข้าครึ่งความกว้างคาน (0.10 ม.) ให้เห็นแนวคานคั่นระหว่างช่อง (ไม่เกิน 15% ของด้าน)
          const ins = (q.kind==='cell' && solid) ? Math.min(0.10*A.g.ptPerM, (q.x1-q.x0)*0.15, (q.y1-q.y0)*0.15) : 0;
          const box = { page:pn, type:'box', nx:(q.x0+ins)/vp.width, ny:(q.y0+ins)/vp.height, nw:(q.x1-q.x0-2*ins)/vp.width, nh:(q.y1-q.y0-2*ins)/vp.height,
            ...(solid ? { fillOpacity:0.24 } : {}) };
          if(x.kind==='beam' || x.kind==='wall'){ const m = { ...base, lenM:q.lenM, ...box }; pageMarks.push(m); if(x.kind==='wall') wallRuns.push({ m, q }); return; }
          if(x.kind==='opening'){
            // ป้ายจริงในแบบ → หน้าต่าง = กรอบยาวตามบาน (W) คร่อมผนังถึงป้าย · ประตู = วงรอบป้าย
            const labT = openLabel(A, x.r.code, q, usedLab), lab = labT || openVecTag(A, x, q, usedLab);
            snap[labT ? 'openText' : !lab ? 'openMid' : lab.t.digit ? 'openTagDigit' : 'openTagNear']++;
            if(lab){
              const m = A.g.ptPerM, oc = openColorOf(x.r.code);
              if(x.group==='หน้าต่าง'){
                const half = Math.max(+x.r.W || 1, 0.3)*m/2, side = Math.sign(lab.off) || 1;
                const a0 = lab.along-half, a1 = lab.along+half;
                const c0 = Math.min(lab.line - side*0.12*m, lab.line + lab.off + side*0.3*m), c1 = Math.max(lab.line - side*0.12*m, lab.line + lab.off + side*0.3*m);
                const [bx0, bx1, by0, by1] = lab.vert ? [c0, c1, a0, a1] : [a0, a1, c0, c1];
                pageMarks.push({ ...base, color:oc, type:'box', nx:bx0/vp.width, ny:by0/vp.height, nw:(bx1-bx0)/vp.width, nh:(by1-by0)/vp.height, fillOpacity:0.35 });
              } else {
                pageMarks.push({ ...base, color:oc, type:'circle', nx:lab.t.cx/vp.width, ny:lab.t.cy/vp.height, nr:0.45*m/vp.width, fillOpacity:0.35 });
              }
              return;
            }
            const n = spanN.get(ref)||1, k = spanK.get(ref)||0; spanK.set(ref, k+1);
            const t = (k+1)/(n+1), px = q.p0.x+(q.p1.x-q.p0.x)*t, py = q.p0.y+(q.p1.y-q.p0.y)*t;
            pageMarks.push({ ...base, type:'circle', nx:px/vp.width, ny:py/vp.height });
            return;
          }
          if(q.kind==='point'){
            // เสา: วงแดงรอบป้ายรหัสในแบบ (เช่น "F1,C1" ข้างจุดตัด · ห่าง ≤1.5 ม.) — ป้ายเป็นข้อความในไฟล์เท่านั้น · ไม่เจอ = จัตุรัสที่เสา
            if(x.kind==='column'){
              const lab = labelNear(A, x.r.code, q, usedLab);
              if(lab){ pageMarks.push({ ...base, type:'circle', nx:lab.x/vp.width, ny:lab.y/vp.height, nr:lab.r/vp.width, fillOpacity:0.18 }); return; }
            }
            if(x.kind==='footing'){
              const o = outlineAt(A, q, pointSizeM(x));
              snap[o ? 'footOutline' : 'footSquare']++;
              if(o){ pageMarks.push({ ...base, type:'box', nx:o.x0/vp.width, ny:o.y0/vp.height, nw:(o.x1-o.x0)/vp.width, nh:(o.y1-o.y0)/vp.height, fillOpacity:0.24 }); return; }
            }
            // สี่เหลี่ยมจัตุรัสด้านสั้น — ข้อมูลแถวไม่บอกว่า B/L วางแกนไหน (วาดผืนผ้าแล้วหมุนผิดทิศหลอกตา) · จัตุรัสด้านสั้นอยู่ในฐานจริงเสมอ
            const side = Math.min(...pointSizeM(x)), w = Math.max(side*A.g.ptPerM, 6), h = w;
            pageMarks.push({ ...base, type:'box', nx:(q.x-w/2)/vp.width, ny:(q.y-h/2)/vp.height, nw:w/vp.width, nh:h/vp.height, ...(solid ? { fillOpacity:0.24 } : {}) });
            return;
          }
          if(!checked){ pageMarks.push({ ...base, wM:q.wM, hM:q.hM, ...box }); return; }
          rects.push(q);
          const inside = labels.filter(c=>within(c,q)).length;
          const dash = labels.length>0 && inside!==1;   // ช่องไม่มีป้าย / หลายป้าย → เส้นประ ให้ผู้ใช้ดูซ้ำ
          if(dash) flagged++;
          pageMarks.push({ code:x.r.code, cat:x.cat, color, quiet:true, dash, wM:q.wM, hM:q.hM,
            label:`${x.r.code} ${ref}`+(dash ? (inside ? ` · มี ${inside} ป้ายในช่อง` : ' · ไม่มีป้ายในช่อง') : ''), ...box });
        });
      });
      // ป้ายพื้นในแบบที่ไม่มีช่องไหนครอบ = แผ่นที่ AI ไม่ได้ใส่ — โชว์เมื่อวงขนาดนี้เป็นป้ายพื้นจริง (ครอบได้ ≥ครึ่ง)
      const orphan = labels.filter(c=>!rects.some(q=>within(c,q)));
      if(rects.length && labels.length && orphan.length <= labels.length/2){
        orphan.forEach(c=>pageMarks.push({ code:'', color:ORPHAN, quiet:true, label:'ป้ายพื้นในแบบที่ไม่มีแถวในตาราง',
          page:pn, type:'circle', nx:c.cx/vp.width, ny:c.cy/vp.height }));
        orphansN += orphan.length;
      }
      // ผนัง: ป้ายชนิดผนัง ▷1◁ ในแบบต้องอยู่บนแนวที่วาง (ระยะ ≤0.3 ม. · แกนป้ายตั้งฉากกับแนว)
      //   ป้ายที่ไม่มีแนวครอบ = วงแดง (ผนังที่ AI ไม่ได้ใส่) · แนวที่ไม่มีป้ายเลย = เส้นประ
      //   ตรวจเฉพาะเมื่อป้ายตกบนแนวได้ ≥60% (ไฟล์ที่ใช้สัญลักษณ์อื่น/ไม่มีป้าย = ไม่แจ้งเตือนหลอก)
      const tags = A.wallTags || [];
      if(wallRuns.length && tags.length){
        const tol = Math.max(0.3*A.g.ptPerM, 4);
        const onRun = (t, q) => {
          const vert = Math.abs(q.p0.x-q.p1.x) < Math.abs(q.p0.y-q.p1.y);
          if(vert ? Math.abs(t.dx) < 0.8 : Math.abs(t.dy) < 0.8) return false;   // ชี้ตั้งฉากเข้าหาแนว
          const [u, line, v, s0, s1] = vert ? [t.x, q.p0.x, t.y, Math.min(q.p0.y,q.p1.y), Math.max(q.p0.y,q.p1.y)]
                                            : [t.y, q.p0.y, t.x, Math.min(q.p0.x,q.p1.x), Math.max(q.p0.x,q.p1.x)];
          return Math.abs(u-line) <= tol && v >= s0-tol && v <= s1+tol;
        };
        const ax = A.g.numAxis==='x' ? Object.values(A.g.axes.num) : Object.values(A.g.axes.let), ay = A.g.numAxis==='x' ? Object.values(A.g.axes.let) : Object.values(A.g.axes.num);
        const m1 = A.g.ptPerM, inGrid = t => ax.length && ay.length && t.x>=Math.min(...ax)-m1 && t.x<=Math.max(...ax)+m1 && t.y>=Math.min(...ay)-m1 && t.y<=Math.max(...ay)+m1;
        const tg = tags.filter(inGrid), lone = tg.filter(t=>!wallRuns.some(w=>onRun(t, w.q)));
        // ป้ายคู่ ▷1◁ = 2 สามเหลี่ยม → รวมเป็นป้ายเดียว (ห่างกัน < 2 เท่าขนาดป้าย) · ใช้ทั้งฝั่งตรงแนวและฝั่งลอย ให้สัดส่วนนับหน่วยเดียวกัน
        const cluster = (list) => { const out = []; list.forEach(t=>{ const o = out.find(o=>Math.hypot(o.x-t.x, o.y-t.y) < t.size*2);
          if(o){ o.x=(o.x+t.x)/2; o.y=(o.y+t.y)/2; o.n++; } else out.push({ x:t.x, y:t.y, size:t.size, n:1 }); }); return out; };
        const orphan = cluster(lone), nOn = cluster(tg.filter(t=>!lone.includes(t))).length;
        const nTags = nOn + orphan.length;
        // ป้ายตรงแนวน้อย = แบบใช้สามเหลี่ยมเรื่องอื่นปน (วงอ้างรูปขยาย · เลขขั้นบันได — แบบกรมฯ ร่วมสมัย5 ตรงแค่ 51%) → ไม่แจ้ง กันวงแดงรก
        if(tg.length && (nTags - orphan.length) >= 0.6*nTags){
          wallRuns.forEach(w=>{ if(!tg.some(t=>onRun(t, w.q))){ w.m.dash = true; w.m.label += ' · ไม่มีป้ายผนังบนแนวนี้'; flagged++; } });
          orphan.forEach(t=>pageMarks.push({ code:'', color:ORPHAN, quiet:true, label:'ป้ายผนังในแบบที่ไม่มีแนวในตาราง',
            page:pn, type:'circle', nx:t.x/vp.width, ny:t.y/vp.height }));
          orphansN += orphan.length;
        }
      }
      if(pageMarks.length) marks[pn] = pageMarks;
    }
    const noGrid = ownPages.filter(p=>!cache.get(p));
    // grids = สเกล/วิธีหากริดต่อหน้าที่วาง (เครื่องมือตรวจความแม่น tools/grid-marks/mark-audit.mjs ใช้แปลงระยะเป็นเมตร)
    const grids = {}; byA.forEach((xs, A)=>{ grids[A.pn] = { ptPerM:A.g.ptPerM, method:A.g.method, w:A.vp.width, h:A.vp.height }; });
    return { marks, grids, geom, stats:{ pages:ownPages.length, gridPages:byA.size, noGrid, rects:rectsN, refs:refsN, unplaced, orphans:orphansN, flagged, countDiff, moved, byGroup, snap } };
  }

  /* ══════════ แก้ขนาดพื้นด้วยการวัดจากกริด (ทำหลังบ้าน ไม่แจ้งผู้ใช้ — เจ้าของกำหนด 2026-11-05) ══════════
     AI กรอก B×L ต่อแถวเดียว แต่แถวมีหลายช่องคนละขนาดได้ (ร่วมสมัย3: SP ทุกช่อง 3×3.5 จริง 4×3.5/2.2×2.45… → +19%)
     โค้ดวัดช่อง grid ของแถวจากเส้นกริดในแบบ → ถ้า (1) วางได้ทุกช่อง (2) จำนวนช่อง = จำนวนในแถว (3) ต่างจาก B×L×จำนวน >10%
     → แยกแถวตามขนาดช่องที่วัดได้ (B = ด้านสั้น · L = ด้านยาว · จำนวน = ช่องขนาดนั้น) ช่องอื่นของแถวคงเดิม (สเปกเหล็ก/หนา/ชนิดพื้น)
     ช่องไม่ครบ (grid น้อยกว่าจำนวน) = ไม่แตะ: วัดได้แค่บางช่อง → ค่าวัดต่ำเกินจริง (อารย3 S1 3 ช่อง/จำนวน 6 วัดได้ −47%)
     วัดเทียบเฉลย 3 บ้าน: ช่องครบ → ค่าวัดใกล้เฉลยกว่าค่า AI ทุกกรณีที่ต่างกันเกิน 10% */
  const FIX_SHEETS = { slabs_cip:'slab', slabs_precast:'precast' };
  function sbFixSlabsFromGrid(sheets, rows, geom){
    const out = { ...sheets }, log = [];
    const byRow = new Map(); (geom||[]).forEach(g=>{ if(g.kind==='cell'){ if(!byRow.has(g.ri)) byRow.set(g.ri, []); byRow.get(g.ri).push(g); } });
    const repl = new Map();   // "sheet#idx" → แถวใหม่ []
    // กันสเกลผิด (เฉพาะหน้าที่สเกลเดา): แบบที่ตัวอักษรเป็นเส้น สเกลมาจากการเดาสเกลมาตรฐาน (guessScale) → เดาผิด = ทุกช่องในหน้าเพี้ยนเท่ากันหมด
    //   หน้าที่กริดมาจากข้อความ สเกลคิดจากตัวเลขระยะในแบบ → ไม่ต้องกัน (บ้านดุง: AI กรอกพื้นชั้นล่างผิดทางเดียวกันหลายแถว ≠ สเกลผิด)
    //   แถวที่ AI อ่านพลาดเพี้ยนเป็นรายแถว แต่สเกลผิดเพี้ยนทั้งหน้า → หน้าที่มัธยฐาน (วัด ÷ AI) ของแถวช่องครบ ≥2 แถว
    //   ห่างจาก 1 เกิน 10% = ไม่เชื่อสเกลหน้านั้น ไม่แก้สักแถว · แถวช่องครบไม่ถึง 2 แถว = ไม่มีตัวเทียบ ไม่แก้
    const pageOk = new Map(), ratios = new Map();
    (rows||[]).forEach((r, ri)=>{
      const sk = r && r._src && r._src.sheet; if(!FIX_SHEETS[sk]) return;
      const src = (sheets[sk]||[])[r._src.idx], cells = byRow.get(ri) || []; if(!src || !cells.length) return;
      const refs = String(r.grid||'').split(/\s*,\s*/).filter(Boolean), n = Number(src.count ?? src.qty) || 1, ai = (Number(src.B)||0)*(Number(src.L)||0)*n;
      if(cells.length!==refs.length || refs.length!==n || !(ai>0)) return;
      const pg = cells[0].page; if(!cells[0].scaleGuessed){ pageOk.set(pg, true); return; }   // สเกลจากตัวเลขระยะในแบบ (ข้อความ) = เชื่อได้
      if(!ratios.has(pg)) ratios.set(pg, []);
      ratios.get(pg).push(cells.reduce((a,c)=>a+c.wM*c.hM, 0)/ai);
    });
    ratios.forEach((rs, pg)=>{ if(pageOk.get(pg)) return; const s = [...rs].sort((a,b)=>a-b), med = s[s.length>>1]; pageOk.set(pg, rs.length>=2 && Math.abs(med-1) <= 0.10); });
    (rows||[]).forEach((r, ri)=>{
      const sk = r && r._src && r._src.sheet; if(!FIX_SHEETS[sk]) return;
      const src = (sheets[sk]||[])[r._src.idx]; if(!src) return;
      const refs = String(r.grid||'').split(/\s*,\s*/).filter(Boolean), cells = byRow.get(ri) || [];
      const n = Number(src.count ?? src.qty) || 1, B = Number(src.B)||0, L = Number(src.L)||0;
      if(!refs.length || cells.length!==refs.length || refs.length!==n) return;
      if(!pageOk.get(cells[0].page)) return;
      if(cells.some(c=>c.page!==cells[0].page)) return;
      if(cells.some(c=>!(c.wM>=0.3 && c.wM<=15 && c.hM>=0.3 && c.hM<=15))) return;
      const meas = cells.reduce((a,c)=>a+c.wM*c.hM, 0), ai = B*L*n;
      if(ai>0 && Math.abs(meas-ai)/ai <= 0.10) return;
      const r2 = v => Math.round(v*100)/100, groups = new Map();
      cells.forEach(c=>{ const s = r2(Math.min(c.wM,c.hM)), l = r2(Math.max(c.wM,c.hM)), k = s+'x'+l;
        if(!groups.has(k)) groups.set(k, { B:s, L:l, refs:[] }); groups.get(k).refs.push(c.ref); });
      // ค่าปริมาณรวมที่ติดมากับแถว (kg/ม³/ม² ที่ AI กรอก) → เฉลี่ยตามสัดส่วนพื้นที่ช่วง
      //   ‼️ SB_RECOMPUTE คงค่า AI ไว้เมื่ออ่านสเปกเหล็กไม่ออก → ถ้าก๊อปทั้งก้อนไปทุกแถวที่แยก = เหล็กนับซ้ำหลายเท่า
      const QTY = ['rebar_kg','rebar_m','rebar_top_kg','rebar_sup_kg','rebar_sup_m','wiremesh_kg','topping_rebar_kg','topping_rebar_m',
        'steel_total_kg','tie_wire_kg','concrete_m3','area_m2','formwork_m2','sand_m3','poly_m2','nail_kg','spacer_n','volume'];
      const parts = [...groups.values()].map((g, i)=>{
        const f = ai > 0 ? (g.B*g.L*g.refs.length)/ai : 0, p = { ...src, B:g.B, L:g.L, count:g.refs.length, grid:g.refs.join(',') };
        QTY.forEach(k=>{ if(Number.isFinite(Number(src[k])) && src[k]!=='' && src[k]!=null) p[k] = r2(Number(src[k])*f); });
        if(i>0) p.openings_m2 = 0;   // ช่องเปิดเป็นค่ารวมของแถว → ไว้ที่แถวแรกแถวเดียว
        if('qty' in src && !('count' in src)) p.qty = g.refs.length;
        return p;
      });
      repl.set(sk+'#'+r._src.idx, parts);
      log.push(`${sk} ${src.code}: ${B}×${L}×${n} = ${r2(ai)} → วัด ${r2(meas)} ม² (${parts.length} แถว)`);
    });
    for(const sk of Object.keys(FIX_SHEETS)){
      if(!Array.isArray(sheets[sk])) continue;
      out[sk] = sheets[sk].flatMap((row, idx)=>repl.get(sk+'#'+idx) || [row]);
    }
    return { sheets: out, log, changed: repl.size };
  }
  // ทั้งชุด: แถวพื้นจาก sheets → วางกริด (หน้าผังจาก route_map) → แก้ขนาด · ล้ม/ไม่มีกริด = คืนของเดิม
  async function sbAutoFixSlabs({ storagePath, sheets, routeMap, onProgress }){
    const rows = gridRowsFromSheets(sheets||{}, 'str').filter(G=>FIX_SHEETS[G.sheet]).flatMap(G=>G.rows);
    if(!rows.length) return { sheets, log:[], changed:0 };
    const candPages = Object.entries(routeMap||{}).filter(([, t])=>Array.isArray(t) && t.includes('struct')).map(([p])=>Number(p));
    const res = await sbBuildGridMarks({ storagePath, rows, candPages, onProgress });
    return sbFixSlabsFromGrid(sheets, rows, res.geom);
  }
  window.sbFixSlabsFromGrid = sbFixSlabsFromGrid;
  window.sbAutoFixSlabs = sbAutoFixSlabs;

  window.sbBuildGridMarks = sbBuildGridMarks;
  window.sbGridRowsFromSheets = gridRowsFromSheets;
  window.sbGridGeom = geomOfGrid;   // ตำแหน่ง grid → pt + เมตร (ใช้ซ้ำได้: วัดระยะคาน/ช่องพื้นจากแบบ)
  window.sbGridRect = rectOfGrid;   // ใช้ทดสอบ
})();
