hwpkit-dev 0.0.2 → 0.0.5

package/src/decoders/hwp/HwpScanner.ts

@@ -1,11 +1,12 @@
 import type { Decoder } from '../../contract/decoder';
-import type { DocRoot, ContentNode, ParaNode, SpanNode, ImgNode } from '../../model/doc-tree';
+import type { DocRoot, ContentNode, ParaNode, SpanNode, ImgNode, GridNode, PageNumNode } from '../../model/doc-tree';
 import type { Outcome } from '../../contract/result';
 import type { Align, Stroke, StrokeKind, PageDims, TextProps, ParaProps, CellProps, GridProps } from '../../model/doc-props';
 import { succeed, fail } from '../../contract/result';
-import { buildRoot, buildSheet, buildPara, buildSpan, buildGrid, buildRow, buildCell, buildImg } from '../../model/builders';
+import { buildRoot, buildSheet, buildPara, buildSpan, buildGrid, buildRow, buildCell, buildImg, buildPb, buildPageNum } from '../../model/builders';
 import { ShieldedParser } from '../../safety/ShieldedParser';
 import { BinaryKit } from '../../toolkit/BinaryKit';
+import { TextKit } from '../../toolkit/TextKit';
 import { Metric, safeHex, safeFont } from '../../safety/StyleBridge';
 import { registry } from '../../pipeline/registry';
 import { A4 } from '../../model/doc-props';
@@ -38,10 +39,14 @@ function isTableTag(t: number) { return t === TAG_TABLE_A || t === TAG_TABLE_B;
 function isCellTag(t: number)  { return t === TAG_CELL_A || t === TAG_CELL_B || t === TAG_LIST_HEADER; }
 
 // CTRL_HEADER ctrlId values (UINT32-LE as ASCII)
-const CTRL_TABLE = 0x74626C20;  // ' lbt'
+const CTRL_TABLE = 0x74626C20;  // 'tbl ' = 표(table)
 const CTRL_IMAGE = 0x696D6720;  // 'img '
 const CTRL_OBJ   = 0x6F626A20;  // 'obj '
 const CTRL_FIG   = 0x66696720;  // 'fig '
+const CTRL_GSO   = 0x67736F20;  // 'gso ' = 그리기 객체 (drawing object, contains embedded images)
+const CTRL_HEAD  = 0x68656164;  // 'head' = 머리말
+const CTRL_FOOT  = 0x666F6F74;  // 'foot' = 꼬리말
+const CTRL_ATNO  = 0x61746E6F;  // 'atno' = 자동 번호 (쪽번호 등)
 
 /* ═══════════════════════════════════════════════════════════════
    Types
@@ -64,15 +69,18 @@ interface HwpCharShape {
   subscript: boolean;
   textColor: string;
 }
-
 interface HwpParaShape {
   align: Align;
   spaceBefore: number;
   spaceAfter: number;
   lineSpacing: number;
+  lineSpacingType: 0 | 1 | 2 | 3; // 0=PERCENT, 1=FIXED, 2=BETWEEN_LINES, 3=AT_LEAST
+  leftMargin: number;
+  rightMargin: number;
   indent: number;
+  verAlign?: 'baseline' | 'top' | 'center' | 'bottom';
+  lineWrap?: 'break' | 'squeeze' | 'keep';
 }
-
 interface HwpBorderFill {
   borders: { type: number; widthPt: number; color: string }[];
   bgColor?: string;
@@ -210,7 +218,7 @@ function parseCharShape(d: Uint8Array): HwpCharShape {
 
 /* ── PARA_SHAPE ─────────────────────────────────────────────── */
 /*  offset  size  field
-    0       4     attr1   (bits 0-1 = alignment: 0=justify,1=left,2=right,3=center)
+    0       4     attr1   (bits 0-1 = line spacing type, bits 2-4 = alignment)
     4       4     leftMargin   (HWPUNIT)
     8       4     rightMargin
     12      4     indent
@@ -218,17 +226,36 @@ function parseCharShape(d: Uint8Array): HwpCharShape {
     20      4     spaceAfter
     24      4     lineSpacing                                         */
 
-const ALIGN_TBL: Record<number, Align> = { 0: 'justify', 1: 'left', 2: 'right', 3: 'center', 4: 'justify' };
+const ALIGN_TBL: Record<number, Align> = { 0: 'justify', 1: 'left', 2: 'right', 3: 'center', 4: 'distribute', 5: 'distribute_space' };
 
 function parseParaShape(d: Uint8Array): HwpParaShape {
-  if (d.length < 4) return { align: 'left', spaceBefore: 0, spaceAfter: 0, lineSpacing: 160, indent: 0 };
+  if (d.length < 4) return { align: 'left', spaceBefore: 0, spaceAfter: 0, lineSpacing: 160, lineSpacingType: 0, leftMargin: 0, rightMargin: 0, indent: 0 };
   const attr = BinaryKit.readU32LE(d, 0);
+
+  // bits 0-1: 줄 간격 종류 (0=PERCENT, 1=FIXED, 2=BETWEEN_LINES, 3=AT_LEAST)
+  const lineSpacingType = (attr & 0x3) as 0 | 1 | 2 | 3;
+
+  // bits 2-4: 정렬 방식 (0=justify,1=left,2=right,3=center,4=distribute,5=split)
+  const align = ALIGN_TBL[(attr >> 2) & 0x7] ?? 'left';
+
+  // 세로 정렬 (Bit 18 ~ Bit 19)
+  const vVal = (attr >> 18) & 0x3;
+  const verAlign = vVal === 1 ? 'top' : vVal === 2 ? 'center' : vVal === 3 ? 'bottom' : 'baseline';
+
+  // 줄 바꿈 기준: attr1 에는 별도 비트 없음, 기본값 'break'
+  const lineWrap: 'break' = 'break';
+
   return {
-    align:       ALIGN_TBL[(attr >> 2) & 0x7] ?? 'left',
-    indent:      d.length >= 16 ? i32(d, 12) : 0,
+    align,
+    lineSpacingType,
+    leftMargin:  d.length >= 8  ? i32(d, 4)  : 0,  // offset 4: 문단 몸체 왼쪽 여백 (HWPUNIT)
+    rightMargin: d.length >= 12 ? i32(d, 8)  : 0,  // offset 8: 문단 몸체 오른쪽 여백 (HWPUNIT)
+    indent:      d.length >= 16 ? i32(d, 12) : 0,  // offset 12: 첫 줄 들여쓰기 (HWPUNIT)
     spaceBefore: d.length >= 20 ? i32(d, 16) : 0,
     spaceAfter:  d.length >= 24 ? i32(d, 20) : 0,
     lineSpacing: d.length >= 28 ? i32(d, 24) : 160,
+    verAlign,
+    lineWrap,
   };
 }
 
@@ -275,8 +302,17 @@ function parseBorderFill(d: Uint8Array): HwpBorderFill {
    Body section parsing
    ═══════════════════════════════════════════════════════════════ */
 
+// gsoCtx: shared mutable counter for 'gso ' drawing objects.
+// Each 'gso ' CTRL_HEADER encountered increments this counter.
+// objectMap is keyed by 0-based gso order = sequential BinData insertion order.
+interface GsoCtx {
+  count: number;
+  headers?: ParaNode[];
+  footers?: ParaNode[];
+}
+
 function parseBody(
-  raw: Uint8Array, compressed: boolean, di: DocInfo, shield: ShieldedParser,
+  raw: Uint8Array, compressed: boolean, di: DocInfo, shield: ShieldedParser, gsoCtx: GsoCtx,
 ): { content: ContentNode[]; pageDims?: PageDims } {
   const recs = parseRecords(compressed ? tryInflate(raw) : raw);
   const content: ContentNode[] = [];
@@ -296,7 +332,7 @@ function parseBody(
       i++; // already handled above; skip at top level
     } else if (recs[i].tag === TAG_PARA_HEADER) {
       const r = shield.guard(
-        () => parseParagraphGroup(recs, i, di, shield),
+        () => parseParagraphGroup(recs, i, di, shield, gsoCtx),
         { nodes: [] as ContentNode[], next: i + 1 },
         `hwp:para@${i}`,
       );
@@ -312,19 +348,25 @@ function parseBody(
 /* ── Paragraph group ────────────────────────────────────────── */
 
 function parseParagraphGroup(
-  recs: HwpRecord[], start: number, di: DocInfo, shield: ShieldedParser,
+  recs: HwpRecord[], start: number, di: DocInfo, shield: ShieldedParser, gsoCtx: GsoCtx,
 ): { nodes: ContentNode[]; next: number } {
   const hdr = recs[start];
   const lv  = hdr.level;
 
-  // paraShapeId at offset 8 (UINT16)
-  const psId = hdr.data.length >= 10 ? BinaryKit.readU16LE(hdr.data, 8) : 0;
-  const ps   = di.paraShapes[psId];
+  // P1: PARA_HEADER 레이아웃
+  //   offset 8-9: paraShapeId (UINT16)
+  //   offset 10:  styleId (UINT8)
+  //   offset 11:  divideSort (UINT8) — 0x04=쪽나누기
+  const psId       = hdr.data.length >= 10 ? BinaryKit.readU16LE(hdr.data, 8) : 0;
+  const hwpStyleId = hdr.data.length >= 11 ? hdr.data[10] : 0;
+  const divideSort = hdr.data.length >= 12 ? hdr.data[11] : 0;
+  const ps         = di.paraShapes[psId];
 
   let text: ParaTextResult | null = null;
   let csPairs: [number, number][] = [];
   const grids: ContentNode[] = [];
-  const ctrlHeaders: { ctrlId: number; objId: number }[] = [];
+  // imgId: for 'gso' uses sequential gsoCtx.count; for others uses flags-based objId
+  const ctrlHeaders: { ctrlId: number; imgId: number; wPt: number; hPt: number; atnoType?: number }[] = [];
   let i = start + 1;
 
   while (i < recs.length && recs[i].level > lv) {
@@ -339,20 +381,60 @@ function parseParagraphGroup(
     } else if (r.tag === TAG_CTRL_HEADER && r.level === lv + 1) {
       if (r.data.length >= 4) {
         const ctrlId = BinaryKit.readU32LE(r.data, 0);
-        // objId at offset 4 (UINT16) - identifies the image/object in BinData
-        const objId = r.data.length >= 6 ? BinaryKit.readU16LE(r.data, 4) : 0;
-        ctrlHeaders.push({ ctrlId, objId });
-
-        if (ctrlId === CTRL_TABLE) {
-          const tr = shield.guard(
-            () => parseTableCtrl(recs, i, di, shield),
-            { grid: null, next: skipKids(recs, i) },
-            `hwp:tbl@${i}`,
-          );
-          if (tr.grid) grids.push(tr.grid);
-          i = tr.next;
+
+        if (ctrlId === CTRL_HEAD || ctrlId === CTRL_FOOT) {
+          // P8: 머리말/꼬리말 컨트롤 — 자식 문단을 파싱해 gsoCtx에 저장
+          const ctrlLv = r.level;
+          const hfParas: ParaNode[] = [];
+          let j = i + 1;
+          while (j < recs.length && recs[j].level > ctrlLv) {
+            if (recs[j].tag === TAG_PARA_HEADER) {
+              const pr = shield.guard(
+                () => parseParagraphGroup(recs, j, di, shield, gsoCtx),
+                { nodes: [] as ContentNode[], next: j + 1 },
+                `hwp:hf@${j}`,
+              );
+              hfParas.push(...pr.nodes.filter((n): n is ParaNode => n.tag === 'para'));
+              j = pr.next;
+            } else {
+              j++;
+            }
+          }
+          if (hfParas.length > 0) {
+            const key = ctrlId === CTRL_HEAD ? 'headers' : 'footers';
+            if (!gsoCtx[key]) gsoCtx[key] = hfParas;
+          }
+          i = j;
         } else {
-          i = skipKids(recs, i);
+          // HWP 5.0 general-object layout:
+          //   [0:4] ctrlId  [4:4] flags  [8:4] xOff  [12:4] yOff
+          //   [16:4] width(HWPUNIT)  [20:4] height(HWPUNIT)
+          const MAX_HWP = 1_000_000;
+          const rawW = r.data.length >= 24 ? BinaryKit.readU32LE(r.data, 16) : 0;
+          const rawH = r.data.length >= 28 ? BinaryKit.readU32LE(r.data, 20) : 0;
+          const wPt = rawW > 0 && rawW < MAX_HWP ? Metric.hwpToPt(rawW) : 0;
+          const hPt = rawH > 0 && rawH < MAX_HWP ? Metric.hwpToPt(rawH) : 0;
+
+          // P9: atno — offset 4 u32 하위 4bit = 번호 종류 (0=쪽번호, 6=전체쪽수)
+          const atnoType = ctrlId === CTRL_ATNO && r.data.length >= 8
+            ? BinaryKit.readU32LE(r.data, 4) & 15
+            : undefined;
+
+          // 'gso ' (그리기 객체) uses sequential counter; others use flags-based id
+          const imgId = ctrlId === CTRL_GSO ? gsoCtx.count++ : (r.data.length >= 6 ? BinaryKit.readU16LE(r.data, 4) : 0);
+          ctrlHeaders.push({ ctrlId, imgId, wPt, hPt, atnoType });
+
+          if (ctrlId === CTRL_TABLE) {
+            const tr = shield.guard(
+              () => parseTableCtrl(recs, i, di, shield, gsoCtx),
+              { grid: null, next: skipKids(recs, i) },
+              `hwp:tbl@${i}`,
+            );
+            if (tr.grid) grids.push(tr.grid);
+            i = tr.next;
+          } else {
+            i = skipKids(recs, i);
+          }
         }
       } else {
         i = skipKids(recs, i);
@@ -362,43 +444,68 @@ function parseParagraphGroup(
     }
   }
 
-  // Match extended controls with CTRL_HEADER entries
-  if (text && ctrlHeaders.length > 0) {
-    for (let ci = 0; ci < text.controls.length; ci++) {
-      if (ci < ctrlHeaders.length) {
-        text.controls[ci].ctrlId = ctrlHeaders[ci].ctrlId;
-        text.controls[ci].matched = true;
-      }
-    }
-  }
-
   const nodes: ContentNode[] = [];
 
-  // Build paragraph from text and inline controls (images)
-  if (text && (text.chars.length > 0 || text.controls.length > 0)) {
-    const paraContent: (SpanNode | ContentNode)[] = [];
+  {
+    const paraContent: Array<SpanNode | GridNode | PageNumNode> = [];
 
-    // Process text chars and controls together
-    if (text.chars.length > 0) {
-      const spans = resolveCharShapes(text.chars, csPairs, di);
-      paraContent.push(...spans);
+    // P9: atno 컨트롤 위치 수집 (pos 기준 정렬)
+    const atnoCtrls: { pos: number; type: number }[] = [];
+    if (text && text.controls.length > 0) {
+      for (let ci = 0; ci < text.controls.length; ci++) {
+        const ch = ctrlHeaders[ci];
+        if (ch && ch.ctrlId === CTRL_ATNO)
+          atnoCtrls.push({ pos: text.controls[ci].pos, type: ch.atnoType ?? 0 });
+      }
+      atnoCtrls.sort((a, b) => a.pos - b.pos);
+    }
+
+    // P9: 텍스트 chars를 atno 위치 기준으로 분할하여 PageNumNode 삽입
+    if (text && text.chars.length > 0) {
+      if (atnoCtrls.length > 0) {
+        let k = 0;
+        for (const ac of atnoCtrls) {
+          const seg: ParsedChar[] = [];
+          while (k < text.chars.length && text.chars[k].pos < ac.pos) seg.push(text.chars[k++]);
+          if (seg.length > 0) paraContent.push(...resolveCharShapes(seg, csPairs, di));
+          paraContent.push(buildPageNum(ac.type === 0 ? 'decimal' : 'total'));
+        }
+        const rest = text.chars.slice(k);
+        if (rest.length > 0) paraContent.push(...resolveCharShapes(rest, csPairs, di));
+      } else {
+        paraContent.push(...resolveCharShapes(text.chars, csPairs, di));
+      }
+    } else if (atnoCtrls.length > 0) {
+      for (const ac of atnoCtrls) paraContent.push(buildPageNum(ac.type === 0 ? 'decimal' : 'total'));
     }
 
-    // Add placeholder spans for extended controls (images)
-    if (text.controls.length > 0) {
+    // Image placeholder spans: only for actual image controls.
+    // Non-image controls (footnotes, TOC entries, etc.) are silently skipped.
+    if (text && text.controls.length > 0) {
       for (let ci = 0; ci < text.controls.length; ci++) {
-        // Create placeholder for all extended controls
-        // Image replacement will happen later in injectImagesIntoContent
-        paraContent.push(buildSpan(`__EXT_${ci}__`));
+        const ch = ctrlHeaders[ci];
+        if (!ch) continue; // anchor-only ctrl (gso is sibling, not inline)
+        const isImg = ch.ctrlId === CTRL_IMAGE || ch.ctrlId === CTRL_FIG || ch.ctrlId === CTRL_OBJ || ch.ctrlId === CTRL_GSO;
+        if (!isImg) continue; // skip footnotes, TOC, page num, etc.
+        const dimStr = (ch.wPt > 0 && ch.hPt > 0)
+          ? `_W${Math.round(ch.wPt)}_H${Math.round(ch.hPt)}`
+          : '';
+        paraContent.push(buildSpan(`__EXT_${ch.imgId}${dimStr}__`));
       }
     }
 
-    if (paraContent.length > 0) {
-      nodes.push(buildPara(paraContent as any, buildParaProps(ps)));
+    // P5: 쪽나누기(divideSort & 4) → page-break 문단 먼저 출력
+    if (divideSort & 4) {
+      nodes.push(buildPara([{ tag: 'span', props: {}, kids: [buildPb()] } as SpanNode]));
     }
+    // P5: 표 → 앵커 문단 순서 (앵커 문단 드롭 금지)
+    nodes.push(...grids);
+    nodes.push(buildPara(
+      paraContent.length > 0 ? paraContent as any : [buildSpan('')],
+      buildParaProps(ps, hwpStyleId),
+    ));
   }
 
-  nodes.push(...grids);
   return { nodes, next: i };
 }
 
@@ -411,8 +518,8 @@ function skipKids(recs: HwpRecord[], idx: number): number {
 
 /* ── PARA_TEXT ───────────────────────────────────────────────── */
 
-// Extended controls: 8 WORDs, associated CTRL_HEADER
-const EXT_CTRL = new Set([2, 3, 11, 12, 14, 15]);
+// Extended controls: 8 WORDs, associated CTRL_HEADER (16-25 also skip 16 bytes)
+const EXT_CTRL = new Set([2, 3, 11, 12, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]);
 // Inline controls: 8 WORDs, no CTRL_HEADER
 const INL_CTRL = new Set([4, 5, 6, 7, 8]);
 
@@ -511,7 +618,7 @@ function styledSpan(text: string, shapeId: number, di: DocInfo): SpanNode {
 /* ── Table control parsing ──────────────────────────────────── */
 
 function parseTableCtrl(
-  recs: HwpRecord[], ctrlIdx: number, di: DocInfo, shield: ShieldedParser,
+  recs: HwpRecord[], ctrlIdx: number, di: DocInfo, shield: ShieldedParser, gsoCtx: GsoCtx,
 ): { grid: ContentNode | null; next: number } {
   const ctrlLv = recs[ctrlIdx].level;
   let i = ctrlIdx + 1;
@@ -567,15 +674,15 @@ function parseTableCtrl(
   const rowCnt = tblData.length >= 6 ? BinaryKit.readU16LE(tblData, 4) : 1;
   const colCnt = tblData.length >= 8 ? BinaryKit.readU16LE(tblData, 6) : 1;
 
-  interface PC { row: number; col: number; cs: number; rs: number; widthHwp: number; props: CellProps; paras: ParaNode[] }
+  interface PC { row: number; col: number; cs: number; rs: number; widthHwp: number; heightHwp?: number; props: CellProps; cellChildren: (ParaNode | GridNode)[] }
   const parsed: PC[] = [];
 
   for (let ci = 0; ci < cells.length; ci++) {
     const c = cells[ci];
     const seqIdx = ci;
     const pc = shield.guard(
-      () => parseCellRec(c.data, c.tag, recs, c.cStart, c.cEnd, di, shield, seqIdx, colCnt),
-      { row: Math.floor(ci / (colCnt || 1)), col: ci % (colCnt || 1), cs: 1, rs: 1, widthHwp: 0, props: {}, paras: [buildPara([buildSpan('')])] },
+      () => parseCellRec(c.data, c.tag, recs, c.cStart, c.cEnd, di, shield, seqIdx, colCnt, gsoCtx),
+      { row: Math.floor(ci / (colCnt || 1)), col: ci % (colCnt || 1), cs: 1, rs: 1, widthHwp: 0, heightHwp: undefined, props: {}, cellChildren: [buildPara([buildSpan('')])] },
       `hwp:cell@${c.cStart}`,
     );
     parsed.push(pc);
@@ -602,9 +709,11 @@ function parseTableCtrl(
     }
   }
   // Pass 2: for columns still 0, try to derive from multi-span cells
+  // Sort by span size ascending so smaller, more precise spans fill widths before larger spans
   const zeroColumns = colWidthsPt.filter(w => w === 0).length;
   if (zeroColumns > 0) {
-    for (const c of parsed) {
+    const spanCells = parsed.filter(c => c.cs > 1 && c.widthHwp > 0).sort((a, b) => a.cs - b.cs);
+    for (const c of spanCells) {
       if (c.cs > 1 && c.widthHwp > 0) {
         // Subtract known column widths from the span
         let known = 0;
@@ -624,13 +733,37 @@ function parseTableCtrl(
     }
   }
 
+  // Post-process: clamp near-zero column widths (< 1pt = floating-point artifact) to minimum 1pt
+  for (let i = 0; i < colWidthsPt.length; i++) {
+    if (colWidthsPt[i] > 0 && colWidthsPt[i] < 1) colWidthsPt[i] = 1;
+  }
+
   const rows = [];
   for (let r = 0; r < actualRowCnt; r++) {
     const rc = parsed.filter(c => c.row === r).sort((a, b) => a.col - b.col);
     if (rc.length === 0) continue;
-    rows.push(buildRow(rc.map(c =>
-      buildCell(c.paras.length ? c.paras : [buildPara([buildSpan('')])], { cs: c.cs, rs: c.rs, props: c.props }),
-    )));
+
+    // Calculate row height — prefer rs=1 cells (exact per-row height)
+    let rowHeightPt: number | undefined = undefined;
+    for (const c of rc) {
+      if (c.heightHwp && c.heightHwp > 0 && c.rs === 1) {
+        const hPt = Metric.hwpToPt(c.heightHwp);
+        if (rowHeightPt == null || hPt > rowHeightPt) rowHeightPt = hPt;
+      }
+    }
+    // Fallback: all cells span multiple rows → approximate height per row
+    if (rowHeightPt == null) {
+      for (const c of rc) {
+        if (c.heightHwp && c.heightHwp > 0) {
+          const hPt = Metric.hwpToPt(c.heightHwp) / c.rs;
+          if (rowHeightPt == null || hPt > rowHeightPt) rowHeightPt = hPt;
+        }
+      }
+    }
+
+    rows.push(buildRow(rc.map(c => {
+      return buildCell(c.cellChildren, { cs: c.cs, rs: c.rs, props: c.props });
+    }), rowHeightPt));
   }
   if (rows.length === 0) return { grid: null, next: i };
 
@@ -659,10 +792,11 @@ function parseTableCtrl(
 
 function parseCellRec(
   d: Uint8Array, tag: number, recs: HwpRecord[], cStart: number, cEnd: number,
-  di: DocInfo, shield: ShieldedParser, seqIdx: number, colCnt: number,
+  di: DocInfo, shield: ShieldedParser, seqIdx: number, colCnt: number, gsoCtx: GsoCtx,
 ) {
   let col: number, row: number, cs = 1, rs = 1;
   let widthHwp = 0;
+  let heightHwp = 0;
   const props: CellProps = {};
 
   const attr = d.length >= 6 ? BinaryKit.readU32LE(d, 2) : 0;
@@ -670,88 +804,158 @@ function parseCellRec(
   if (va === 1) props.va = 'mid';
   else if (va === 2) props.va = 'bot';
 
+  const HWP_PAD_LR_DEFAULT = 360;
+  const HWP_PAD_TB_DEFAULT = 141;
+
   if (tag === TAG_LIST_HEADER && d.length >= 22) {
-    // LIST_HEADER with cell-specific fields
-    // offset 8: colAddr, offset 10: rowAddr (HWP 5.0 spec)
     col = BinaryKit.readU16LE(d, 8);
     row = BinaryKit.readU16LE(d, 10);
     cs  = Math.max(1, BinaryKit.readU16LE(d, 12));
     rs  = Math.max(1, BinaryKit.readU16LE(d, 14));
     widthHwp = BinaryKit.readU32LE(d, 16);
-
-    const bfId = d.length >= 34 ? BinaryKit.readU16LE(d, 32) : 0;
-    if (bfId > 0 && bfId <= di.borderFills.length) {
-      const bf = di.borderFills[bfId - 1];
-      if (bf.borders.length >= 4) {
-        props.left  = toStroke(bf.borders[0]);
-        props.right = toStroke(bf.borders[1]);
-        props.top   = toStroke(bf.borders[2]);
-        props.bot   = toStroke(bf.borders[3]);
-      }
-      if (bf.bgColor && bf.bgColor !== 'FFFFFF') props.bg = bf.bgColor;
+    heightHwp = d.length >= 24 ? BinaryKit.readU32LE(d, 20) : 0;
+    if (d.length >= 32) {
+      const pL = BinaryKit.readU16LE(d, 24); const pR = BinaryKit.readU16LE(d, 26);
+      const pT = BinaryKit.readU16LE(d, 28); const pB = BinaryKit.readU16LE(d, 30);
+      if (pL !== HWP_PAD_LR_DEFAULT) props.padL = Metric.hwpToPt(pL);
+      if (pR !== HWP_PAD_LR_DEFAULT) props.padR = Metric.hwpToPt(pR);
+      if (pT !== HWP_PAD_TB_DEFAULT) props.padT = Metric.hwpToPt(pT);
+      if (pB !== HWP_PAD_TB_DEFAULT) props.padB = Metric.hwpToPt(pB);
     }
+    const bfId = d.length >= 34 ? BinaryKit.readU16LE(d, 32) : 0;
+    if (bfId > 0 && bfId <= di.borderFills.length) applyCellBorderFill(di.borderFills[bfId - 1], props);
   } else if (tag !== TAG_LIST_HEADER) {
-    // Full CELL record with position/span/borderFill
     col = d.length >= 8  ? BinaryKit.readU16LE(d, 6) : seqIdx % (colCnt || 1);
     row = d.length >= 10 ? BinaryKit.readU16LE(d, 8) : Math.floor(seqIdx / (colCnt || 1));
     cs  = d.length >= 12 ? Math.max(1, BinaryKit.readU16LE(d, 10)) : 1;
     rs  = d.length >= 14 ? Math.max(1, BinaryKit.readU16LE(d, 12)) : 1;
     widthHwp = d.length >= 18 ? BinaryKit.readU32LE(d, 14) : 0;
-
-    const bfId = d.length >= 32 ? BinaryKit.readU16LE(d, 30) : 0;
-    if (bfId > 0 && bfId <= di.borderFills.length) {
-      const bf = di.borderFills[bfId - 1];
-      if (bf.borders.length >= 4) {
-        props.left  = toStroke(bf.borders[0]);
-        props.right = toStroke(bf.borders[1]);
-        props.top   = toStroke(bf.borders[2]);
-        props.bot   = toStroke(bf.borders[3]);
-      }
-      if (bf.bgColor && bf.bgColor !== 'FFFFFF') props.bg = bf.bgColor;
+    heightHwp = d.length >= 22 ? BinaryKit.readU32LE(d, 18) : 0;
+    if (d.length >= 30) {
+      const pL = BinaryKit.readU16LE(d, 22); const pR = BinaryKit.readU16LE(d, 24);
+      const pT = BinaryKit.readU16LE(d, 26); const pB = BinaryKit.readU16LE(d, 28);
+      if (pL !== HWP_PAD_LR_DEFAULT) props.padL = Metric.hwpToPt(pL);
+      if (pR !== HWP_PAD_LR_DEFAULT) props.padR = Metric.hwpToPt(pR);
+      if (pT !== HWP_PAD_TB_DEFAULT) props.padT = Metric.hwpToPt(pT);
+      if (pB !== HWP_PAD_TB_DEFAULT) props.padB = Metric.hwpToPt(pB);
     }
+    const bfId = d.length >= 32 ? BinaryKit.readU16LE(d, 30) : 0;
+    if (bfId > 0 && bfId <= di.borderFills.length) applyCellBorderFill(di.borderFills[bfId - 1], props);
   } else {
-    // Fallback: LIST_HEADER too short, compute sequentially
     row = Math.floor(seqIdx / (colCnt || 1));
     col = seqIdx % (colCnt || 1);
   }
 
-  // Parse cell content paragraphs
-  const paras: ParaNode[] = [];
+  const cellChildren: (ParaNode | GridNode)[] = [];
+  const MAX_HWP = 1_000_000;
   let k = cStart;
+
   while (k < cEnd) {
     if (recs[k].tag === TAG_PARA_HEADER) {
-      // For cell paragraphs, they might be at various nesting levels
+      // Parse paragraph inside cell — also extracts nested tables within the paragraph
       const r = shield.guard(
         () => {
           const hdr = recs[k];
           const lv = hdr.level;
           const psId = hdr.data.length >= 10 ? BinaryKit.readU16LE(hdr.data, 8) : 0;
+          // P6: 셀 내부 문단의 styleId / divideSort 읽기
+          const cellStyleId = hdr.data.length >= 11 ? hdr.data[10] : 0;
+          const cellDivide  = hdr.data.length >= 12 ? hdr.data[11] : 0;
           const ps = di.paraShapes[psId];
           let txt: ParaTextResult | null = null;
           let csp: [number, number][] = [];
+          const ctrlHdrs: { ctrlId: number; imgId: number; wPt: number; hPt: number }[] = [];
+          const innerGrids: GridNode[] = [];
           let j = k + 1;
           while (j < cEnd && recs[j].level > lv) {
             if (recs[j].tag === TAG_PARA_TEXT) { txt = decodeParaText(recs[j].data); j++; }
             else if (recs[j].tag === TAG_PARA_CHAR_SHAPE) { csp = parseCharShapePairs(recs[j].data); j++; }
+            else if (recs[j].tag === TAG_CTRL_HEADER && recs[j].level === lv + 1) {
+              if (recs[j].data.length >= 4) {
+                const ctrlId = BinaryKit.readU32LE(recs[j].data, 0);
+                if (ctrlId === CTRL_TABLE) {
+                  // Nested table inside a cell paragraph — recurse into parseTableCtrl
+                  const nestedTr = shield.guard(
+                    () => parseTableCtrl(recs, j, di, shield, gsoCtx),
+                    { grid: null, next: skipKids(recs, j) },
+                    `hwp:innerNestedTbl@${j}`,
+                  );
+                  if (nestedTr.grid) innerGrids.push(nestedTr.grid as GridNode);
+                  j = nestedTr.next;
+                } else {
+                  const rawW = recs[j].data.length >= 24 ? BinaryKit.readU32LE(recs[j].data, 16) : 0;
+                  const rawH = recs[j].data.length >= 28 ? BinaryKit.readU32LE(recs[j].data, 20) : 0;
+                  const wPt = rawW > 0 && rawW < MAX_HWP ? Metric.hwpToPt(rawW) : 0;
+                  const hPt = rawH > 0 && rawH < MAX_HWP ? Metric.hwpToPt(rawH) : 0;
+                  const imgId = ctrlId === CTRL_GSO ? gsoCtx.count++ : (recs[j].data.length >= 6 ? BinaryKit.readU16LE(recs[j].data, 4) : 0);
+                  ctrlHdrs.push({ ctrlId, imgId, wPt, hPt });
+                  j = skipKids(recs, j);
+                }
+              } else {
+                j = skipKids(recs, j);
+              }
+            }
             else j++;
           }
-          const spans = txt && txt.chars.length > 0 ? resolveCharShapes(txt.chars, csp, di) : [buildSpan('')];
-          return { para: buildPara(spans, buildParaProps(ps)), next: j };
+          const paraContent: (SpanNode | ContentNode)[] = [];
+          if (txt && txt.chars.length > 0) paraContent.push(...resolveCharShapes(txt.chars, csp, di));
+          if (txt && txt.controls.length > 0) {
+            for (let ci = 0; ci < txt.controls.length; ci++) {
+              const ch = ctrlHdrs[ci];
+              if (!ch) continue;
+              const isImg = ch.ctrlId === CTRL_IMAGE || ch.ctrlId === CTRL_FIG || ch.ctrlId === CTRL_OBJ || ch.ctrlId === CTRL_GSO;
+              if (!isImg) continue;
+              const dimStr = (ch.wPt > 0 && ch.hPt > 0) ? `_W${Math.round(ch.wPt)}_H${Math.round(ch.hPt)}` : '';
+              paraContent.push(buildSpan(`__EXT_${ch.imgId}${dimStr}__`));
+            }
+          }
+          const kids = paraContent.length > 0 ? paraContent as any : [buildSpan('')];
+          // P6: innerGrids 먼저, 앵커 문단 나중 (P5와 동일한 순서)
+          const items: (ParaNode | GridNode)[] = [...innerGrids, buildPara(kids, buildParaProps(ps, cellStyleId))];
+          if (cellDivide & 4) items.unshift(buildPara([{ tag: 'span', props: {}, kids: [buildPb()] } as SpanNode]));
+          return { items, next: j };
         },
-        { para: buildPara([buildSpan('')]), next: k + 1 },
+        { items: [buildPara([buildSpan('')])] as (ParaNode | GridNode)[], next: k + 1 },
         `hwp:cellP@${k}`,
       );
-      paras.push(r.para);
+      cellChildren.push(...r.items);
       k = r.next;
+    } else if (recs[k].tag === TAG_CTRL_HEADER && recs[k].data.length >= 4) {
+      // CTRL_HEADER at cell level (sibling of PARA_HEADER) — anchored 'gso' images and outer-level nested tables
+      const cellCtrlId = BinaryKit.readU32LE(recs[k].data, 0);
+      if (cellCtrlId === CTRL_GSO) {
+        const gsoId = gsoCtx.count++;
+        const rawW = recs[k].data.length >= 24 ? BinaryKit.readU32LE(recs[k].data, 16) : 0;
+        const rawH = recs[k].data.length >= 28 ? BinaryKit.readU32LE(recs[k].data, 20) : 0;
+        const wPt = rawW > 0 && rawW < MAX_HWP ? Metric.hwpToPt(rawW) : 0;
+        const hPt = rawH > 0 && rawH < MAX_HWP ? Metric.hwpToPt(rawH) : 0;
+        const dimStr = (wPt > 0 && hPt > 0) ? `_W${Math.round(wPt)}_H${Math.round(hPt)}` : '';
+        cellChildren.push(buildPara([buildSpan(`__EXT_${gsoId}${dimStr}__`)]));
+        k = skipKids(recs, k);
+      } else if (cellCtrlId === CTRL_TABLE) {
+        const tr = shield.guard(
+          () => parseTableCtrl(recs, k, di, shield, gsoCtx),
+          { grid: null, next: skipKids(recs, k) },
+          `hwp:nestedTbl@${k}`,
+        );
+        if (tr.grid) cellChildren.push(tr.grid as GridNode);
+        k = tr.next;
+      } else {
+        k = skipKids(recs, k);
+      }
     } else { k++; }
   }
 
-  return { row, col, cs, rs, props, widthHwp, paras: paras.length ? paras : [buildPara([buildSpan('')])] };
+  return {
+    row, col, cs, rs, props, widthHwp,
+    heightHwp: heightHwp || undefined,
+    cellChildren: cellChildren.length ? cellChildren : [buildPara([buildSpan('')])],
+  };
 }
 
 /* ── PAGE_DEF ───────────────────────────────────────────────── */
 /*  [0:4] width  [4:4] height  [8:4] ml  [12:4] mr
-    [16:4] mt  [20:4] mb  [36:4] attr (bit0=landscape)           */
+    [16:4] mt  [20:4] mb  [24:4] header  [28:4] footer  [36:4] attr (bit0=landscape) */
 
 function parsePageDef(d: Uint8Array): PageDims {
   if (d.length < 24) return A4;
@@ -761,11 +965,15 @@ function parsePageDef(d: Uint8Array): PageDims {
   const mr = BinaryKit.readU32LE(d, 12);
   const mt = BinaryKit.readU32LE(d, 16);
   const mb = BinaryKit.readU32LE(d, 20);
+  const header = d.length >= 28 ? BinaryKit.readU32LE(d, 24) : 0;
+  const footer = d.length >= 32 ? BinaryKit.readU32LE(d, 28) : 0;
   const at = d.length >= 40 ? BinaryKit.readU32LE(d, 36) : 0;
   return {
     wPt: Metric.hwpToPt(w),  hPt: Metric.hwpToPt(h),
     ml: Metric.hwpToPt(ml),  mr: Metric.hwpToPt(mr),
     mt: Metric.hwpToPt(mt),  mb: Metric.hwpToPt(mb),
+    headerPt: header > 0 ? Metric.hwpToPt(header) : undefined,
+    footerPt: footer > 0 ? Metric.hwpToPt(footer) : undefined,
     orient: (at & 1) ? 'landscape' : 'portrait',
   };
 }
@@ -788,6 +996,18 @@ function toStroke(b: { type: number; widthPt: number; color: string }): Stroke {
   return { kind: BORDER_KIND[b.type] ?? 'solid', pt: b.widthPt, color: b.color };
 }
 
+// Apply borderFill to CellProps. Preserve explicit NONE so DOCX tcBorders can
+// override the table-level tblBorders. Filtering NONE would let tblBorders bleed through.
+function applyCellBorderFill(bf: HwpBorderFill, props: CellProps): void {
+  if (bf.borders.length >= 4) {
+    props.left  = toStroke(bf.borders[0]);
+    props.right = toStroke(bf.borders[1]);
+    props.top   = toStroke(bf.borders[2]);
+    props.bot   = toStroke(bf.borders[3]);
+  }
+  if (bf.bgColor && bf.bgColor !== 'FFFFFF') props.bg = bf.bgColor;
+}
+
 function strokeFromBF(bfId: number, di: DocInfo): Stroke | undefined {
   if (bfId <= 0 || bfId > di.borderFills.length) return undefined;
   const bf = di.borderFills[bfId - 1];
@@ -796,14 +1016,30 @@ function strokeFromBF(bfId: number, di: DocInfo): Stroke | undefined {
   return { kind: BORDER_KIND[b.type] ?? 'solid', pt: b.widthPt, color: b.color };
 }
 
-function buildParaProps(ps?: HwpParaShape): ParaProps {
-  if (!ps) return {};
-  const p: ParaProps = {};
+function buildParaProps(ps?: HwpParaShape, hwpStyleId?: number): ParaProps {
+  // P2: hwpStyleId를 초기값으로 포함 (undefined이면 빈 객체)
+  const p: ParaProps = hwpStyleId !== undefined ? { hwpStyleId } : {};
+  if (!ps) return p;
   if (ps.align && ps.align !== 'left') p.align = ps.align;
   if (ps.spaceBefore > 0) p.spaceBefore = Metric.hwpToPt(ps.spaceBefore);
   if (ps.spaceAfter > 0)  p.spaceAfter  = Metric.hwpToPt(ps.spaceAfter);
-  if (ps.lineSpacing > 0 && ps.lineSpacing !== 160) p.lineHeight = ps.lineSpacing / 100;
-  if (ps.indent > 0) p.indentPt = Metric.hwpToPt(ps.indent);
+  // 줄 간격: type=0(PERCENT) → lineHeight, type=1(FIXED) → lineHeightFixed
+  if (ps.lineSpacingType === 1) {
+    if (ps.lineSpacing > 0) p.lineHeightFixed = Metric.hwpToPt(ps.lineSpacing);
+  } else {
+    // P10: 160%(HWP 기본값) 생략 버그 수정 — 항상 lineHeight 설정
+    if (ps.lineSpacing > 0) p.lineHeight = ps.lineSpacing / 100;
+  }
+  // leftMargin (offset 4) = 문단 몸체 왼쪽 여백 → leftMargin (pt), ensure non-negative
+  const leftMarginPt = Math.max(0, Metric.hwpToPt(ps.leftMargin));
+  if (leftMarginPt > 0) p.leftMargin = leftMarginPt;
+  // rightMargin (offset 8) = 문단 몸체 오른쪽 여백 → indentRightPt (pt)
+  const rightMarginPt = Math.max(0, Metric.hwpToPt(ps.rightMargin));
+  if (rightMarginPt > 0) p.indentRightPt = rightMarginPt;
+  // indent (offset 12) = 첫 줄 들여쓰기(양수) / 내어쓰기(음수) → firstLineIndentPt
+  if (ps.indent !== 0) p.firstLineIndentPt = Metric.hwpToPt(ps.indent);
+  if (ps.verAlign && ps.verAlign !== 'baseline') p.verAlign = ps.verAlign;
+  if (ps.lineWrap && ps.lineWrap !== 'break') p.lineWrap = ps.lineWrap;
   return p;
 }
 
@@ -813,6 +1049,7 @@ function buildParaProps(ps?: HwpParaShape): ParaProps {
 
 export class HwpScanner implements Decoder {
   readonly format = 'hwp';
+  readonly aliases = ['application/vnd.hancom.hwp'];
 
   async decode(data: Uint8Array): Promise<Outcome<DocRoot>> {
     const shield = new ShieldedParser();
@@ -834,52 +1071,36 @@ export class HwpScanner implements Decoder {
         di = shield.guard(() => parseDocInfo(diRaw, compressed), di, 'hwp:docInfo');
       }
 
-      // Extract images from BinData streams
-      const imageStreams: { path: string; data: Uint8Array }[] = [];
-      for (const [path, data] of streams) {
-        if ((path.includes('BinData') || path.includes('.jpg') || path.includes('.jpeg') || path.includes('.png') || path.includes('.gif') || path.includes('.bmp'))
-            && !path.includes('FileHeader') && !path.includes('DocInfo') && !path.includes('BodyText') && !path.includes('Section')) {
-          imageStreams.push({ path, data });
-          console.log(`[HwpScanner] Image stream found: ${path} (${data.length} bytes)`);
-        }
+      // Extract images from BinData streams.
+      // HWP duplicates each BinData entry: once as "BinData/BIN0001.jpg" and once as "BIN0001.jpg".
+      // We keep only the "BinData/" prefixed versions, sort by BIN number, then assign 0-based keys
+      // matching the order 'gso' CTRL_HEADER records are encountered during body parsing.
+      const binEntries: { binNum: number; data: Uint8Array }[] = [];
+      for (const [path, streamData] of streams) {
+        // Match "BinData/BIN0001.jpg" style — the canonical form
+        const m = path.match(/^BinData[/\\]BIN(\d+)\.\w+$/i);
+        if (m) binEntries.push({ binNum: parseInt(m[1], 10), data: streamData });
       }
+      // Sort by BIN number (ascending) so BIN0001→idx0, BIN0002→idx1, …
+      binEntries.sort((a, b) => a.binNum - b.binNum);
 
-      // Create image nodes for each image stream (deduplicated by hash)
       const objectMap = new Map<number, ImgNode>();
-      const seenHashes = new Set<string>();
-      let imgIdx = 0;
-      for (const { path, data } of imageStreams) {
-        // Determine MIME type from extension or signature
-        let mimeType = 'image/jpeg';
-        const lowerPath = path.toLowerCase();
-        if (lowerPath.includes('.png')) mimeType = 'image/png';
-        else if (lowerPath.includes('.gif')) mimeType = 'image/gif';
-        else if (lowerPath.includes('.bmp')) mimeType = 'image/bmp';
-
-        // Also check signature
-        if (data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4E && data[3] === 0x47) mimeType = 'image/png';
-        else if (data[0] === 0x47 && data[1] === 0x49 && data[2] === 0x46 && data[3] === 0x3538) mimeType = 'image/gif';
-        else if (data[0] === 0x42 && data[1] === 0x4D) mimeType = 'image/bmp';
-
-        const imgData = Buffer.from(data);
-        const base64 = imgData.toString('base64');
-        const hash = base64.slice(0, 20); // Use first 20 chars as simple hash
-        if (!seenHashes.has(hash)) {
-          seenHashes.add(hash);
-          objectMap.set(imgIdx++, buildImg(
-            base64,
-            mimeType as any,
-            0, // w
-            0, // h
-            `Image from ${path}`,
-          ));
-          console.log(`[HwpScanner] Added unique image: ${hash}... (${data.length} bytes)`);
-        } else {
-          console.log(`[HwpScanner] Duplicate image skipped: ${hash}...`);
-        }
+      for (let idx = 0; idx < binEntries.length; idx++) {
+        const { data: imgData } = binEntries[idx];
+
+        // Determine MIME type from binary signature first, then fall back to extension
+        let mimeType: ImgNode['mime'] = 'image/jpeg';
+        if (imgData[0] === 0x89 && imgData[1] === 0x50) mimeType = 'image/png';
+        else if (imgData[0] === 0x47 && imgData[1] === 0x49) mimeType = 'image/gif';
+        else if (imgData[0] === 0x42 && imgData[1] === 0x4D) mimeType = 'image/bmp';
+
+        const base64 = TextKit.base64Encode(imgData);
+        const { wPt, hPt } = getImageDimsPt(imgData, mimeType);
+        objectMap.set(idx, buildImg(base64, mimeType, wPt, hPt));
       }
 
-      console.log(`[HwpScanner] Found ${imageStreams.length} image streams, ${objectMap.size} unique images`);
+      // gsoCtx tracks sequential 'gso' encounter order — must be shared across all sections
+      const gsoCtx: GsoCtx = { count: 0 };
 
       // Body sections
       const allContent: ContentNode[] = [];
@@ -891,7 +1112,7 @@ export class HwpScanner implements Decoder {
           if (s === 0) {
             const fb = findBodySection(streams);
             if (fb) {
-              const r = parseBody(fb, compressed, di, shield);
+              const r = parseBody(fb, compressed, di, shield, gsoCtx);
               allContent.push(...r.content);
               if (r.pageDims) pageDims = r.pageDims;
             }
@@ -899,7 +1120,7 @@ export class HwpScanner implements Decoder {
           break;
         }
         const r = shield.guard(
-          () => parseBody(sec, compressed, di, shield),
+          () => parseBody(sec, compressed, di, shield, gsoCtx),
           { content: [], pageDims: undefined },
           `hwp:sec${s}`,
         );
@@ -907,33 +1128,17 @@ export class HwpScanner implements Decoder {
         if (r.pageDims) pageDims = r.pageDims;
       }
 
-      // Inject images into paragraphs (only if images are available)
-      console.log(`[HwpScanner] Before injection: ${allContent.length} nodes, ${objectMap.size} images available`);
       if (objectMap.size > 0) {
         injectImagesIntoContent(allContent, objectMap);
-        console.log(`[HwpScanner] After injection: ${allContent.length} nodes`);
       }
 
-      // Count images (recursively)
-      const countImages = (nodes: ContentNode[]): number => {
-        let count = 0;
-        for (const node of nodes) {
-          if ((node as any).tag === 'img') count++;
-          if ((node as any).tag === 'para' && (node as any).kids) count += countImages((node as any).kids);
-          if ((node as any).tag === 'grid' && (node as any).kids) {
-            for (const row of (node as any).kids) {
-              if (row.kids) count += countImages(row.kids);
-            }
-          }
-        }
-        return count;
-      };
-      const imgCount = countImages(allContent);
-      console.log(`[HwpScanner] Images in content: ${imgCount}`);
-
       warns.push(...shield.flush());
       const content = allContent.length > 0 ? allContent : [buildPara([buildSpan('')])];
-      return succeed(buildRoot({}, [buildSheet(content, pageDims)]), warns);
+      // P8: 머리말/꼬리말을 gsoCtx에서 가져와 buildSheet에 전달
+      return succeed(buildRoot({}, [buildSheet(content, pageDims, {
+        headers: gsoCtx.headers ? { default: gsoCtx.headers } : undefined,
+        footers: gsoCtx.footers ? { default: gsoCtx.footers } : undefined,
+      })]), warns);
     } catch (e: any) {
       warns.push(...shield.flush());
       return fail(`HWP decode error: ${e?.message ?? String(e)}`, warns);
@@ -947,6 +1152,52 @@ function findBodySection(streams: Map<string, Uint8Array>): Uint8Array | undefin
   return undefined;
 }
 
+/* ═══════════════════════════════════════════════════════════════
+   Image dimension extraction from binary headers
+   ════════════════════════════════════════════════════════════ */
+
+// Returns { wPt, hPt } by parsing image headers; falls back to { wPt: 72, hPt: 72 } (1-inch)
+function getImageDimsPt(data: Uint8Array, mime: string): { wPt: number; hPt: number } {
+  const fallback = { wPt: 72, hPt: 72 };
+  try {
+    if (mime === 'image/png' && data.length >= 24) {
+      // PNG IHDR: sig(8) + length(4) + type(4) + width(4) + height(4) — all big-endian
+      const w = (data[16] << 24 | data[17] << 16 | data[18] << 8 | data[19]) >>> 0;
+      const h = (data[20] << 24 | data[21] << 16 | data[22] << 8 | data[23]) >>> 0;
+      if (w > 0 && h > 0) return { wPt: w * 0.75, hPt: h * 0.75 }; // 96 DPI → pt
+    }
+    if (mime === 'image/jpeg') {
+      // Scan for SOF markers: FF C0 / C1 / C2 / C3
+      let i = 2;
+      while (i + 8 < data.length) {
+        if (data[i] !== 0xFF) { i++; continue; }
+        const marker = data[i + 1];
+        if (marker >= 0xC0 && marker <= 0xC3) {
+          // SOF: 2-byte marker + 2-byte length + 1-byte precision + 2-byte height + 2-byte width
+          const h = (data[i + 5] << 8 | data[i + 6]) >>> 0;
+          const w = (data[i + 7] << 8 | data[i + 8]) >>> 0;
+          if (w > 0 && h > 0) return { wPt: w * 0.75, hPt: h * 0.75 };
+        }
+        const segLen = data[i + 2] << 8 | data[i + 3];
+        i += 2 + (segLen > 0 ? segLen : 2);
+      }
+    }
+    if (mime === 'image/bmp' && data.length >= 26) {
+      // BMP DIB header: width at 18, height at 22 (signed int32 LE; negative = top-down)
+      const w = BinaryKit.readU32LE(data, 18);
+      const h = Math.abs(BinaryKit.readU32LE(data, 22) | 0);
+      if (w > 0 && h > 0) return { wPt: w * 0.75, hPt: h * 0.75 };
+    }
+    if (mime === 'image/gif' && data.length >= 10) {
+      // GIF: width at 6, height at 8 (uint16 LE)
+      const w = data[6] | data[7] << 8;
+      const h = data[8] | data[9] << 8;
+      if (w > 0 && h > 0) return { wPt: w * 0.75, hPt: h * 0.75 };
+    }
+  } catch { /* ignore */ }
+  return fallback;
+}
+
 /* ═══════════════════════════════════════════════════════════════
    OLE Object extraction (images)
    ════════════════════════════════════════════════════════════ */
@@ -994,35 +1245,69 @@ function injectImagesIntoContent(
   content: ContentNode[],
   objectMap: Map<number, ImgNode>
 ): void {
-  const imageArray = Array.from(objectMap.values());
-  if (imageArray.length === 0) return;
+  if (objectMap.size === 0) return;
+
+  // Helper function to process a list of kids (spans, images, etc.)
+  const processKids = (kids: any[]) => {
+    for (let i = 0; i < kids.length; i++) {
+      const kid = kids[i];
+      // Span node structure: { tag: 'span', props, kids: [{ tag: 'txt', content }] }
+      if (kid.tag === 'span' && kid.kids && kid.kids[0]?.tag === 'txt') {
+        const text = kid.kids[0].content;
+        // __EXT_N__ or __EXT_N_W<wPt>_H<hPt>__ (with encoded display size)
+        // N is the objId that matches the index in objectMap
+        const match = text.match?.(/^__(?:IMG|EXT)_(\d+)(?:_W(\d+)_H(\d+))?__$/);
+        if (match) {
+          const objId = parseInt(match[1], 10);
+          const base = objectMap.get(objId);
+          if (base) {
+            const wPt = match[2] ? parseInt(match[2], 10) : 0;
+            const hPt = match[3] ? parseInt(match[3], 10) : 0;
+            // Use encoded display size when valid; otherwise keep pixel-based dims
+            kids[i] = (wPt > 0 && hPt > 0) ? { ...base, w: wPt, h: hPt } : base;
+          }
+        }
+      }
+    }
+  };
 
-  // Get unique images (deduplicate by base64 content)
-  const uniqueImages = Array.from(new Set(imageArray.map(img => img.b64))).map(b64 => {
-    return imageArray.find(img => img.b64 === b64)!;
-  });
-  if (uniqueImages.length === 0) return;
+  // Recursively process a grid (table): resolves image placeholders in all cells,
+  // including nested grids inside cells.
+  const processGridKids = (grid: any) => {
+    if (!grid.kids || !Array.isArray(grid.kids)) return;
+
+    for (const row of grid.kids) {
+      if (!row.kids || !Array.isArray(row.kids)) continue;
+
+      for (const cell of row.kids) {
+        if (!cell.kids || !Array.isArray(cell.kids)) continue;
+
+        for (const cellKid of cell.kids) {
+          if (cellKid.tag === 'grid') {
+            // Nested table inside cell — recurse
+            processGridKids(cellKid);
+          } else if (cellKid.tag === 'para' && cellKid.kids) {
+            processKids(cellKid.kids);
+          }
+        }
+      }
+    }
+  };
 
-  let imgIdx = 0;
   for (const node of content) {
     if (node.tag === 'para' && node.kids) {
-      for (let i = 0; i < node.kids.length; i++) {
-        const kid = node.kids[i];
-        // Span node structure: { tag: 'span', props, kids: [{ tag: 'txt', content }] }
-        if (kid.tag === 'span' && kid.kids && kid.kids[0]?.tag === 'txt') {
-          const text = kid.kids[0].content;
-          // Support both __IMG_N__ and __EXT_N__ patterns
-          const match = text.match?.(/^__(?:IMG|EXT)_(\d+)__$/);
-          if (match) {
-            // Replace placeholder with next available image (round-robin)
-            const imgNode = uniqueImages[imgIdx % uniqueImages.length];
-            if (imgNode) {
-              node.kids[i] = imgNode;
-              imgIdx++;
-            }
-          }
+      // Process paragraph kids (spans, images, links, grids)
+      processKids(node.kids);
+
+      // Also process any nested grids inside the paragraph
+      for (const kid of node.kids) {
+        if (kid.tag === 'grid') {
+          processGridKids(kid);
         }
       }
+    } else if (node.tag === 'grid') {
+      // Process grid nodes (tables)
+      processGridKids(node);
     }
   }
 }