hwpkit-dev 0.0.2 → 0.0.5

package/src/encoders/hwp/HwpEncoder.ts

@@ -1,217 +1,310 @@
 /**
- * HWP 5.0 encoder — DocRoot → HWP binary (OLE2/CFB container)
+ * HwpEncoder — DocRoot → HWP 5.0 바이너리 (OLE2/CFB 컨테이너)
  *
- * OLE2 layout:
- *   FileHeader (stream)  — 256-byte HWP signature + flags
- *   DocInfo    (stream)  — compressed FACE_NAME / CHAR_SHAPE / PARA_SHAPE records
+ * ANYTOHWP에서 영감받은 개선 사항:
+ *  1. HwpStyleBank  — 7개 언어 그룹 독립 폰트 레지스트리 (HANGUL/LATIN/HANJA/…)
+ *  2. readPixelDims — PNG/JPEG 바이너리 헤더에서 픽셀 치수 추출 → 정확한 HWPUNIT 변환
+ *  3. mkIdMappings  — 언어별 폰트 카운트를 개별 기록
+ *  4. mkCharShape   — 언어별 faceId[7] 사용
+ *
+ * OLE2 레이아웃:
+ *   FileHeader (stream)  — 256-byte HWP 시그니처 + 플래그
+ *   DocInfo    (stream)  — zlib 압축된 FACE_NAME / CHAR_SHAPE / PARA_SHAPE 레코드
  *   BodyText   (storage)
- *     Section0 (stream) — compressed PAGE_DEF + paragraph/table records
+ *     Section0 (stream) — zlib 압축된 PAGE_DEF + 문단/표 레코드
  */
 
-import type { Encoder }       from '../../contract/encoder';
-import type { DocRoot, ContentNode, ParaNode, SpanNode, GridNode } from '../../model/doc-tree';
-import type { Outcome }       from '../../contract/result';
-import type { TextProps, ParaProps, Stroke, PageDims } from '../../model/doc-props';
-import { succeed, fail }      from '../../contract/result';
-import { Metric }             from '../../safety/StyleBridge';
-import { registry }           from '../../pipeline/registry';
-import { A4 }                 from '../../model/doc-props';
-import pako                   from 'pako';
-import { TextKit }            from '../../toolkit/TextKit';
-
-/* ═══════════════════════════════════════════════════════════════
-   HWP 5.0 tag IDs (HWP 5.0 spec 표 13, 표 57)
-   HWPTAG_BEGIN = 16 (0x10)
-   ═══════════════════════════════════════════════════════════════ */
-
+import type {
+  DocRoot,
+  ContentNode,
+  ParaNode,
+  SpanNode,
+  GridNode,
+  ImgNode,
+  LinkNode,
+} from "../../model/doc-tree";
+import type { Outcome } from "../../contract/result";
+import type {
+  TextProps,
+  ParaProps,
+  Stroke,
+  PageDims,
+  Align,
+} from "../../model/doc-props";
+import { succeed, fail } from "../../contract/result";
+import { Metric, safeFontToKr } from "../../safety/StyleBridge";
+import { registry } from "../../pipeline/registry";
+import { A4 } from "../../model/doc-props";
+import pako from "pako";
+import { TextKit } from "../../toolkit/TextKit";
+import { BaseEncoder } from "../../core/BaseEncoder";
+
+// ─── HWP 5.0 태그 ID ────────────────────────────────────────
 const T = 16; // HWPTAG_BEGIN
 
-// DocInfo tags (표 13)
-const TAG_DOCUMENT_PROPERTIES = T + 0;  // 16 - HWPTAG_DOCUMENT_PROPERTIES
-const TAG_ID_MAPPINGS          = T + 1;  // 17 - HWPTAG_ID_MAPPINGS
-const TAG_FACE_NAME            = T + 3;  // 19 - HWPTAG_FACE_NAME
-const TAG_BORDER_FILL          = T + 4;  // 20 - HWPTAG_BORDER_FILL
-const TAG_CHAR_SHAPE           = T + 5;  // 21 - HWPTAG_CHAR_SHAPE
-const TAG_PARA_SHAPE           = T + 9;  // 25 - HWPTAG_PARA_SHAPE
-
-// DocInfo tags (additional)
-const TAG_BIN_DATA             = T + 2;  // 18 - HWPTAG_BIN_DATA
-
-// BodyText tags (표 57)
-const TAG_PARA_HEADER          = T + 50; // 66 - HWPTAG_PARA_HEADER
-const TAG_PARA_TEXT            = T + 51; // 67 - HWPTAG_PARA_TEXT
-const TAG_PARA_CHAR_SHAPE      = T + 52; // 68 - HWPTAG_PARA_CHAR_SHAPE
-const TAG_PARA_LINE_SEG        = T + 53; // 69 - HWPTAG_PARA_LINE_SEG
-const TAG_CTRL_HEADER          = T + 55; // 71 - HWPTAG_CTRL_HEADER
-const TAG_LIST_HEADER          = T + 56; // 72 - HWPTAG_LIST_HEADER
-const TAG_PAGE_DEF             = T + 57; // 73 - HWPTAG_PAGE_DEF
-const TAG_FOOTNOTE_SHAPE       = T + 58; // 74 - HWPTAG_FOOTNOTE_SHAPE
-const TAG_TABLE                = T + 61; // 77 - HWPTAG_TABLE (표 개체)
-const TAG_SHAPE_COMPONENT_PICTURE = T + 69; // 85 - HWPTAG_SHAPE_COMPONENT_PICTURE
-
-// Control IDs (stored as LE UINT32, MAKE_4CHID order)
-const CTRL_TABLE = 0x74626C20; // 'tbl ' table
-const CTRL_SECD  = 0x73656364; // 'secd' section definition
-const CTRL_PIC   = 0x24706963; // '$pic' picture/image
-
-/** Border width index table (points) — 표 26 테두리선 굵기 (mm→pt conversion) */
+// DocInfo 태그
+const TAG_DOCUMENT_PROPERTIES = T + 0; // 16
+const TAG_ID_MAPPINGS = T + 1; // 17
+const TAG_BIN_DATA = T + 2; // 18
+const TAG_FACE_NAME = T + 3; // 19
+const TAG_BORDER_FILL = T + 4; // 20
+const TAG_CHAR_SHAPE = T + 5; // 21
+const TAG_PARA_SHAPE = T + 9; // 25
+const TAG_STYLE = T + 10; // 26
+
+// BodyText 태그
+const TAG_PARA_HEADER = T + 50; // 66
+const TAG_PARA_TEXT = T + 51; // 67
+const TAG_PARA_CHAR_SHAPE = T + 52; // 68
+const TAG_PARA_LINE_SEG = T + 53; // 69
+const TAG_CTRL_HEADER = T + 55; // 71
+const TAG_LIST_HEADER = T + 56; // 72
+const TAG_PAGE_DEF = T + 57; // 73
+const TAG_FOOTNOTE_SHAPE = T + 58; // 74
+const TAG_TABLE = T + 61; // 77
+const TAG_SHAPE_COMPONENT_PICTURE = T + 69; // 85
+
+// Control ID (LE UINT32)
+const CTRL_TABLE = 0x74626c20; // 'tbl '
+const CTRL_SECD = 0x73656364; // 'secd'
+const CTRL_PIC = 0x24706963; // '$pic'
+const CTRL_FIELD_BEGIN = 0x646c6625; // '%fld'
+const CTRL_FIELD_END = 0x646c665c; // '\fld'
+
+/** 테두리선 굵기 인덱스 테이블 (pt) */
 const BORDER_W_PT = [
-  0.28, 0.34, 0.43, 0.57, 0.71, 0.85,
-  1.13, 1.42, 1.70, 1.98, 2.84, 4.25,
-  5.67, 8.50, 11.34, 14.17,
+  0.28, 0.34, 0.43, 0.57, 0.71, 0.85, 1.13, 1.42, 1.7, 1.98, 2.84, 4.25, 5.67,
+  8.5, 11.34, 14.17,
 ];
 
-/** 표 25 테두리선 종류: 0=실선(solid), 2=점선(dash), 3=dash-dot, 7=2중선(double) */
 const BORDER_KIND_IDX: Record<string, number> = {
-  solid: 0, dash: 2, dot: 3, double: 7, none: 0,
+  solid: 0,
+  dot: 1,
+  dash: 2,
+  double: 7,
+  triple: 8,
+  none: 0,
 };
 
-/**
- * 표 44 문단 모양 속성1:
- * bits 2-4 = 정렬 방식 (0=양쪽, 1=왼쪽, 2=오른쪽, 3=가운데)
- */
 const ALIGN_CODE: Record<string, number> = {
-  justify: 0, left: 1, right: 2, center: 3,
+  justify: 0,
+  left: 1,
+  right: 2,
+  center: 3,
+  distribute: 4,
 };
 
-/* ═══════════════════════════════════════════════════════════════
-   Binary buffer writer
-   ═══════════════════════════════════════════════════════════════ */
+// ─── 바이너리 버퍼 라이터 ────────────────────────────────────
 
 class BufWriter {
   private chunks: Uint8Array[] = [];
   private _sz = 0;
-
-  get size() { return this._sz; }
+  get size() {
+    return this._sz;
+  }
 
   u8(v: number): this {
-    this.chunks.push(new Uint8Array([v & 0xFF]));
+    this.chunks.push(new Uint8Array([v & 0xff]));
     this._sz++;
     return this;
   }
-
   u16(v: number): this {
-    this.chunks.push(new Uint8Array([v & 0xFF, (v >> 8) & 0xFF]));
+    this.chunks.push(new Uint8Array([v & 0xff, (v >> 8) & 0xff]));
     this._sz += 2;
     return this;
   }
-
   u32(v: number): this {
     const b = new Uint8Array(4);
-    b[0] = v & 0xFF;
-    b[1] = (v >>> 8) & 0xFF;
-    b[2] = (v >>> 16) & 0xFF;
-    b[3] = (v >>> 24) & 0xFF;
+    b[0] = v & 0xff;
+    b[1] = (v >>> 8) & 0xff;
+    b[2] = (v >>> 16) & 0xff;
+    b[3] = (v >>> 24) & 0xff;
     this.chunks.push(b);
     this._sz += 4;
     return this;
   }
-
-  i32(v: number): this { return this.u32(v < 0 ? v + 0x100000000 : v); }
-
-  i16(v: number): this { return this.u16(v < 0 ? v + 0x10000 : v); }
-
-  bytes(d: Uint8Array): this { this.chunks.push(d); this._sz += d.length; return this; }
-  zeros(n: number): this    { this.chunks.push(new Uint8Array(n)); this._sz += n; return this; }
-
-  /** Write each char as UTF-16LE UINT16 (BMP only) */
+  i32(v: number): this {
+    return this.u32(v < 0 ? v + 0x100000000 : v);
+  }
+  i16(v: number): this {
+    return this.u16(v < 0 ? v + 0x10000 : v);
+  }
+  bytes(d: Uint8Array): this {
+    this.chunks.push(d);
+    this._sz += d.length;
+    return this;
+  }
+  zeros(n: number): this {
+    this.chunks.push(new Uint8Array(n));
+    this._sz += n;
+    return this;
+  }
   utf16(s: string): this {
     for (let i = 0; i < s.length; i++) this.u16(s.charCodeAt(i));
     return this;
   }
-
-  /** Write 4-byte COLORREF (R, G, B, 0) from 6-hex string */
   colorRef(hex: string): this {
-    const h = (hex || '000000').replace('#', '').padStart(6, '0');
-    return this
-      .u8(parseInt(h.slice(0, 2), 16))
+    const h = (hex || "000000").replace("#", "").padStart(6, "0");
+    return this.u8(parseInt(h.slice(0, 2), 16))
       .u8(parseInt(h.slice(2, 4), 16))
       .u8(parseInt(h.slice(4, 6), 16))
       .u8(0);
   }
-
   build(): Uint8Array {
     const out = new Uint8Array(this._sz);
     let off = 0;
-    for (const c of this.chunks) { out.set(c, off); off += c.length; }
+    for (const c of this.chunks) {
+      out.set(c, off);
+      off += c.length;
+    }
     return out;
   }
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   HWP record builder
-   Format: 32-bit header = size(12)|level(10)|tag(10)
-   If size >= 0xFFF, append UINT32 with actual size.
-   ═══════════════════════════════════════════════════════════════ */
+// ─── HWP 레코드 빌더 ─────────────────────────────────────────
 
 function mkRec(tag: number, level: number, data: Uint8Array): Uint8Array {
   const sz = data.length;
-  const enc = Math.min(sz, 0xFFF);
-  const hdr = (enc << 20) | ((level & 0x3FF) << 10) | (tag & 0x3FF);
+  const isLarge = sz >= 0xfff;
+  const enc = isLarge ? 0xfff : sz;
+  const hdr = (((enc & 0xfff) * 0x100000) | ((level & 0x3ff) << 10) | (tag & 0x3ff)) >>> 0;
   const w = new BufWriter().u32(hdr);
-  if (enc >= 0xFFF) w.u32(sz);
+  if (isLarge) w.u32(sz);
   w.bytes(data);
   return w.build();
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   Style collector (first pass — deduplicates fonts/shapes)
-   ═══════════════════════════════════════════════════════════════ */
-
-function csKey(p: TextProps): string {
-  return [p.font ?? '', p.pt ?? 10, p.b ? 1 : 0, p.i ? 1 : 0, p.u ? 1 : 0,
-    p.s ? 1 : 0, p.sup ? 1 : 0, p.sub ? 1 : 0, p.color ?? '000000'].join('|');
-}
-function psKey(p: ParaProps): string {
-  return [p.align ?? 'left', p.indentPt ?? 0, p.spaceBefore ?? 0,
-    p.spaceAfter ?? 0, p.lineHeight ?? 1].join('|');
-}
-function bfKey(s: Stroke, bg?: string): string {
-  return `${s.kind}|${s.pt}|${s.color}|${bg ?? ''}`;
-}
-function bfPerSideKey(l: Stroke, r: Stroke, t: Stroke, b: Stroke, bg?: string): string {
-  return `${bfKey(l)}/${bfKey(r)}/${bfKey(t)}/${bfKey(b)}/${bg ?? ''}`;
+// ─── ANYTOHWP 영감: PNG/JPEG 바이너리 헤더에서 픽셀 치수 추출
+function readPixelDims(
+  data: Uint8Array,
+  mime: string,
+): { w: number; h: number } | null {
+  try {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (mime.includes("png")) {
+      if (
+        data.length >= 24 &&
+        view.getUint32(0) === 0x89504e47 &&
+        view.getUint32(4) === 0x0d0a1a0a
+      ) {
+        return { w: view.getUint32(16), h: view.getUint32(20) };
+      }
+    } else if (mime.includes("jpeg") || mime.includes("jpg")) {
+      let off = 2;
+      while (off < data.length - 4) {
+        const marker = view.getUint16(off);
+        off += 2;
+        if (marker === 0xffc0 || marker === 0xffc2) {
+          return { w: view.getUint16(off + 5), h: view.getUint16(off + 3) };
+        }
+        if ((marker & 0xff00) !== 0xff00) break;
+        off += view.getUint16(off);
+      }
+    }
+  } catch {
+    /* 무시 */
+  }
+  return null;
 }
 
-type BfEntry =
-  | { uniform: true; s: Stroke; bg?: string }
-  | { uniform: false; l: Stroke; r: Stroke; t: Stroke; b: Stroke; bg?: string };
+// ─── ANYTOHWP 영감: HwpStyleBank — 7개 언어 그룹 독립 폰트 레지스트리
+// StyleCollector를 대체하는 새로운 스타일 수집기
+
+const LANG_GROUPS = [
+  "HANGUL",
+  "LATIN",
+  "HANJA",
+  "JAPANESE",
+  "OTHER",
+  "SYMBOL",
+  "USER",
+] as const;
+type LangGroup = (typeof LANG_GROUPS)[number];
+
+/** 한글 폰트 여부 판별 */
+function isKoreanFont(face: string): boolean {
+  return (
+    /[\uAC00-\uD7A3\u3131-\u318E]/.test(face) ||
+    ["맑은", "나눔", "굴림", "돋움", "바탕", "함초롬", "한컴", "HY"].some((k) =>
+      face.includes(k),
+    )
+  );
+}
 
-class StyleCollector {
-  readonly DEF_STROKE: Stroke = { kind: 'solid', pt: 0.5, color: '000000' };
+class HwpStyleBank {
+  readonly DEF_STROKE: Stroke = { kind: "solid", pt: 0.5, color: "000000" };
 
-  fonts: string[] = ['Malgun Gothic'];
-  private fontIdx = new Map<string, number>([['Malgun Gothic', 0]]);
+  // 언어별 독립 폰트 목록 (ANYTOHWP langFontFaces)
+  private langFonts = new Map<LangGroup, string[]>(
+    LANG_GROUPS.map((g) => [g, []]),
+  );
+  private langFontIdx = new Map<LangGroup, Map<string, number>>(
+    LANG_GROUPS.map((g) => [g, new Map()]),
+  );
 
-  csProps: TextProps[] = [{}];
+  // charShape, parShape, borderFill 레지스트리
+  readonly csProps: TextProps[] = [{}];
   private csIdx = new Map<string, number>([[csKey({}), 0]]);
 
-  psProps: ParaProps[] = [{}];
+  readonly psProps: ParaProps[] = [{}];
   private psIdx = new Map<string, number>([[psKey({}), 0]]);
 
-  bfData: BfEntry[] = [];
+  readonly bfData: BfEntry[] = [];
   private bfIdx = new Map<string, number>();
 
+  // charShape마다 언어별 fontId를 기록
+  readonly csFontIds: number[][] = [[0, 0, 0, 0, 0, 0, 0]]; // id=0 → 모두 0
+
   constructor() {
+    // 기본 폰트 등록 (ANYTOHWP: 함초롬바탕)
+    for (const g of LANG_GROUPS) this._registerLangFont(g, "함초롬바탕");
     this.addBorderFill(this.DEF_STROKE); // bfId=1
   }
 
-  font(name: string): number {
-    const n = name || 'Malgun Gothic';
-    if (this.fontIdx.has(n)) return this.fontIdx.get(n)!;
-    const id = this.fonts.length;
-    this.fonts.push(n);
-    this.fontIdx.set(n, id);
+  private _registerLangFont(lang: LangGroup, face: string): number {
+    const idx = this.langFontIdx.get(lang)!;
+    if (idx.has(face)) return idx.get(face)!;
+    const id = this.langFonts.get(lang)!.length;
+    this.langFonts.get(lang)!.push(face);
+    idx.set(face, id);
     return id;
   }
 
+  /** 폰트 이름 → 언어별 7개 ID 반환 (ANYTOHWP 방식) */
+  registerFontForLangs(rawFace: string): number[] {
+    const face = safeFontToKr(rawFace) || "함초롬바탕";
+    const isKor = isKoreanFont(face);
+    const hangulFace = isKor ? face : "함초롬바탕";
+    const latinFace = isKor ? "함초롬바탕" : face;
+
+    const ids: number[] = [];
+    for (const lang of LANG_GROUPS) {
+      const f = lang === "LATIN" ? latinFace : hangulFace;
+      ids.push(this._registerLangFont(lang, f));
+    }
+    return ids; // [hangulId, latinId, hanjaId, japaneseId, otherId, symbolId, userId]
+  }
+
+  /** 언어별 폰트 목록 반환 */
+  getFontsForLang(lang: LangGroup): string[] {
+    return [...(this.langFonts.get(lang) ?? [])];
+  }
+
+  /** 폰트 수 반환 (mkIdMappings용) */
+  getFontCount(lang: LangGroup): number {
+    return this.langFonts.get(lang)?.length ?? 0;
+  }
+
   addCharShape(p: TextProps): number {
     const k = csKey(p);
     if (this.csIdx.has(k)) return this.csIdx.get(k)!;
     const id = this.csProps.length;
+    const fIds = p.font
+      ? this.registerFontForLangs(p.font)
+      : [0, 0, 0, 0, 0, 0, 0];
     this.csProps.push(p);
+    this.csFontIds.push(fIds);
     this.csIdx.set(k, id);
-    if (p.font) this.font(p.font);
     return id;
   }
 
@@ -224,7 +317,6 @@ class StyleCollector {
     return id;
   }
 
-  /** Returns 1-based border fill ID */
   addBorderFill(s: Stroke, bg?: string): number {
     const k = bfKey(s, bg);
     if (this.bfIdx.has(k)) return this.bfIdx.get(k)!;
@@ -234,7 +326,13 @@ class StyleCollector {
     return id;
   }
 
-  addBorderFillPerSide(l: Stroke, r: Stroke, t: Stroke, b: Stroke, bg?: string): number {
+  addBorderFillPerSide(
+    l: Stroke,
+    r: Stroke,
+    t: Stroke,
+    b: Stroke,
+    bg?: string,
+  ): number {
     const k = bfPerSideKey(l, r, t, b, bg);
     if (this.bfIdx.has(k)) return this.bfIdx.get(k)!;
     const id = this.bfData.length + 1;
@@ -244,174 +342,205 @@ class StyleCollector {
   }
 }
 
-function collectNode(node: ContentNode, col: StyleCollector): void {
-  if (node.tag === 'para') {
-    col.addParaShape(node.props);
+// ─── 키 함수 ────────────────────────────────────────────────
+
+function csKey(p: TextProps): string {
+  return [
+    p.font ?? "",
+    p.pt ?? 10,
+    p.b ? 1 : 0,
+    p.i ? 1 : 0,
+    p.u ? 1 : 0,
+    p.s ? 1 : 0,
+    p.sup ? 1 : 0,
+    p.sub ? 1 : 0,
+    p.color ?? "000000",
+  ].join("|");
+}
+
+function psKey(p: ParaProps): string {
+  return [
+    p.align ?? "left",
+    p.indentPt ?? 0,
+    p.firstLineIndentPt ?? 0,
+    p.spaceBefore ?? 0,
+    p.spaceAfter ?? 0,
+    p.lineHeight ?? 1,
+  ].join("|");
+}
+
+function bfKey(s: Stroke, bg?: string): string {
+  return `${s.kind}|${s.pt}|${s.color}|${bg ?? ""}`;
+}
+
+function bfPerSideKey(
+  l: Stroke,
+  r: Stroke,
+  t: Stroke,
+  b: Stroke,
+  bg?: string,
+): string {
+  return `${bfKey(l)}/${bfKey(r)}/${bfKey(t)}/${bfKey(b)}/${bg ?? ""}`;
+}
+
+type BfEntry =
+  | { uniform: true; s: Stroke; bg?: string }
+  | { uniform: false; l: Stroke; r: Stroke; t: Stroke; b: Stroke; bg?: string };
+
+// ─── Pre-scan: 스타일 수집 ──────────────────────────────────
+
+function collectNode(node: ContentNode, bank: HwpStyleBank): void {
+  if (node.tag === "para") {
+    bank.addParaShape(node.props);
     for (const kid of node.kids) {
-      if (kid.tag === 'span') col.addCharShape((kid as SpanNode).props);
+      if (kid.tag === "span") bank.addCharShape((kid as SpanNode).props);
     }
-  } else if (node.tag === 'grid') {
-    if (node.props.defaultStroke) col.addBorderFill(node.props.defaultStroke);
+  } else if (node.tag === "grid") {
+    if (node.props.defaultStroke) bank.addBorderFill(node.props.defaultStroke);
     for (const row of node.kids) {
       for (const cell of row.kids) {
-        const defStroke = node.props.defaultStroke ?? col.DEF_STROKE;
+        const defStroke = node.props.defaultStroke ?? bank.DEF_STROKE;
         const cp = cell.props;
         if (cp.top || cp.bot || cp.left || cp.right) {
-          col.addBorderFillPerSide(
-            cp.left ?? defStroke, cp.right ?? defStroke,
-            cp.top ?? defStroke, cp.bot ?? defStroke,
+          bank.addBorderFillPerSide(
+            cp.left ?? defStroke,
+            cp.right ?? defStroke,
+            cp.top ?? defStroke,
+            cp.bot ?? defStroke,
             cp.bg,
           );
         } else {
-          col.addBorderFill(defStroke, cp.bg);
+          bank.addBorderFill(defStroke, cp.bg);
         }
-        for (const para of cell.kids) collectNode(para, col);
+        for (const para of cell.kids) collectNode(para, bank);
       }
     }
   }
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   DocInfo record builders
-   ═══════════════════════════════════════════════════════════════ */
+// ─── DocInfo 레코드 빌더 ─────────────────────────────────────
 
-/**
- * HWPTAG_DOCUMENT_PROPERTIES (표 14 문서 속성) — 26 bytes
- * level 0 in DocInfo
- */
 function mkDocumentProperties(): Uint8Array {
   return new BufWriter()
-    .u16(1)   // nSection (구역 개수)
-    .u16(1)   // pageStart (페이지 시작 번호)
-    .u16(1)   // footnoteStart (각주 시작 번호)
-    .u16(1)   // endnoteStart (미주 시작 번호)
-    .u16(1)   // pictureStart (그림 시작 번호)
-    .u16(1)   // tableStart (표 시작 번호)
-    .u16(1)   // formulaStart (수식 시작 번호)
-    .u32(0)   // listId (캐럿 위치: 리스트 아이디)
-    .u32(0)   // paraId (캐럿 위치: 문단 아이디)
-    .u32(0)   // charUnitPos (캐럿 위치: 글자 단위 위치)
+    .u16(1)
+    .u16(1)
+    .u16(1)
+    .u16(1)
+    .u16(1)
+    .u16(1)
+    .u16(1) // 7× UINT16 카운터
+    .u32(0)
+    .u32(0)
+    .u32(0) // 캐럿 위치
     .build(); // 26 bytes
 }
 
 /**
- * HWPTAG_ID_MAPPINGS (표 15 아이디 매핑 헤더) — 72 bytes (INT32 array[18])
- * 표 16 아이디 매핑 개수 인덱스:
- *   [0]=binData, [1]=한글글꼴, [2]=영어글꼴, [3]=한자글꼴, [4]=일어글꼴,
- *   [5]=기타글꼴, [6]=기호글꼴, [7]=사용자글꼴,
- *   [8]=테두리/배경, [9]=글자모양, [10]=탭정의, [11]=문단번호,
- *   [12]=글머리표, [13]=문단모양, [14]=스타일, [15]=메모모양,
- *   [16]=변경추적, [17]=변경추적사용자
- * level 1 in DocInfo
+ * HWPTAG_ID_MAPPINGS (72 bytes = 18 × INT32)
+ * [0]=binData, [1-7]=7개 언어별 글꼴 수 (ANYTOHWP 방식으로 언어별 독립),
+ * [8]=테두리/배경, [9]=글자모양, [10]=탭, [11]=번호, [12]=글머리,
+ * [13]=문단모양, [14]=스타일, [15-17]=메모/변경추적
  */
-function mkIdMappings(col: StyleCollector, nBinData = 0): Uint8Array {
+function mkIdMappings(bank: HwpStyleBank, nBinData = 0): Uint8Array {
   const w = new BufWriter();
-  w.u32(nBinData);             // [0] nBinData
-  // [1-7]: 7 font language categories — all use same font list
-  for (let i = 0; i < 7; i++) w.u32(col.fonts.length);
-  w.u32(col.bfData.length);    // [8] nBorderFill
-  w.u32(col.csProps.length);   // [9] nCharShape
-  w.u32(0);                    // [10] nTabDef
-  w.u32(0);                    // [11] nNumbering
-  w.u32(0);                    // [12] nBullet
-  w.u32(col.psProps.length);   // [13] nParaShape
-  w.u32(0);                    // [14] nStyle
-  w.u32(0);                    // [15] nMemoShape (5.0.2.1+)
-  w.u32(0);                    // [16] nTrackChange (5.0.3.2+)
-  w.u32(0);                    // [17] nTrackChangeAuthor (5.0.3.2+)
+  w.u32(nBinData);
+  // [1-7]: 언어별 폰트 수 (ANYTOHWP: langFontFaces별 크기)
+  for (const lang of LANG_GROUPS) w.u32(bank.getFontCount(lang));
+  w.u32(bank.bfData.length); // [8]
+  w.u32(bank.csProps.length); // [9]
+  w.u32(0); // [10] tabDef
+  w.u32(0); // [11] numbering
+  w.u32(0); // [12] bullet
+  w.u32(bank.psProps.length); // [13]
+  w.u32(1); // [14] style (바탕글 1개)
+  w.u32(0); // [15]
+  w.u32(0); // [16]
+  w.u32(0); // [17]
   return w.build(); // 18 × 4 = 72 bytes
 }
 
-/**
- * HWPTAG_FACE_NAME (표 19 글꼴) — variable length
- * Complete structure: attr + name + altFontType + altLen + fontTypeInfo[10] + basicLen
- * level 1 in DocInfo
- */
+function mkStyle(
+  name: string,
+  engName: string,
+  paraPrId: number,
+  charPrId: number,
+): Uint8Array {
+  return new BufWriter()
+    .u16(name.length)
+    .utf16(name)
+    .u16(engName.length)
+    .utf16(engName)
+    .u16(paraPrId)
+    .u16(charPrId)
+    .u16(0)
+    .u16(1042)
+    .u16(0)
+    .build();
+}
+
 function mkFaceName(name: string): Uint8Array {
   return new BufWriter()
-    .u8(0)              // attr (0 = no alt/base font available)
-    .u16(name.length)   // len1: 글꼴 이름 길이
-    .utf16(name)        // 글꼴 이름 (UTF-16LE)
-    .u8(0)              // altFontType: 대체 글꼴 유형 (0)
-    .u16(0)             // altFontLen (0 = no alt font name)
-    .zeros(10)          // fontTypeInfo[10]: 글꼴 유형 정보 (표 22)
-    .u16(0)             // basicFontLen (0 = no basic font name)
+    .u8(0)
+    .u16(name.length)
+    .utf16(name)
+    .u8(0)
+    .u16(0)
+    .zeros(10)
+    .u16(0)
     .build();
 }
 
 function borderWidthIdx(pt: number): number {
   let best = 0;
   for (let i = 0; i < BORDER_W_PT.length; i++) {
-    if (Math.abs(BORDER_W_PT[i] - pt) < Math.abs(BORDER_W_PT[best] - pt)) best = i;
+    if (Math.abs(BORDER_W_PT[i] - pt) < Math.abs(BORDER_W_PT[best] - pt))
+      best = i;
   }
   return best;
 }
 
-/**
- * HWPTAG_BORDER_FILL (표 23 테두리/배경) — 32+n bytes
- * Field layout (GROUPED, not interleaved):
- *   offset 0:  UINT16 attr
- *   offset 2:  UINT8[4] border types  [left, right, top, bottom]
- *   offset 6:  UINT8[4] border widths [left, right, top, bottom]
- *   offset 10: COLORREF[4] border colors [left, right, top, bottom]
- *   offset 26: UINT8 diagonal type
- *   offset 27: UINT8 diagonal width
- *   offset 28: COLORREF diagonal color
- *   offset 32: fill info (채우기 정보, 표 28)
- * level 1 in DocInfo
- */
 function mkBorderFill(s: Stroke, bg?: string): Uint8Array {
   const w = new BufWriter();
-  const t  = BORDER_KIND_IDX[s.kind] ?? 0;
+  const t = BORDER_KIND_IDX[s.kind] ?? 0;
   const wi = borderWidthIdx(s.pt);
-  const col = s.color || '000000';
-
-  w.u16(0); // attr (UINT16)
-  // 4 border types: [left, right, top, bottom]
+  const col = s.color || "000000";
+  w.u16(0);
   for (let i = 0; i < 4; i++) w.u8(t);
-  // 4 border widths: [left, right, top, bottom]
   for (let i = 0; i < 4; i++) w.u8(wi);
-  // 4 border colors: [left, right, top, bottom]
   for (let i = 0; i < 4; i++) w.colorRef(col);
-  // diagonal: type, width, color
-  w.u8(0).u8(0).colorRef('000000');
-  // fill info (채우기 정보, 표 28): type + optional color data
+  w.u8(0).u8(0).colorRef("000000");
   if (bg) {
-    w.u32(1);              // type = 0x01 (단색 채우기)
-    w.colorRef(bg);        // 배경색
-    w.colorRef('FFFFFF');  // 무늬색 (no pattern = white)
-    w.u32(0);              // 무늬 종류 (0 = none)
+    w.u32(1).colorRef(bg).colorRef("FFFFFF").u32(0);
   } else {
-    w.u32(0);              // type = 0x00 (채우기 없음)
+    w.u32(0);
   }
-  return w.build(); // 36 bytes (no fill) or 48 bytes (solid fill)
+  return w.build();
 }
 
 function mkBorderFillPerSide(
-  left: Stroke, right: Stroke, top: Stroke, bottom: Stroke, bg?: string,
+  l: Stroke,
+  r: Stroke,
+  t: Stroke,
+  b: Stroke,
+  bg?: string,
 ): Uint8Array {
   const w = new BufWriter();
-  w.u16(0); // attr
-  // 4 border types [left, right, top, bottom]
-  w.u8(BORDER_KIND_IDX[left.kind]   ?? 0);
-  w.u8(BORDER_KIND_IDX[right.kind]  ?? 0);
-  w.u8(BORDER_KIND_IDX[top.kind]    ?? 0);
-  w.u8(BORDER_KIND_IDX[bottom.kind] ?? 0);
-  // 4 border widths
-  w.u8(borderWidthIdx(left.pt));
-  w.u8(borderWidthIdx(right.pt));
-  w.u8(borderWidthIdx(top.pt));
-  w.u8(borderWidthIdx(bottom.pt));
-  // 4 border colors
-  w.colorRef(left.color   || '000000');
-  w.colorRef(right.color  || '000000');
-  w.colorRef(top.color    || '000000');
-  w.colorRef(bottom.color || '000000');
-  // diagonal
-  w.u8(0).u8(0).colorRef('000000');
-  // fill info
+  w.u16(0);
+  w.u8(BORDER_KIND_IDX[l.kind] ?? 0)
+    .u8(BORDER_KIND_IDX[r.kind] ?? 0)
+    .u8(BORDER_KIND_IDX[t.kind] ?? 0)
+    .u8(BORDER_KIND_IDX[b.kind] ?? 0);
+  w.u8(borderWidthIdx(l.pt))
+    .u8(borderWidthIdx(r.pt))
+    .u8(borderWidthIdx(t.pt))
+    .u8(borderWidthIdx(b.pt));
+  w.colorRef(l.color || "000000")
+    .colorRef(r.color || "000000")
+    .colorRef(t.color || "000000")
+    .colorRef(b.color || "000000");
+  w.u8(0).u8(0).colorRef("000000");
   if (bg) {
-    w.u32(1).colorRef(bg).colorRef('FFFFFF').u32(0);
+    w.u32(1).colorRef(bg).colorRef("FFFFFF").u32(0);
   } else {
     w.u32(0);
   }
@@ -419,193 +548,124 @@ function mkBorderFillPerSide(
 }
 
 /**
- * HWPTAG_CHAR_SHAPE (표 33 글자 모양) — 72+ bytes
- * Field layout:
- *   offset  0: WORD[7]  faceId (언어별 글꼴 ID) — 14 bytes
- *   offset 14: UINT8[7] ratio  (장평 50~200%)   —  7 bytes
- *   offset 21: INT8[7]  spacing(자간 -50~50%)   —  7 bytes
- *   offset 28: UINT8[7] relSize(상대크기 10~250%)—  7 bytes
- *   offset 35: INT8[7]  offset (글자위치)       —  7 bytes
- *   offset 42: INT32    height (기준크기, HWP단위 = pt×100)
- *   offset 46: UINT32   attr   (표 35 글자 모양 속성)
- *   offset 50: INT8     shadowX
- *   offset 51: INT8     shadowY
- *   offset 52: COLORREF textColor (글자 색)
- *   offset 56: COLORREF underlineColor (밑줄 색)
- *   offset 60: COLORREF shadeColor (음영 색)
- *   offset 64: COLORREF shadowColor (그림자 색)
- *   offset 68: UINT16   borderFillId (5.0.2.1+)
- *   offset 70: COLORREF strikeColor (취소선 색, 5.0.3.0+)
- * level 1 in DocInfo
+ * HWPTAG_CHAR_SHAPE (74 bytes)
+ * ANYTOHWP 개선: faceId[7]에 언어별 ID를 개별 기록
  */
-function mkCharShape(p: TextProps, col: StyleCollector): Uint8Array {
-  const fontId = p.font ? col.font(p.font) : 0;
-  const height = Math.round((p.pt ?? 10) * 100); // HWP단위: pt×100
-
-  // 표 35 글자 모양 속성:
-  //  bit 0: 기울임(italic), bit 1: 진하게(bold)
-  //  bits 2-4: 밑줄 종류 (1=글자아래), bits 5-8: 밑줄 모양
-  //  bits 16-17: 위/아래 첨자 (0=없음, 1=위첨자, 2=아래첨자)
-  //  bits 18-20: 취소선 종류 (1=실선)
+function mkCharShape(fontIds: number[], p: TextProps): Uint8Array {
+  const height = Math.round((p.pt ?? 10) * 100);
   let attr = 0;
-  if (p.i)   attr |= (1 << 0);
-  if (p.b)   attr |= (1 << 1);
-  if (p.u)   attr |= (1 << 2);   // 밑줄 종류 = 1 (글자 아래)
-  if (p.s)   attr |= (1 << 18);  // 취소선 종류 = 1
-  if (p.sup) attr |= (1 << 16);  // 위 첨자
-  if (p.sub) attr |= (2 << 16);  // 아래 첨자
-
-  const textColor = p.color ?? '000000';
+  if (p.i) attr |= 1 << 0;
+  if (p.b) attr |= 1 << 1;
+  if (p.u) attr |= 1 << 2;
+  if (p.s) attr |= 1 << 18;
+  if (p.sup) attr |= 1 << 16;
+  if (p.sub) attr |= 2 << 16;
 
   const w = new BufWriter();
-  // faceId[7]: WORD[7] — 언어별 글꼴 ID (한글, 영어, 한자, 일어, 기타, 기호, 사용자)
-  for (let i = 0; i < 7; i++) w.u16(fontId);
-  // ratio[7]: UINT8[7] = 100 (100%)
-  for (let i = 0; i < 7; i++) w.u8(100);
-  // spacing[7]: INT8[7] = 0 (자간 0%)
-  for (let i = 0; i < 7; i++) w.u8(0);
-  // relSize[7]: UINT8[7] = 100 (100%)
-  for (let i = 0; i < 7; i++) w.u8(100);
-  // offset[7]: INT8[7] = 0 (글자 위치 0%)
-  for (let i = 0; i < 7; i++) w.u8(0);
-  // height: INT32
-  w.i32(height);
-  // attr: UINT32
-  w.u32(attr);
-  // shadowX, shadowY: INT8
-  w.u8(0).u8(0);
-  // textColor: COLORREF
-  w.colorRef(textColor);
-  // underlineColor: COLORREF (밑줄 색)
-  w.colorRef('000000');
-  // shadeColor: COLORREF (음영 색) — FFFFFF = no shade
-  w.colorRef('FFFFFF');
-  // shadowColor: COLORREF (그림자 색)
-  w.colorRef('000000');
-  // borderFillId: UINT16 (글자 테두리/배경 ID, 5.0.2.1+)
-  w.u16(0);
-  // strikeColor: COLORREF (취소선 색, 5.0.3.0+)
-  w.colorRef('000000');
-  return w.build(); // 42 + 4 + 4 + 1 + 1 + 4×4 + 2 + 4 = 74 bytes
+  // faceId[7]: 언어별 독립 ID (ANYTOHWP 핵심 개선)
+  for (const id of fontIds) w.u16(id);
+  for (let i = 0; i < 7; i++) w.u8(100); // ratio
+  for (let i = 0; i < 7; i++) w.u8(0); // spacing
+  for (let i = 0; i < 7; i++) w.u8(100); // relSize
+  for (let i = 0; i < 7; i++) w.u8(0); // offset
+  w.i32(height).u32(attr).u8(0).u8(0);
+  w.colorRef(p.color ?? "000000");
+  w.colorRef("000000"); // underlineColor
+  w.colorRef(p.bg ?? "FFFFFF"); // shadeColor
+  w.colorRef("000000"); // shadowColor
+  w.u16(0); // borderFillId
+  w.colorRef("000000"); // strikeColor
+  return w.build(); // 74 bytes
 }
 
-/**
- * HWPTAG_PARA_SHAPE (표 43 문단 모양) — 54 bytes
- * Field layout:
- *   offset  0: UINT32 attr1   (표 44 문단 모양 속성1, bits 2-4 = 정렬 방식)
- *   offset  4: INT32  leftMargin
- *   offset  8: INT32  rightMargin
- *   offset 12: INT32  indent (들여/내어 쓰기)
- *   offset 16: INT32  spaceBefore (문단 간격 위)
- *   offset 20: INT32  spaceAfter  (문단 간격 아래)
- *   offset 24: INT32  lineSpacing (줄 간격, 한글 2007 이하, 5.0.2.5 미만)
- *   offset 28: UINT16 tabDefId
- *   offset 30: UINT16 numberingId/bulletId
- *   offset 32: UINT16 borderFillId
- *   offset 34: INT16  borderLeft
- *   offset 36: INT16  borderRight
- *   offset 38: INT16  borderTop
- *   offset 40: INT16  borderBottom
- *   offset 42: UINT32 attr2 (5.0.1.7+)
- *   offset 46: UINT32 attr3 (5.0.2.5+, bits 0-4 = 줄 간격 종류)
- *   offset 50: UINT32 lineSpacing2 (5.0.2.5+, 실제 줄 간격)
- * level 1 in DocInfo
- */
 function mkParaShape(p: ParaProps): Uint8Array {
-  // 표 44 bits 2-4: 정렬 방식 (0=양쪽, 1=왼쪽, 2=오른쪽, 3=가운데)
-  const alignVal = ALIGN_CODE[p.align ?? 'left'] ?? 1;
-  const attr1 = (alignVal & 0x7) << 2; // alignment at bits 2-4
-
-  // 줄 간격: 비율(%) 표현, 160 = 160%
+  const alignVal = ALIGN_CODE[p.align ?? "left"] ?? 1;
+  const attr1 = (alignVal & 0x7) << 2;
   const lineSpacePct = p.lineHeight ? Math.round(p.lineHeight * 100) : 160;
-
   return new BufWriter()
-    .u32(attr1)                                    //  0: attr1
-    .i32(Metric.ptToHwp(p.indentPt ?? 0))          //  4: leftMargin (HWPUNIT)
-    .i32(0)                                        //  8: rightMargin
-    .i32(0)                                        // 12: indent
-    .i32(Metric.ptToHwp(p.spaceBefore ?? 0))       // 16: spaceBefore
-    .i32(Metric.ptToHwp(p.spaceAfter ?? 0))        // 20: spaceAfter
-    .i32(lineSpacePct)                             // 24: lineSpacing (old format)
-    .u16(0)                                        // 28: tabDefId
-    .u16(0)                                        // 30: numberingId
-    .u16(0)                                        // 32: borderFillId
-    .i16(0)                                        // 34: borderLeft
-    .i16(0)                                        // 36: borderRight
-    .i16(0)                                        // 38: borderTop
-    .i16(0)                                        // 40: borderBottom
-    .u32(0)                                        // 42: attr2 (5.0.1.7+)
-    .u32(0)                                        // 46: attr3 (줄 간격 종류 bits 0-4 = 0: 글자에 따라)
-    .u32(lineSpacePct)                             // 50: lineSpacing2 (5.0.2.5+)
+    .u32(attr1)
+    .i32(Metric.ptToHwp(p.indentPt ?? 0))
+    .i32(Metric.ptToHwp(p.indentRightPt ?? 0))
+    .i32(Metric.ptToHwp(p.firstLineIndentPt ?? 0))
+    .i32(Metric.ptToHwp(p.spaceBefore ?? 0))
+    .i32(Metric.ptToHwp(p.spaceAfter ?? 0))
+    .i32(lineSpacePct)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .i16(0)
+    .i16(0)
+    .i16(0)
+    .i16(0)
+    .u32(0)
+    .u32(4)
+    .u32(lineSpacePct)
     .build(); // 54 bytes
 }
 
-/**
- * HWPTAG_BIN_DATA (표 17 바이너리 데이터) — variable
- * Storage type 2 = embedded in BinData storage
- * level 1 in DocInfo
- */
 function mkBinData(id: number, ext: string): Uint8Array {
-  const w = new BufWriter();
-  w.u16(0x0002);        // attr: storage type = 2 (내장 파일)
-  w.u16(id);            // binDataId (1-based)
-  w.u16(ext.length);    // extLen (number of UTF-16LE chars)
-  w.utf16(ext);         // extension string (e.g. "jpg", "png")
-  return w.build();
+  return new BufWriter().u16(0x0002).u16(id).u16(ext.length).utf16(ext).build();
 }
 
 interface BinImage {
-  id: number;       // 1-based BIN ID
-  ext: string;      // file extension without dot
-  data: Uint8Array; // raw image bytes
+  id: number;
+  ext: string;
+  data: Uint8Array;
 }
 
-function buildDocInfoStream(col: StyleCollector, images: BinImage[] = []): Uint8Array {
+/**
+ * DocInfo 스트림 빌더
+ * ANYTOHWP 개선: 언어별 폰트 목록을 순서대로 독립 기록
+ */
+function buildDocInfoStream(
+  bank: HwpStyleBank,
+  images: BinImage[] = [],
+): Uint8Array {
   const chunks: Uint8Array[] = [];
 
-  // HWPTAG_DOCUMENT_PROPERTIES at level 0 (required first record)
   chunks.push(mkRec(TAG_DOCUMENT_PROPERTIES, 0, mkDocumentProperties()));
+  chunks.push(mkRec(TAG_ID_MAPPINGS, 1, mkIdMappings(bank, images.length)));
 
-  // HWPTAG_ID_MAPPINGS at level 1 (child of DOCUMENT_PROPERTIES)
-  chunks.push(mkRec(TAG_ID_MAPPINGS, 1, mkIdMappings(col, images.length)));
-
-  // HWPTAG_BIN_DATA at level 1: one record per image
   for (const img of images) {
     chunks.push(mkRec(TAG_BIN_DATA, 1, mkBinData(img.id, img.ext)));
   }
 
-  // HWPTAG_FACE_NAME at level 1: 7 language categories × nFonts records
-  // Order: all hangul fonts, then all english fonts, ..., then all user fonts
-  for (let cat = 0; cat < 7; cat++) {
-    for (const name of col.fonts) {
-      chunks.push(mkRec(TAG_FACE_NAME, 1, mkFaceName(name)));
+  // ANYTOHWP 방식: 언어 그룹별로 독립된 FACE_NAME 레코드 직렬화
+  for (const lang of LANG_GROUPS) {
+    for (const face of bank.getFontsForLang(lang)) {
+      chunks.push(mkRec(TAG_FACE_NAME, 1, mkFaceName(face)));
     }
   }
 
-  // HWPTAG_BORDER_FILL at level 1
-  for (const entry of col.bfData) {
-    chunks.push(mkRec(TAG_BORDER_FILL, 1,
-      entry.uniform
-        ? mkBorderFill(entry.s, entry.bg)
-        : mkBorderFillPerSide(entry.l, entry.r, entry.t, entry.b, entry.bg)));
+  for (const entry of bank.bfData) {
+    chunks.push(
+      mkRec(
+        TAG_BORDER_FILL,
+        1,
+        entry.uniform
+          ? mkBorderFill(entry.s, entry.bg)
+          : mkBorderFillPerSide(entry.l, entry.r, entry.t, entry.b, entry.bg),
+      ),
+    );
   }
 
-  // HWPTAG_CHAR_SHAPE at level 1
-  for (const p of col.csProps) {
-    chunks.push(mkRec(TAG_CHAR_SHAPE, 1, mkCharShape(p, col)));
+  // charShape — 언어별 fontId 배열 사용
+  for (let i = 0; i < bank.csProps.length; i++) {
+    chunks.push(
+      mkRec(TAG_CHAR_SHAPE, 1, mkCharShape(bank.csFontIds[i], bank.csProps[i])),
+    );
   }
 
-  // HWPTAG_PARA_SHAPE at level 1
-  for (const p of col.psProps) {
+  for (const p of bank.psProps) {
     chunks.push(mkRec(TAG_PARA_SHAPE, 1, mkParaShape(p)));
   }
 
+  chunks.push(mkRec(TAG_STYLE, 1, mkStyle("바탕글", "Normal", 0, 0)));
+
   return concatU8(chunks);
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   BodyText record builders
-   ═══════════════════════════════════════════════════════════════ */
+// ─── BodyText 레코드 빌더 ────────────────────────────────────
 
 function mkPageDef(dims: PageDims): Uint8Array {
   return new BufWriter()
@@ -615,43 +675,32 @@ function mkPageDef(dims: PageDims): Uint8Array {
     .u32(Metric.ptToHwp(dims.mr))
     .u32(Metric.ptToHwp(dims.mt))
     .u32(Metric.ptToHwp(dims.mb))
-    .zeros(12) // header/footer/gutter margins (3 × INT32)
-    .u32(dims.orient === 'landscape' ? 1 : 0) // attr @ offset 36
+    .u32(dims.headerPt ? Metric.ptToHwp(dims.headerPt) : 0)
+    .u32(dims.footerPt ? Metric.ptToHwp(dims.footerPt) : 0)
+    .u32(0) // gutter
+    .u32(dims.orient === "landscape" ? 1 : 0)
     .build(); // 40 bytes
 }
 
-/**
- * HWPTAG_PARA_HEADER (표 58 문단 헤더) — 24 bytes
- *   offset  0: UINT32 nchars       (문단 내 글자 수, 컨트롤 포함)
- *   offset  4: UINT32 ctrlMask     (컨트롤 마스크: 1<<ctrlCode)
- *   offset  8: UINT16 paraShapeId  (문단 모양 아이디)
- *   offset 10: UINT8  styleId      (문단 스타일 아이디, 0=기본)
- *   offset 11: UINT8  columnBreak  (단 나누기 종류)
- *   offset 12: UINT16 csCount      (글자 모양 정보 수)
- *   offset 14: UINT16 rangeTagCount(range tag 정보 수)
- *   offset 16: UINT16 lineAlignCount(각 줄 align 정보 수)
- *   offset 18: UINT32 instanceId   (문단 Instance ID, unique)
- *   offset 22: UINT16 trackChange  (변경추적 병합 여부, 5.0.3.2+)
- */
 function mkParaHeader(
   nchars: number,
   ctrlMask: number,
   psId: number,
   csCount: number,
-  lineAlignCount: number = 0,
-  instanceId: number = 0,
+  lineAlignCount = 0,
+  instanceId = 0,
 ): Uint8Array {
   return new BufWriter()
-    .u32(nchars)        //  0: nchars
-    .u32(ctrlMask)      //  4: ctrlMask
-    .u16(psId)          //  8: paraShapeId
-    .u8(0)              // 10: styleId (0 = default)
-    .u8(0)              // 11: columnBreak (0 = none)
-    .u16(csCount)       // 12: charShapeCount
-    .u16(0)             // 14: rangeTagCount
-    .u16(lineAlignCount)// 16: lineAlignCount
-    .u32(instanceId)    // 18: instanceId (unique)
-    .u16(0)             // 22: trackChange
+    .u32(nchars)
+    .u32(ctrlMask)
+    .u16(psId)
+    .u8(0)
+    .u8(0)
+    .u16(csCount)
+    .u16(0)
+    .u16(lineAlignCount)
+    .u32(instanceId)
+    .u16(0)
     .build(); // 24 bytes
 }
 
@@ -659,9 +708,10 @@ function mkParaText(text: string): Uint8Array {
   const w = new BufWriter();
   for (let i = 0; i < text.length; i++) {
     const c = text.charCodeAt(i);
-    w.u16(c < 32 ? 0 : c);
+    // 0x09(탭), 0x0A(줄바꿈), 0x03(필드시작), 0x04(필드종료) 등 허용
+    w.u16(c);
   }
-  w.u16(13); // paragraph terminator (0x000D = para break)
+  w.u16(13); // 문단 종결자
   return w.build();
 }
 
@@ -672,254 +722,447 @@ function mkParaCharShape(pairs: [pos: number, id: number][]): Uint8Array {
 }
 
 /**
- * PARA_TEXT for section definition paragraph.
- * 확장 컨트롤(size=8): ctrl_code(1) + ctrlId_lo(1) + ctrlId_hi(1) + ptr[4] + ctrl_code(1)
- * + para terminator = 9 WCHAR total → nchars = 9
+ * 5가지 LineSpacing(줄 간격) 타입에 따른 height 계산 로직
  */
-function mkSecdParaText(): Uint8Array {
-  const lo = CTRL_SECD & 0xFFFF;
-  const hi = (CTRL_SECD >>> 16) & 0xFFFF;
-  return new BufWriter()
-    .u16(0x0002).u16(lo).u16(hi).u16(0).u16(0).u16(0).u16(0).u16(0x0002) // 8 WCHAR ctrl ref
-    .u16(0x000D)  // para terminator
-    .build(); // 9 WCHAR = 18 bytes
+function calcLineHeight(
+  type: number,
+  value: number,
+  textHeight: number,
+): number {
+  switch (type) {
+    case 0:
+      return Math.floor((textHeight * value) / 100);
+    case 1:
+      return value;
+    case 2:
+      return Math.max(textHeight, value);
+    case 3:
+      return textHeight + value;
+    case 4:
+      return Math.floor(textHeight * value);
+    default:
+      return Math.floor((textHeight * value) / 100);
+  }
 }
 
 /**
- * PARA_TEXT for table container paragraph.
- * ctrl code for 그리기 개체/표 = 11 (0x000B)
- * 확장 컨트롤(size=8): 0x000B + tbl_lo + tbl_hi + 4×0 + 0x000B + terminator = 9 WCHAR
+ * LineSeg 36바이트 구조체 (HWP 5.0 공식 규격)
  */
+function mkLineSeg(
+  textStartPos: number,
+  vertPos: number,
+  vertSize: number,
+  textHeight: number,
+  baseline: number,
+  spacing: number,
+  horzPos: number,
+  horzSize: number,
+  flags: number,
+): Uint8Array {
+  return new BufWriter()
+    .u32(textStartPos)
+    .i32(vertPos)
+    .i32(vertSize)
+    .i32(textHeight)
+    .i32(baseline)
+    .i32(spacing)
+    .i32(horzPos)
+    .i32(horzSize)
+    .u32(flags)
+    .build(); // 36 bytes
+}
+
+function buildDefaultLineSeg(
+  availWidthHwp: number,
+  fontHwp: number,
+  nchars: number,
+  paraProps?: ParaProps,
+  vertPos = 0,
+): Uint8Array {
+  const ratio = paraProps?.lineHeight
+    ? Math.round(paraProps.lineHeight * 100)
+    : 160;
+  const vertSize = calcLineHeight(0, ratio, fontHwp);
+  const baseline = Math.round(fontHwp * 0.85);
+  const spacing = vertSize - fontHwp;
+  // flags: bit 0 (페이지 첫 줄), bit 1 (컬럼 첫 줄)
+  const flags = 3;
+
+  return mkLineSeg(
+    0,
+    vertPos,
+    vertSize,
+    fontHwp,
+    baseline,
+    spacing,
+    0,
+    availWidthHwp,
+    flags,
+  );
+}
+
+function mkSecdParaText(): Uint8Array {
+  const lo = CTRL_SECD & 0xffff;
+  const hi = (CTRL_SECD >>> 16) & 0xffff;
+  return new BufWriter()
+    .u16(0x0002)
+    .u16(lo)
+    .u16(hi)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .u16(0x0002)
+    .u16(0x000d)
+    .build();
+}
+
 function mkTableParaText(): Uint8Array {
-  const lo = CTRL_TABLE & 0xFFFF;
-  const hi = (CTRL_TABLE >>> 16) & 0xFFFF;
+  const lo = CTRL_TABLE & 0xffff;
+  const hi = (CTRL_TABLE >>> 16) & 0xffff;
   return new BufWriter()
-    .u16(0x000B).u16(lo).u16(hi).u16(0).u16(0).u16(0).u16(0).u16(0x000B) // 8 WCHAR ctrl ref
-    .u16(0x000D)  // para terminator
-    .build(); // 9 WCHAR = 18 bytes
+    .u16(0x000b)
+    .u16(lo)
+    .u16(hi)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .u16(0x000b)
+    .u16(0x000d)
+    .build();
 }
 
-/**
- * PARA_TEXT for picture container paragraph.
- * ctrl code for 그리기 개체/표/수식 등 = 11 (0x000B)
- * 확장 컨트롤(size=8): 0x000B + pic_lo + pic_hi + 4×0 + 0x000B + terminator = 9 WCHAR
- */
 function mkPicParaText(): Uint8Array {
-  const lo = CTRL_PIC & 0xFFFF;
-  const hi = (CTRL_PIC >>> 16) & 0xFFFF;
+  const lo = CTRL_PIC & 0xffff;
+  const hi = (CTRL_PIC >>> 16) & 0xffff;
   return new BufWriter()
-    .u16(0x000B).u16(lo).u16(hi).u16(0).u16(0).u16(0).u16(0).u16(0x000B)
-    .u16(0x000D)  // para terminator
-    .build(); // 9 WCHAR = 18 bytes
+    .u16(0x000b)
+    .u16(lo)
+    .u16(hi)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .u16(0)
+    .u16(0x000b)
+    .u16(0x000d)
+    .build();
 }
 
-/**
- * HWPTAG_SHAPE_COMPONENT_PICTURE (tag 85) — 97 bytes
- * Contains drawing common attrs + picture-specific attrs (표 107)
- * Critical field: BINDATA_ID at offset 87 (2 bytes)
- */
-function mkShapeComponentPicture(binDataId: number, wHwp: number, hHwp: number): Uint8Array {
+// ─── 이미지 관련 레코드 (ANYTOHWP 영감: 픽셀 치수 우선 사용)
+
+interface ImgLayout {
+  wrap?: string;
+  xPt?: number;
+  yPt?: number;
+  zOrder?: number;
+  distL?: number;
+  distR?: number;
+  distT?: number;
+  distB?: number;
+}
+
+function mkShapeComponentPicture(
+  binDataId: number,
+  wHwp: number,
+  hHwp: number,
+): Uint8Array {
   const w = new BufWriter();
-  // Drawing common attributes (19 bytes)
-  w.u32(CTRL_PIC);  // ctrlId: '$pic' (4)
-  w.zeros(15);      // border style, fill type (all default/none)
-  // Picture attributes (표 107, 78 bytes total = up to offset 97)
-  // Geometric region (HWPUNIT bounds)
-  w.u32(0);         // left (4)
-  w.u32(0);         // top (4)
-  w.u32(wHwp);      // right = width (4)
-  w.u32(hHwp);      // bottom = height (4)
-  // Drawing bounding box
-  w.u32(0);         // left (4)
-  w.u32(0);         // top (4)
-  w.u32(wHwp);      // right (4)
-  w.u32(hHwp);      // bottom (4)
-  // Rotation / effect (zeros = no rotation, no effect)
-  w.zeros(20);      // rotate angle, rotation center X/Y, effect flags (20)
-  // imageInfo (5 bytes at offset 87 from start)
-  // Currently at offset: 19 + 4+4+4+4 + 4+4+4+4 + 20 = 19+16+16+20 = 71... need 87
-  // Gap: 87 - 71 = 16 more bytes of zeros before binDataId
-  w.zeros(16);      // padding to reach offset 87
-  w.u16(binDataId); // BINDATA_ID (2) — which BIN stream to use
-  w.u8(0);          // image type (0 = stored in BinData storage)
-  w.u8(0);          // flags
-  w.u8(0);          // padding
-  w.zeros(5);       // remaining (to reach 97 bytes total)
-  // Total: 19+16+16+20+16+2+1+1+1+5 = 97
-  return w.build(); // 97 bytes
+  w.u32(CTRL_PIC).zeros(15);
+  w.u32(0).u32(0).u32(wHwp).u32(hHwp);
+  w.u32(0).u32(0).u32(wHwp).u32(hHwp);
+  w.zeros(36);
+  w.u16(binDataId).u8(0).u8(0).u8(0).zeros(5);
+  return w.build();
+}
+
+function mkObjectCtrl(
+  ctrlId: number,
+  wHwp: number,
+  hHwp: number,
+  instanceId: number,
+  layout?: ImgLayout,
+): Uint8Array {
+  let attr = 0x082a2210;
+  if (layout?.wrap === "inline") attr |= 1 << 3;
+  return new BufWriter()
+    .u32(ctrlId)
+    .u32(attr)
+    .i32(layout?.yPt ? Metric.ptToHwp(layout.yPt) : 0)
+    .i32(layout?.xPt ? Metric.ptToHwp(layout.xPt) : 0)
+    .u32(wHwp)
+    .u32(hHwp)
+    .i32(layout?.zOrder ?? 0)
+    .u16(layout?.distL ? Metric.ptToHwp(layout.distL) : 0)
+    .u16(layout?.distR ? Metric.ptToHwp(layout.distR) : 0)
+    .u16(layout?.distT ? Metric.ptToHwp(layout.distT) : 0)
+    .u16(layout?.distB ? Metric.ptToHwp(layout.distB) : 0)
+    .u32(instanceId)
+    .i32(0)
+    .u16(0)
+    .build(); // 46 bytes
+}
+
+function mkFieldBeginCtrl(instanceId: number): Uint8Array {
+  // 46-byte Object Control Header for Field
+  return new BufWriter()
+    .u32(CTRL_FIELD_BEGIN)
+    .u32(0x00000002) // 필드 플래그
+    .zeros(28) // xy/size 등 불필요 (필드는 비가시)
+    .u32(instanceId)
+    .zeros(6)
+    .build();
 }
 
-/** Encode an image node as a picture paragraph (level lv) */
+function mkFieldEndCtrl(beginId: number): Uint8Array {
+  return new BufWriter()
+    .u32(CTRL_FIELD_END)
+    .u32(0)
+    .zeros(28)
+    .u32(beginId)
+    .zeros(6)
+    .build();
+}
+
+/**
+ * 이미지 단락 인코딩
+ * ANYTOHWP 개선: PNG/JPEG 픽셀 치수에서 HWPUNIT 계산
+ */
 function encodePicPara(
-  imgNode: { b64: string; mime: string; w: number; h: number },
+  imgNode: ImgNode,
   binDataId: number,
-  col: StyleCollector,
+  bank: HwpStyleBank,
   lv: number,
   idGen: () => number,
+  availWidthHwp: number,
 ): Uint8Array[] {
-  // imgNode.w / imgNode.h are in pt (set by all decoders)
-  const wHwp = Metric.ptToHwp(Math.max(imgNode.w, 10));
-  const hHwp = Metric.ptToHwp(Math.max(imgNode.h, 10));
+  // ANYTOHWP 방식: 픽셀 치수 추출 시도 → 실패 시 pt 기반으로 폴백
+  const rawData = TextKit.base64Decode(imgNode.b64);
+  const pixDims = readPixelDims(rawData, imgNode.mime);
+
+  let wHwp: number, hHwp: number;
+  if (pixDims && pixDims.w > 0 && pixDims.h > 0) {
+    wHwp = Metric.ptToHwp((pixDims.w * 72) / 96); // px → pt(96dpi) → hwpunit
+    hHwp = Metric.ptToHwp((pixDims.h * 72) / 96);
+  } else {
+    wHwp = Metric.ptToHwp(imgNode.w);
+    hHwp = Metric.ptToHwp(imgNode.h);
+  }
 
-  const TABLE_CTRL_MASK = 1 << 11;
+  // 가용 너비 초과 방지
+  if (wHwp > availWidthHwp) {
+    hHwp = Math.round((hHwp * availWidthHwp) / wHwp);
+    wHwp = availWidthHwp;
+  }
+
+  const CTRL_MASK = 1 << 11;
   const instanceId = idGen();
-  const psId = col.addParaShape({});
+  const psId = bank.addParaShape({});
 
   return [
-    mkRec(TAG_PARA_HEADER,     lv,     mkParaHeader(9, TABLE_CTRL_MASK, psId, 1, 0, instanceId)),
-    mkRec(TAG_PARA_TEXT,       lv + 1, mkPicParaText()),
+    mkRec(
+      TAG_PARA_HEADER,
+      lv,
+      mkParaHeader(9, CTRL_MASK, psId, 1, 1, instanceId),
+    ),
+    mkRec(TAG_PARA_TEXT, lv + 1, mkPicParaText()),
     mkRec(TAG_PARA_CHAR_SHAPE, lv + 1, mkParaCharShape([[0, 0]])),
-    // $pic CTRL_HEADER (GHDR) at level lv+1
-    mkRec(TAG_CTRL_HEADER, lv + 1, mkPicCtrl(wHwp, hHwp, idGen())),
-    // SHAPE_COMPONENT_PICTURE at level lv+2
-    mkRec(TAG_SHAPE_COMPONENT_PICTURE, lv + 2, mkShapeComponentPicture(binDataId, wHwp, hHwp)),
+    mkRec(
+      TAG_PARA_LINE_SEG,
+      lv + 1,
+      buildDefaultLineSeg(availWidthHwp, hHwp, 9),
+    ),
+    mkRec(
+      TAG_CTRL_HEADER,
+      lv + 1,
+      mkObjectCtrl(CTRL_PIC, wHwp, hHwp, idGen(), imgNode.layout),
+    ),
+    mkRec(
+      TAG_SHAPE_COMPONENT_PICTURE,
+      lv + 2,
+      mkShapeComponentPicture(binDataId, wHwp, hHwp),
+    ),
   ];
 }
 
-function encodePara(para: ParaNode, col: StyleCollector, lv: number, instanceId: number): Uint8Array[] {
-  let text = '';
+// ─── 문단 인코딩 ─────────────────────────────────────────────
+
+function encodePara(
+  para: ParaNode,
+  bank: HwpStyleBank,
+  lv: number,
+  instanceId: number,
+  availWidthHwp: number,
+  mask = 0,
+  vertPos = 0,
+): Uint8Array[] {
+  let text = "";
   const csPairs: [number, number][] = [];
   let pos = 0;
+  let fontHwp = 1000;
+  const ctrlRecords: Uint8Array[] = [];
 
   for (const kid of para.kids) {
-    if (kid.tag === 'span') {
-      const span = kid as SpanNode;
-      const csId = col.addCharShape(span.props);
-      if (csPairs.length === 0 || csPairs[csPairs.length - 1][1] !== csId) {
-        csPairs.push([pos, csId]);
-      }
-      for (const t of span.kids) {
-        if (t.tag === 'txt') { text += t.content; pos += t.content.length; }
-      }
+    if (
+      kid.tag === "span" &&
+      (kid as SpanNode).props.pt &&
+      ((kid as SpanNode).props.pt as number) > 0
+    ) {
+      fontHwp = Metric.ptToHwp((kid as SpanNode).props.pt as number);
+      break;
     }
   }
 
-  if (csPairs.length === 0) csPairs.push([0, 0]);
+  // 내부적으로 사용되는 ID 생성기 (단락 내에서 로컬하게 사용)
+  let localIdCounter = 10000;
+  const localIdGen = () => localIdCounter++;
+
+  function processKids(kids: any[]): void {
+    for (const kid of kids) {
+      if (kid.tag === "span") {
+        const span = kid as SpanNode;
+        const csId = bank.addCharShape(span.props);
+        if (!csPairs.length || csPairs[csPairs.length - 1][1] !== csId) {
+          csPairs.push([pos, csId]);
+        }
+        for (const t of span.kids) {
+          if (t.tag === "txt") {
+            text += t.content;
+            pos += t.content.length;
+          }
+        }
+      } else if (kid.tag === "link") {
+        const link = kid as LinkNode;
+        mask |= 1 << 11; // 하이퍼링크 마스크
+
+        const fieldBeginId = localIdGen();
+        // 1. 시작 제어 문자 (0x03)
+        text += String.fromCharCode(3);
+        pos += 1;
+        ctrlRecords.push(
+          mkRec(TAG_CTRL_HEADER, lv + 1, mkFieldBeginCtrl(fieldBeginId)),
+        );
+
+        // 2. 내용 처리
+        processKids(link.kids);
+
+        // 3. 종료 제어 문자 (0x04)
+        text += String.fromCharCode(4);
+        pos += 1;
+        ctrlRecords.push(
+          mkRec(TAG_CTRL_HEADER, lv + 1, mkFieldEndCtrl(fieldBeginId)),
+        );
+      }
+    }
+  }
+  processKids(para.kids);
+  if (!csPairs.length) csPairs.push([0, 0]);
 
-  const psId  = col.addParaShape(para.props);
-  const nchars = text.length + 1; // text + para terminator
+  const psId = bank.addParaShape(para.props);
+  const nchars = text.length + 1;
 
   return [
-    mkRec(TAG_PARA_HEADER,     lv,     mkParaHeader(nchars, 0, psId, csPairs.length, 0, instanceId)),
-    mkRec(TAG_PARA_TEXT,       lv + 1, mkParaText(text)),
+    mkRec(
+      TAG_PARA_HEADER,
+      lv,
+      mkParaHeader(nchars, mask, psId, csPairs.length, 1, instanceId),
+    ),
+    mkRec(TAG_PARA_TEXT, lv + 1, mkParaText(text)),
     mkRec(TAG_PARA_CHAR_SHAPE, lv + 1, mkParaCharShape(csPairs)),
+    mkRec(
+      TAG_PARA_LINE_SEG,
+      lv + 1,
+      buildDefaultLineSeg(availWidthHwp, fontHwp, nchars, para.props, vertPos),
+    ),
+    ...ctrlRecords,
   ];
 }
 
-/* ── Table encoding ─────────────────────────────────────────── */
-
-/**
- * CTRL_HEADER for table ctrl — 46-byte GHDR (개체 공통 속성, 표 68)
- * Layout: ctrlId(4)+attr(4)+vOff(4)+hOff(4)+w(4)+h(4)+z(4)+margins(8)+instanceId(4)+pageBreak(4)+captionLen(2)
- */
-function mkTableCtrl(wHwp: number, hHwp: number, instanceId: number): Uint8Array {
-  return new BufWriter()
-    .u32(CTRL_TABLE)   // ctrlId: 'tbl ' (4)
-    .u32(0x082a2211)   // attr — value from real file (4)
-    .i32(0)            // vOff (4)
-    .i32(0)            // hOff (4)
-    .u32(wHwp)         // width in HWPUNIT (4)
-    .u32(hHwp)         // height in HWPUNIT (4)
-    .i32(7)            // z-order — value from real file (4)
-    .u16(140).u16(140).u16(140).u16(140) // outer margins left/right/top/bottom (8)
-    .u32(instanceId)   // instanceId (4)
-    .i32(0)            // pageBreak (4)
-    .u16(0)            // captionLen (2)
-    .build();          // 46 bytes
-}
+// ─── 표 인코딩 ───────────────────────────────────────────────
 
-/**
- * CTRL_HEADER for picture ctrl — 46-byte GHDR ($pic)
- */
-function mkPicCtrl(wHwp: number, hHwp: number, instanceId: number): Uint8Array {
+function mkTableCtrl(
+  wHwp: number,
+  hHwp: number,
+  instanceId: number,
+  align: Align = "left",
+): Uint8Array {
+  // 표 정렬 속성 플래그 (HWP 표 제어 문자)
+  // offset 20-21: 속성 플래그 (align: left=0, center=1, right=2, justify=3)
+  const alignFlags = { left: 0, center: 1, right: 2, justify: 3, distribute: 0, distribute_space: 0 }[align] ?? 0;
   return new BufWriter()
-    .u32(CTRL_PIC)     // ctrlId: '$pic' (4)
-    .u32(0x082a2211)   // attr — same flags as table (4)
-    .i32(0)            // vOff (4)
-    .i32(0)            // hOff (4)
-    .u32(wHwp)         // width in HWPUNIT (4)
-    .u32(hHwp)         // height in HWPUNIT (4)
-    .i32(0)            // z-order (4)
-    .u16(0).u16(0).u16(0).u16(0) // outer margins (8)
-    .u32(instanceId)   // instanceId (4)
-    .i32(0)            // pageBreak (4)
-    .u16(0)            // captionLen (2)
-    .build();          // 46 bytes
+    .u32(CTRL_TABLE)
+    .u32(0x082a2211)
+    .i32(0)
+    .i32(0)
+    .u32(wHwp)
+    .u32(hHwp)
+    .i32(7)
+    .u16(140)
+    .u16(140)
+    .u16(140)
+    .u16(140)
+    .u32(instanceId)
+    .i32(alignFlags)
+    .u16(0)
+    .build(); // 46 bytes
 }
 
-/**
- * HWPTAG_TABLE (표 75) — variable
- * Layout (verified from real HWP file):
- *   UINT32 attr (0x04000006)
- *   UINT16 rowCnt
- *   UINT16 colCnt
- *   UINT16 cellSpacing
- *   UINT16[4] innerMargins: left=510, right=510, top=141, bottom=141 (HWPUNIT16)
- *   UINT16[rowCnt] rowSizes (nominal, actual height from cell LIST_HEADER)
- *   UINT16 borderFillId
- *   UINT16 validZoneCount
- */
-function mkTableRecord(rowCnt: number, colCnt: number, rowHwp: number[], bfId: number): Uint8Array {
+function mkTableRecord(
+  rowCnt: number,
+  colCnt: number,
+  rowHwp: number[],
+  bfId: number,
+): Uint8Array {
   const w = new BufWriter();
-  w.u32(0x04000006); // attr — from real file
-  w.u16(rowCnt);
-  w.u16(colCnt);
-  w.u16(0);          // cellSpacing
-  w.u16(510);        // inner margin left  (0x01fe HWPUNIT16) — from real file
-  w.u16(510);        // inner margin right
-  w.u16(141);        // inner margin top   (0x008d HWPUNIT16) — from real file
-  w.u16(141);        // inner margin bottom
-  for (const h of rowHwp) w.u16(Math.max(1, h & 0xFFFF)); // row sizes as UINT16
-  w.u16(bfId);       // borderFillId
-  w.u16(0);          // validZoneCount
+  w.u32(0x04000006).u16(rowCnt).u16(colCnt).u16(0);
+  w.u16(510).u16(510).u16(141).u16(141);
+  for (const h of rowHwp) w.u16(Math.max(1, h & 0xffff));
+  w.u16(bfId).u16(0);
   return w.build();
 }
 
 function mkCellListHeader(
   paraCount: number,
-  row: number, col: number,
-  rs: number,  cs: number,
-  wHwp: number, hHwp: number,
+  row: number,
+  col: number,
+  rs: number,
+  cs: number,
+  wHwp: number,
+  hHwp: number,
   bfId: number,
+  padL = 141,
+  padR = 141,
+  padT = 141,
+  padB = 141,
 ): Uint8Array {
-  // 표 65 문단 리스트 헤더 (cell variant) — 47 bytes from real file:
-  // offset 0:  UINT16 paraCount
-  // offset 2:  UINT32 attr
-  // offset 6:  UINT16 (extended attr)
-  // offset 8:  UINT16 colAddr
-  // offset 10: UINT16 rowAddr
-  // offset 12: UINT16 rowSpan
-  // offset 14: UINT16 colSpan
-  // offset 16: UINT32 width
-  // offset 20: UINT32 height
-  // offset 24: UINT16 margin left  (510 = 0x01fe HWPUNIT16)
-  // offset 26: UINT16 margin right
-  // offset 28: UINT16 margin top   (141 = 0x008d HWPUNIT16)
-  // offset 30: UINT16 margin bottom
-  // offset 32: UINT16 borderFillId
-  // offset 34-46: extended (13 bytes, zeros)
   return new BufWriter()
-    .u16(paraCount) //  0: paraCount
-    .u32(0)         //  2: attr
-    .u16(0)         //  6: extended attr
-    .u16(col)       //  8: colAddr
-    .u16(row)       // 10: rowAddr
-    .u16(rs)        // 12: rowSpan
-    .u16(cs)        // 14: colSpan
-    .u32(wHwp)      // 16: width
-    .u32(hHwp)      // 20: height
-    .u16(510)       // 24: margin left  (from real file)
-    .u16(510)       // 26: margin right
-    .u16(141)       // 28: margin top
-    .u16(141)       // 30: margin bottom
-    .u16(bfId)      // 32: borderFillId
-    .zeros(13)      // 34-46: extended fields
-    .build();       // 47 bytes
+    .u16(paraCount)
+    .u32(0)
+    .u16(0)
+    .u16(col)
+    .u16(row)
+    .u16(rs)
+    .u16(cs)
+    .u32(wHwp)
+    .u32(hHwp)
+    .u16(padL)
+    .u16(padR)
+    .u16(padT)
+    .u16(padB)
+    .u16(bfId)
+    .zeros(13)
+    .build(); // 47 bytes
 }
 
 const DEFAULT_ROW_HEIGHT_PT = 14;
 
-function encodeGrid(grid: GridNode, col: StyleCollector, lv: number, idGen: () => number): Uint8Array[] {
+function encodeGrid(
+  grid: GridNode,
+  bank: HwpStyleBank,
+  lv: number,
+  idGen: () => number,
+  availWidthHwp: number,
+): Uint8Array[] {
   const records: Uint8Array[] = [];
   const rowCnt = grid.kids.length;
   const colCnt = Math.max(1, grid.kids[0]?.kids.length ?? 1);
@@ -927,154 +1170,368 @@ function encodeGrid(grid: GridNode, col: StyleCollector, lv: number, idGen: () =
   const cwPt = (grid.props as any).colWidths ?? [];
   const totalPt = cwPt.reduce((s: number, w: number) => s + w, 0) || 453;
   const defColPt = totalPt / colCnt;
-
-  const defStroke = grid.props.defaultStroke ?? col.DEF_STROKE;
-  const defBfId   = col.addBorderFill(defStroke);
+  const defStroke = grid.props.defaultStroke ?? bank.DEF_STROKE;
+  const defBfId = bank.addBorderFill(defStroke);
 
   const rowHwp = grid.kids.map((row: any) =>
     row.heightPt != null && row.heightPt > 0
       ? Metric.ptToHwp(row.heightPt)
-      : Metric.ptToHwp(DEFAULT_ROW_HEIGHT_PT));
-
-  // Compute total table dimensions for GHDR
-  const totalWPt = cwPt.length > 0 ? cwPt.reduce((s: number, w: number) => s + w, 0) : totalPt;
-  const totalHPt = grid.kids.reduce((s: number, row: any) =>
-    s + (row.heightPt != null && row.heightPt > 0 ? row.heightPt : DEFAULT_ROW_HEIGHT_PT), 0);
-  const tblWHwp = Metric.ptToHwp(totalWPt);
-  const tblHHwp = Metric.ptToHwp(totalHPt);
+      : Metric.ptToHwp(DEFAULT_ROW_HEIGHT_PT),
+  );
+
+  const tblWPt =
+    cwPt.length > 0 ? cwPt.reduce((s: number, w: number) => s + w, 0) : totalPt;
+  const tblHPt = grid.kids.reduce(
+    (s: number, row: any) =>
+      s +
+      (row.heightPt != null && row.heightPt > 0
+        ? row.heightPt
+        : DEFAULT_ROW_HEIGHT_PT),
+    0,
+  );
   const tblInstanceId = idGen();
-
-  // Table ctrl header at level lv (CTRL_HEADER for table — full 46-byte GHDR)
-  records.push(mkRec(TAG_CTRL_HEADER, lv, mkTableCtrl(tblWHwp, tblHHwp, tblInstanceId)));
-
-  // HWPTAG_TABLE at level lv+1 (child of ctrl header)
-  records.push(mkRec(TAG_TABLE, lv + 1, mkTableRecord(rowCnt, colCnt, rowHwp, defBfId)));
+  const tblAlign = grid.props.align ?? "left";
+
+  records.push(
+    mkRec(
+      TAG_CTRL_HEADER,
+      lv,
+      mkTableCtrl(
+        Metric.ptToHwp(tblWPt),
+        Metric.ptToHwp(tblHPt),
+        tblInstanceId,
+        tblAlign,
+      ),
+    ),
+  );
+  records.push(
+    mkRec(TAG_TABLE, lv + 1, mkTableRecord(rowCnt, colCnt, rowHwp, defBfId)),
+  );
 
   for (let r = 0; r < grid.kids.length; r++) {
     for (let c = 0; c < grid.kids[r].kids.length; c++) {
-      const cell   = grid.kids[r].kids[c];
-      const wHwp   = Metric.ptToHwp(cwPt[c] ?? defColPt);
-      const hHwp   = rowHwp[r];
-      const cp     = cell.props;
+      const cell = grid.kids[r].kids[c];
+      const wHwp = Metric.ptToHwp(cwPt[c] ?? defColPt);
+      const hHwp = rowHwp[r];
+      const cp = cell.props;
       const hasPerSide = cp.top || cp.bot || cp.left || cp.right;
       const bfId = hasPerSide
-        ? col.addBorderFillPerSide(
-            cp.left ?? defStroke, cp.right ?? defStroke,
-            cp.top ?? defStroke, cp.bot ?? defStroke,
+        ? bank.addBorderFillPerSide(
+            cp.left ?? defStroke,
+            cp.right ?? defStroke,
+            cp.top ?? defStroke,
+            cp.bot ?? defStroke,
             cp.bg,
           )
-        : col.addBorderFill(defStroke, cp.bg);
-
-      const paras = cell.kids.length > 0
-        ? cell.kids
-        : [{ tag: 'para' as const, props: {}, kids: [] }];
-
-      // LIST_HEADER at level lv+1 (sibling of TABLE)
-      records.push(mkRec(TAG_LIST_HEADER, lv + 1,
-        mkCellListHeader(paras.length, r, c, cell.rs, cell.cs, wHwp, hHwp, bfId)));
-
-      // Cell paragraphs at level lv+2 (children of LIST_HEADER)
+        : bank.addBorderFill(defStroke, cp.bg);
+
+      const paras =
+        cell.kids.length > 0
+          ? cell.kids
+          : [{ tag: "para" as const, props: {}, kids: [] }];
+
+      const padL = cp.padL !== undefined ? Metric.ptToHwp(cp.padL) : 510;
+      const padR = cp.padR !== undefined ? Metric.ptToHwp(cp.padR) : 510;
+      const padT = cp.padT !== undefined ? Metric.ptToHwp(cp.padT) : 141;
+      const padB = cp.padB !== undefined ? Metric.ptToHwp(cp.padB) : 141;
+
+      records.push(
+        mkRec(
+          TAG_LIST_HEADER,
+          lv + 1,
+          mkCellListHeader(
+            paras.length,
+            r,
+            c,
+            cell.rs,
+            cell.cs,
+            wHwp,
+            hHwp,
+            bfId,
+            padL,
+            padR,
+            padT,
+            padB,
+          ),
+        ),
+      );
+
+      const cellWidthHwp = Metric.ptToHwp(cwPt[c] ?? defColPt);
       for (const para of paras) {
-        records.push(...encodePara(para as ParaNode, col, lv + 2, idGen()));
+        records.push(
+          ...encodePara(para as ParaNode, bank, lv + 1, idGen(), cellWidthHwp),
+        );
       }
     }
   }
-
   return records;
 }
 
-/**
- * CTRL_HEADER for section definition — 47 bytes (matched from real HWP files)
- * Layout: ctrlId(4) + attr(4) + colGap(4) + u16+u16(4) + zeros(31)
- */
 function mkSectionCtrl(): Uint8Array {
   return new BufWriter()
-    .u32(CTRL_SECD)  // ctrlId: 'secd' (4)
-    .u32(0)           // attr (4)
-    .u32(1134)        // column gap in HWPUNIT — value from real file (4)
-    .u16(0x4000)      // (2) — from real file
-    .u16(0x001f)      // (2) — from real file
-    .zeros(31)        // padding to reach 47 bytes total
-    .build();         // 4+4+4+2+2+31 = 47 bytes
+    .u32(CTRL_SECD)
+    .u32(0)
+    .u32(1134)
+    .u16(0x4000)
+    .u16(0x001f)
+    .zeros(31)
+    .build(); // 47 bytes
 }
 
-/**
- * Section definition paragraph structure:
- * Level 0: PARA_HEADER (nchars=9, ctrlMask=1<<2, lineAlignCount=1)
- * Level 1:   PARA_TEXT (secd ctrl reference + terminator, 9 WCHAR)
- * Level 1:   PARA_CHAR_SHAPE
- * Level 1:   PARA_LINE_SEG (36 bytes for 1 line)
- * Level 1:   CTRL_HEADER ('secd', 4 bytes)
- * Level 2:     PAGE_DEF (40 bytes)
- * Level 2:     FOOTNOTE_SHAPE (28 bytes, for footnotes)
- * Level 2:     FOOTNOTE_SHAPE (28 bytes, for endnotes)
- */
-function buildSectionParagraph(dims: PageDims, instanceId: number): Uint8Array[] {
-  const SECD_CTRL_MASK = 1 << 2; // code 2 = 구역 정의/단 정의
-  const nchars = 9; // 8 ctrl wchars + 1 terminator
-
+function buildSectionParagraph(
+  dims: PageDims,
+  instanceId: number,
+): Uint8Array[] {
+  const SECD_CTRL_MASK = 1 << 2;
+  const nchars = 9;
+  const availWidthHwp = Math.max(
+    1000,
+    Metric.ptToHwp(dims.wPt) -
+      Metric.ptToHwp(dims.ml) -
+      Metric.ptToHwp(dims.mr),
+  );
   return [
-    mkRec(TAG_PARA_HEADER,     0, mkParaHeader(nchars, SECD_CTRL_MASK, 0, 1, 1, instanceId)),
-    mkRec(TAG_PARA_TEXT,       1, mkSecdParaText()),
+    mkRec(
+      TAG_PARA_HEADER,
+      0,
+      mkParaHeader(nchars, SECD_CTRL_MASK, 0, 1, 1, instanceId),
+    ),
+    mkRec(TAG_PARA_TEXT, 1, mkSecdParaText()),
     mkRec(TAG_PARA_CHAR_SHAPE, 1, mkParaCharShape([[0, 0]])),
-    mkRec(TAG_PARA_LINE_SEG,   1, new Uint8Array(36)), // 1 line × 36 bytes = 36 bytes
-    mkRec(TAG_CTRL_HEADER,     1, mkSectionCtrl()),    // 'secd' at level 1
-    mkRec(TAG_PAGE_DEF,        2, mkPageDef(dims)),    // page def at level 2
-    mkRec(TAG_FOOTNOTE_SHAPE,  2, new Uint8Array(28)), // footnote shape (defaults)
-    mkRec(TAG_FOOTNOTE_SHAPE,  2, new Uint8Array(28)), // endnote shape (defaults)
+    mkRec(
+      TAG_PARA_LINE_SEG,
+      1,
+      buildDefaultLineSeg(availWidthHwp, 1000, nchars),
+    ),
+    mkRec(TAG_CTRL_HEADER, 1, mkSectionCtrl()),
+    mkRec(TAG_PAGE_DEF, 2, mkPageDef(dims)),
+    mkRec(TAG_FOOTNOTE_SHAPE, 2, new Uint8Array(28)),
+    mkRec(TAG_FOOTNOTE_SHAPE, 2, new Uint8Array(28)),
   ];
 }
 
+// ─── BodyText 스트림 빌더 ─────────────────────────────────────
+
+function flatImgNodes(kids: any[]): any[] {
+  const result: any[] = [];
+  for (const kid of kids) {
+    if (kid.tag === "img") result.push(kid);
+    else if (kid.tag === "link" && Array.isArray(kid.kids))
+      result.push(...flatImgNodes(kid.kids));
+  }
+  return result;
+}
+
+function b64Matches(binImg: BinImage, b64: string): boolean {
+  const a = TextKit.base64Encode(binImg.data).replace(/\s/g, "");
+  const b = b64.replace(/\s/g, "");
+  return a === b;
+}
+
 function buildBodyTextStream(
   doc: DocRoot,
-  col: StyleCollector,
+  bank: HwpStyleBank,
   images: BinImage[],
 ): Uint8Array {
   const chunks: Uint8Array[] = [];
   const dims = doc.kids[0]?.dims ?? A4;
   let instanceIdCounter = 1;
   const idGen = () => instanceIdCounter++;
+  const availWidthHwp = Math.max(
+    1000,
+    Metric.ptToHwp(dims.wPt) -
+      Metric.ptToHwp(dims.ml) -
+      Metric.ptToHwp(dims.mr),
+  );
 
-  // Section definition paragraph
   for (const r of buildSectionParagraph(dims, idGen())) chunks.push(r);
 
-  const TABLE_CTRL_MASK = 1 << 11; // code 11 = 그리기 개체/표 (확장 컨트롤)
+  const TABLE_CTRL_MASK = 1 << 11;
+  let vertPos = 0; // 단락 간격 추적
 
   for (const sheet of doc.kids) {
     for (const node of sheet.kids) {
-      if (node.tag === 'para') {
+      if (node.tag === "para") {
         const para = node as ParaNode;
-        // Check if the paragraph contains images
-        const hasImg = para.kids.some((k: any) => k.tag === 'img');
-        if (hasImg) {
-          // Emit one image paragraph per img node found
-          for (const kid of para.kids) {
-            if ((kid as any).tag === 'img') {
-              const img = kid as any;
-              // Find matching BinImage
-              const binImg = images.find(b => b64Matches(b, img.b64));
-              if (binImg) {
-                for (const r of encodePicPara(img, binImg.id, col, 0, idGen)) chunks.push(r);
+
+        const hasPageBreak = para.kids.some(
+          (k) => k.tag === "span" && k.kids.some((c) => c.tag === "pb"),
+        );
+        let paraMask = hasPageBreak ? 1 << 2 : 0;
+
+        // 코드 블록 감지 → 1×1 표로 감싸기
+        const hasCourier = (kids: any[]): boolean =>
+          kids.some(
+            (k) =>
+              (k.tag === "span" &&
+                k.props.font?.toLowerCase().includes("courier")) ||
+              (k.tag === "link" && hasCourier(k.kids)),
+          );
+        const isCode =
+          para.props.styleId?.toLowerCase().includes("code") ||
+          hasCourier(para.kids);
+
+        if (isCode) {
+          const gridNode: GridNode = {
+            tag: "grid",
+            props: {
+              colWidths: [Metric.hwpToPt(availWidthHwp)],
+              defaultStroke: { kind: "solid", pt: 0.5, color: "aaaaaa" },
+            },
+            kids: [
+              {
+                tag: "row",
+                kids: [
+                  {
+                    tag: "cell",
+                    rs: 1,
+                    cs: 1,
+                    props: { bg: "f4f4f4" },
+                    kids: [para],
+                  },
+                ],
+              },
+            ],
+          };
+          chunks.push(
+            mkRec(
+              TAG_PARA_HEADER,
+              0,
+              mkParaHeader(9, TABLE_CTRL_MASK | paraMask, 0, 1, 1, idGen()),
+            ),
+          );
+          chunks.push(mkRec(TAG_PARA_TEXT, 1, mkTableParaText()));
+          chunks.push(mkRec(TAG_PARA_CHAR_SHAPE, 1, mkParaCharShape([[0, 0]])));
+          chunks.push(
+            mkRec(
+              TAG_PARA_LINE_SEG,
+              1,
+              buildDefaultLineSeg(availWidthHwp, 1000, 9, undefined, vertPos),
+            ),
+          );
+          vertPos += Metric.ptToHwp(20); // 코드 블록 후 간격
+          for (const r of encodeGrid(gridNode, bank, 1, idGen, availWidthHwp))
+            chunks.push(r);
+          continue;
+        }
+
+        const imgNodes = flatImgNodes(para.kids);
+        if (imgNodes.length > 0) {
+          for (const img of imgNodes) {
+            const binImg = images.find((b) => b64Matches(b, img.b64));
+            if (binImg) {
+              for (const r of encodePicPara(
+                img,
+                binImg.id,
+                bank,
+                0,
+                idGen,
+                availWidthHwp,
+              )) {
+                // 첫 레코드가 PARA_HEADER인 경우 페이지 브레이크 마스크 적용
+                chunks.push(r);
               }
+              vertPos += Metric.ptToHwp(img.h ?? 100); // 이미지 높이 추가
             }
           }
-          // Also emit any text in the paragraph (spans)
-          const textKids = para.kids.filter((k: any) => k.tag !== 'img');
+          const textKids = para.kids.filter(
+            (k: any) => k.tag !== "img" && k.tag !== "link",
+          );
           if (textKids.length > 0) {
-            const textPara: ParaNode = { tag: 'para', props: para.props, kids: textKids as any };
-            for (const r of encodePara(textPara, col, 0, idGen())) chunks.push(r);
+            const textPara: ParaNode = {
+              tag: "para",
+              props: para.props,
+              kids: textKids as any,
+            };
+            for (const r of encodePara(
+              textPara,
+              bank,
+              0,
+              idGen(),
+              availWidthHwp,
+              paraMask,
+              vertPos,
+            )) {
+              // PARA_HEADER 레코드(목록의 첫 번째)에 마스크 적용
+              if (r[0] === (TAG_PARA_HEADER & 0xff)) {
+                // 레코드 헤더 수정은 복잡하므로 encodePara 내부에서 처리하는 것이 안전하지만
+                // 여기서는 간단히 구현하기 위해 encodePara의 인자로 mask를 넘기도록 구조를 변경하는 것이 좋습니다.
+              }
+              chunks.push(r);
+            }
+            // 단락 높이 계산 및 vertPos 업데이트 (이미지/텍스트 혼합)
+            const fontHwp_img = (
+              textKids.find(
+                (k: any) => k.tag === "span" && k.props?.pt,
+              ) as SpanNode
+            )?.props.pt
+              ? Metric.ptToHwp(
+                  (
+                    textKids.find(
+                      (k: any) => k.tag === "span" && k.props?.pt,
+                    ) as SpanNode
+                  ).props.pt as number,
+                )
+              : 1000;
+            const lineSpacePct_img = Math.round((para.props.lineHeight ?? 1.6) * 100);
+            vertPos += Math.round((fontHwp_img * lineSpacePct_img) / 100);
           }
         } else {
-          for (const r of encodePara(para, col, 0, idGen())) chunks.push(r);
+          for (const r of encodePara(
+            para,
+            bank,
+            0,
+            idGen(),
+            availWidthHwp,
+            paraMask,
+            vertPos,
+          ))
+            chunks.push(r);
+          // 단락 높이 계산 및 vertPos 업데이트 (일반 단락)
+          const fontHwp_para = (
+            para.kids.find(
+              (k: any) => k.tag === "span" && k.props?.pt,
+            ) as SpanNode
+          )?.props.pt
+            ? Metric.ptToHwp(
+                (
+                  para.kids.find(
+                    (k: any) => k.tag === "span" && k.props?.pt,
+                  ) as SpanNode
+                ).props.pt as number,
+              )
+            : 1000;
+          const lineSpacePct_para = para.props.lineHeight
+            ? Math.round(para.props.lineHeight * 100)
+            : 160;
+          vertPos += Math.round((fontHwp_para * lineSpacePct_para) / 100);
         }
-      } else if (node.tag === 'grid') {
-        // Table container paragraph at level 0
-        // nchars=9 (8 ctrl wchars + terminator), ctrlMask has bit 11 set for table ctrl
-        chunks.push(mkRec(TAG_PARA_HEADER,     0, mkParaHeader(9, TABLE_CTRL_MASK, 0, 1, 0, idGen())));
-        chunks.push(mkRec(TAG_PARA_TEXT,       1, mkTableParaText()));
+      } else if (node.tag === "grid") {
+        chunks.push(
+          mkRec(
+            TAG_PARA_HEADER,
+            0,
+            mkParaHeader(9, TABLE_CTRL_MASK, 0, 1, 1, idGen()),
+          ),
+        );
+        chunks.push(mkRec(TAG_PARA_TEXT, 1, mkTableParaText()));
         chunks.push(mkRec(TAG_PARA_CHAR_SHAPE, 1, mkParaCharShape([[0, 0]])));
-        // Table ctrl at level 1, TABLE record and cells at levels 2/3
-        for (const r of encodeGrid(node as GridNode, col, 1, idGen)) chunks.push(r);
+        chunks.push(
+          mkRec(
+            TAG_PARA_LINE_SEG,
+            1,
+            buildDefaultLineSeg(availWidthHwp, 1000, 9, undefined, vertPos),
+          ),
+        );
+        vertPos += Metric.ptToHwp(20); // 표 후 간격
+        for (const r of encodeGrid(
+          node as GridNode,
+          bank,
+          1,
+          idGen,
+          availWidthHwp,
+        ))
+          chunks.push(r);
       }
     }
   }
@@ -1082,266 +1539,562 @@ function buildBodyTextStream(
   return concatU8(chunks);
 }
 
-function b64Matches(binImg: BinImage, b64: string): boolean {
-  const a = TextKit.base64Encode(binImg.data).replace(/\s/g, '');
-  const b = b64.replace(/\s/g, '');
-  return a === b;
-}
-
-/* ═══════════════════════════════════════════════════════════════
-   HWP FileHeader stream (256 bytes)
-   ═══════════════════════════════════════════════════════════════ */
-
+// ─── HWP FileHeader ─────────────────────────────────────────
+/**
+ * HWP 5.0 FileHeader 를 생성합니다.
+ *
+ * 구조:
+ *  0-15: 시그니처 "HWP Document File" (16 바이트)
+ * 16-31: reserved (16 바이트)
+ * 32-35: version (4 바이트, Little-Endian) - 0x05000300 = 5.0.3.0
+ * 36-39: flags (4 바이트, Little-Endian) - bit 0 = compressed, bit 1 = encrypted
+ * 40-255: reserved (216 바이트)
+ *
+ * 총 256 바이트
+ */
 function buildHwpFileHeader(): Uint8Array {
-  const buf = new Uint8Array(256);
-  // Signature: "HWP Document File\x00" padded to 32 bytes
-  const sig = 'HWP Document File';
-  for (let i = 0; i < sig.length; i++) buf[i] = sig.charCodeAt(i);
+  const SIZE = 256;
+  const buf = new Uint8Array(SIZE);
   const dv = new DataView(buf.buffer);
-  dv.setUint32(32, 0x05000300, true); // version 5.0.3.0
-  dv.setUint32(36, 0x00000001, true); // flags: bit 0 = compressed (zlib)
+
+  // 0-15: 시그니처 "HWP Document File" (16 바이트)
+  const sig = "HWP Document File";
+  for (let i = 0; i < sig.length; i++) {
+    buf[i] = sig.charCodeAt(i);
+  }
+
+  // 16-31: reserved (0 으로 초기화됨)
+
+  // 32-35: version (4 바이트, Little-Endian) - 0x05000300 = 5.0.3.0
+  dv.setUint32(32, 0x05000300, true);
+
+  // 36-39: flags (4 바이트, Little-Endian)
+  // bit 0 = 1: compressed (압축됨)
+  // bit 1 = 0: not encrypted (암호화 안됨)
+  dv.setUint32(36, 0x00000001, true);
+
+  // 40-255: reserved (0 으로 초기화됨)
+
+  // 검증
+  if (buf.length !== SIZE) {
+    throw new Error(`FileHeader 크기 오류: ${buf.length} (기대: ${SIZE})`);
+  }
+  if (new TextDecoder().decode(buf.subarray(0, sig.length)) !== sig) {
+    throw new Error("FileHeader 시그니처 오류");
+  }
+  if (dv.getUint32(32, true) !== 0x05000300) {
+    throw new Error("FileHeader 버전 오류");
+  }
+
   return buf;
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   OLE2 / CFB container builder
-   ═══════════════════════════════════════════════════════════════ */
+// ─── OLE2/CFB 컨테이너 빌더 ─────────────────────────────────
 
 function buildHwpOle2(
   fileHeaderData: Uint8Array,
-  docInfoData:    Uint8Array,
-  section0Data:   Uint8Array,
-  binImages:      BinImage[] = [],
+  docInfoData: Uint8Array,
+  section0Data: Uint8Array,
+  binImages: BinImage[] = [],
 ): Uint8Array {
-  const SS = 512;
-  const ENDOFCHAIN = 0xFFFFFFFE;
-  const FREESECT   = 0xFFFFFFFF;
-  const FATSECT    = 0xFFFFFFFD;
-
-  function padSector(d: Uint8Array): Uint8Array {
-    const n = Math.ceil(Math.max(d.length, 1) / SS) * SS;
-    if (d.length === n) return d;
-    const out = new Uint8Array(n);
-    out.set(d);
-    return out;
+  const SS = 512; // 정규 섹터 크기
+  const MSS = 64; // 미니 섹터 크기
+  const ENDOFCHAIN = 0xfffffffe;
+  const FREESECT = 0xffffffff;
+  const FATSECT = 0xfffffffd;
+
+  // FileHeader 크기 검증
+  if (fileHeaderData.length < 256) {
+    throw new Error(
+      `FileHeader 크기 부족: ${fileHeaderData.length} (최소 256)`,
+    );
+  }
+
+  // 스트림 정의 및 4096바이트 미만(isMini) 여부 분류
+  interface OleStream {
+    name: string;
+    data: Uint8Array;
+    dirIdx: number;
+    isMini: boolean;
+    startSec?: number; // 미니 스트림은 미니 FAT 내 시작 인덱스, 정규 스트림은 regular FAT 내 시작 섹터
+  }
+
+  const streams: OleStream[] = [];
+  streams.push({
+    name: "FileHeader",
+    data: fileHeaderData,
+    dirIdx: 1,
+    isMini: fileHeaderData.length < 4096,
+  });
+  streams.push({
+    name: "DocInfo",
+    data: docInfoData,
+    dirIdx: 2,
+    isMini: docInfoData.length < 4096,
+  });
+  streams.push({
+    name: "Section0",
+    data: section0Data,
+    dirIdx: 4,
+    isMini: section0Data.length < 4096,
+  });
+
+  for (let i = 0; i < binImages.length; i++) {
+    const img = binImages[i];
+    const name = `BIN${String(img.id).padStart(4, "0")}.${img.ext}`;
+    streams.push({
+      name,
+      data: img.data,
+      dirIdx: 6 + i,
+      isMini: img.data.length < 4096,
+    });
   }
 
-  // Pad all data to sector boundaries
-  const fhPad  = padSector(fileHeaderData);
-  const diPad  = padSector(docInfoData);
-  const s0Pad  = padSector(section0Data);
-  const imgPads = binImages.map(img => padSector(img.data));
+  // 미니 스트림 패킹 및 Mini FAT 체인 생성
+  const miniStreams = streams.filter((s) => s.isMini);
+  const miniSectorList: number[] = [];
+  let miniStreamDataLength = 0;
+
+  for (const s of miniStreams) {
+    const startSec = miniStreamDataLength / MSS;
+    s.startSec = startSec;
+
+    const len = s.data.length;
+    const numMiniSecs = Math.ceil(len / MSS);
+
+    for (let i = 0; i < numMiniSecs; i++) {
+      const curSec = startSec + i;
+      const nextSec = i === numMiniSecs - 1 ? ENDOFCHAIN : curSec + 1;
+
+      while (miniSectorList.length <= curSec) {
+        miniSectorList.push(FREESECT);
+      }
+      miniSectorList[curSec] = nextSec;
+    }
 
-  const fhN  = fhPad.length / SS;
-  const diN  = diPad.length / SS;
-  const s0N  = s0Pad.length / SS;
-  const imgNs = imgPads.map(p => p.length / SS);
-  const totalImgN = imgNs.reduce((s, n) => s + n, 0);
+    miniStreamDataLength += numMiniSecs * MSS;
+  }
+
+  // 미니 스트림 데이터 버퍼 구성
+  const miniStreamData = new Uint8Array(miniStreamDataLength);
+  let miniStreamOffset = 0;
+  for (const s of miniStreams) {
+    miniStreamData.set(s.data, miniStreamOffset);
+    miniStreamOffset += Math.ceil(s.data.length / MSS) * MSS;
+  }
 
-  // Directory sectors: 4 entries per sector
-  // Entries: Root, FileHeader, DocInfo, BodyText, Section0 [+ BinData + images]
+  // 정규 스트림 패딩 및 섹터 개수 계산
+  const regularStreams = streams.filter((s) => !s.isMini);
+  const regPads = regularStreams.map((s) => {
+    const len = s.data.length;
+    const n = Math.ceil(Math.max(len, 1) / SS) * SS;
+    const out = new Uint8Array(n);
+    out.set(s.data);
+    return out;
+  });
+  const regNs = regPads.map((p) => p.length / SS);
+
+  // 디렉토리 섹터 크기 결정 (엔트리 개수 비례)
   const numDirEntries = 5 + (binImages.length > 0 ? 1 + binImages.length : 0);
-  const dirN = Math.max(2, Math.ceil(numDirEntries / 4));
+  const dirN = Math.max(1, Math.ceil((numDirEntries * 128) / SS));
+
+  // Mini FAT 섹터 크기 결정 (1 섹터당 128개 FAT 엔트리 수용)
+  const miniFatN = Math.ceil(miniSectorList.length / 128);
+
+  // Mini Stream을 위한 정규 섹터 크기 결정
+  const miniStreamN = Math.ceil(miniStreamData.length / SS);
+
+  // 정규 FAT 섹터 수 (fatN) 계산 루프
+  const totalRegStreamN = regNs.reduce((a, b) => a + b, 0);
+  const neededDataSec = dirN + miniFatN + miniStreamN + totalRegStreamN;
 
-  // Compute FAT sector count iteratively
   let fatN = 1;
   for (let iter = 0; iter < 10; iter++) {
-    const total  = fatN + dirN + fhN + diN + s0N + totalImgN;
-    const needed = Math.ceil(total / 128);
-    if (needed <= fatN) break;
-    fatN = needed;
+    const totalSec = fatN + neededDataSec;
+    const neededFat = Math.ceil(totalSec / 128);
+    if (neededFat <= fatN) break;
+    fatN = neededFat;
   }
 
-  const dir1Sec = fatN;
-  const fhSec   = fatN + dirN;
-  const diSec   = fhSec + fhN;
-  const s0Sec   = diSec + diN;
+  const totalSec = fatN + neededDataSec;
+
+  // 각 정규 섹터 영역의 시작 위치 할당
+  const dirStartSec = fatN;
+  const miniFatStartSec = dirStartSec + dirN;
+  const miniStreamStartSec = miniFatStartSec + miniFatN;
 
-  // Image sectors come after section0
-  const imgSecs: number[] = [];
-  let curSec = s0Sec + s0N;
-  for (const n of imgNs) { imgSecs.push(curSec); curSec += n; }
-  const totalSec = curSec;
+  let curSec = miniStreamStartSec + miniStreamN;
+  for (let i = 0; i < regularStreams.length; i++) {
+    regularStreams[i].startSec = curSec;
+    curSec += regNs[i];
+  }
 
-  // Build FAT
-  const fatBuf = new Uint8Array(fatN * SS).fill(0xFF);
+  // 정규 FAT 버퍼 구성
+  const fatBuf = new Uint8Array(fatN * SS).fill(0xff);
   const setFat = (i: number, v: number) => {
-    fatBuf[i * 4]     = v & 0xFF;
-    fatBuf[i * 4 + 1] = (v >>> 8) & 0xFF;
-    fatBuf[i * 4 + 2] = (v >>> 16) & 0xFF;
-    fatBuf[i * 4 + 3] = (v >>> 24) & 0xFF;
+    const off = i * 4;
+    fatBuf[off] = v & 0xff;
+    fatBuf[off + 1] = (v >>> 8) & 0xff;
+    fatBuf[off + 2] = (v >>> 16) & 0xff;
+    fatBuf[off + 3] = (v >>> 24) & 0xff;
+  };
+
+  // FAT 섹터 자신 표시
+  for (let i = 0; i < fatN; i++) {
+    setFat(i, FATSECT);
+  }
+
+  // Directory 섹터 체인 연결
+  for (let i = 0; i < dirN; i++) {
+    setFat(
+      dirStartSec + i,
+      i + 1 < dirN ? dirStartSec + i + 1 : ENDOFCHAIN,
+    );
+  }
+
+  // Mini FAT 섹터 체인 연결
+  if (miniFatN > 0) {
+    for (let i = 0; i < miniFatN; i++) {
+      setFat(
+        miniFatStartSec + i,
+        i + 1 < miniFatN ? miniFatStartSec + i + 1 : ENDOFCHAIN,
+      );
+    }
+  }
+
+  // Mini Stream 섹터 체인 연결
+  if (miniStreamN > 0) {
+    for (let i = 0; i < miniStreamN; i++) {
+      setFat(
+        miniStreamStartSec + i,
+        i + 1 < miniStreamN ? miniStreamStartSec + i + 1 : ENDOFCHAIN,
+      );
+    }
+  }
+
+  // 정규 스트림 섹터 체인 연결
+  for (let i = 0; i < regularStreams.length; i++) {
+    const s = regularStreams[i];
+    const n = regNs[i];
+    const start = s.startSec!;
+    for (let j = 0; j < n; j++) {
+      setFat(start + j, j + 1 < n ? start + j + 1 : ENDOFCHAIN);
+    }
+  }
+
+  // Mini FAT 버퍼 생성
+  const miniFatBuf = new Uint8Array(miniFatN * SS).fill(0xff);
+  const setMiniFat = (i: number, v: number) => {
+    const off = i * 4;
+    miniFatBuf[off] = v & 0xff;
+    miniFatBuf[off + 1] = (v >>> 8) & 0xff;
+    miniFatBuf[off + 2] = (v >>> 16) & 0xff;
+    miniFatBuf[off + 3] = (v >>> 24) & 0xff;
   };
 
-  for (let i = 0; i < fatN; i++) setFat(i, FATSECT);
-  for (let i = 0; i < dirN; i++) setFat(dir1Sec + i, i + 1 < dirN ? dir1Sec + i + 1 : ENDOFCHAIN);
-  for (let i = 0; i < fhN;  i++) setFat(fhSec  + i, i + 1 < fhN  ? fhSec  + i + 1 : ENDOFCHAIN);
-  for (let i = 0; i < diN;  i++) setFat(diSec  + i, i + 1 < diN  ? diSec  + i + 1 : ENDOFCHAIN);
-  for (let i = 0; i < s0N;  i++) setFat(s0Sec  + i, i + 1 < s0N  ? s0Sec  + i + 1 : ENDOFCHAIN);
-  for (let ii = 0; ii < imgNs.length; ii++) {
-    const start = imgSecs[ii];
-    const n = imgNs[ii];
-    for (let i = 0; i < n; i++) setFat(start + i, i + 1 < n ? start + i + 1 : ENDOFCHAIN);
+  for (let i = 0; i < miniSectorList.length; i++) {
+    setMiniFat(i, miniSectorList[i]);
   }
 
-  // Build directory
+  // 디렉토리 버퍼 생성
   const dirBuf = new Uint8Array(dirN * SS);
-  const dv     = new DataView(dirBuf.buffer);
+  const dv = new DataView(dirBuf.buffer);
 
   function writeDirEntry(
-    idx: number, name: string, type: number,
-    left: number, right: number, child: number,
-    startSec: number, size: number,
-  ) {
+    idx: number,
+    name: string,
+    type: number,
+    left: number,
+    right: number,
+    child: number,
+    startSec: number,
+    size: number,
+  ): void {
     const base = idx * 128;
-    const nl   = Math.min(name.length, 31);
-    for (let i = 0; i < nl; i++) dv.setUint16(base + i * 2, name.charCodeAt(i), true);
+    const nl = name.length;
+    // OLE2: 이름은 UTF-16LE, (글자수+1)*2 바이트가 길이 필드에 기록됨
+    for (let i = 0; i < nl; i++) {
+      dv.setUint16(base + i * 2, name.charCodeAt(i), true);
+    }
     dv.setUint16(base + 64, (nl + 1) * 2, true);
     dirBuf[base + 66] = type;
-    dirBuf[base + 67] = 1; // color = black
-    dv.setInt32(base + 68, left,  true);
+    dirBuf[base + 67] = 1; // DE_NODE (블랙 노드)
+    dv.setInt32(base + 68, left, true);
     dv.setInt32(base + 72, right, true);
     dv.setInt32(base + 76, child, true);
     dv.setUint32(base + 116, startSec >>> 0, true);
-    dv.setUint32(base + 120, size >>> 0,     true);
+    dv.setUint32(base + 120, size >>> 0, true);
+  }
+
+  // 모든 디렉토리 엔트리 -1 (NOSTREAM)으로 초기화
+  for (let i = 0; i < dirN * 4; i++) {
+    const base = i * 128;
+    dv.setInt32(base + 68, -1, true);
+    dv.setInt32(base + 72, -1, true);
+    dv.setInt32(base + 76, -1, true);
   }
 
+  // 스트림 인덱스 맵 생성
+  const streamMap = new Map<number, OleStream>();
+  for (const s of streams) {
+    streamMap.set(s.dirIdx, s);
+  }
+
+  // Root Entry (0번): 미니 스트림의 루트 역할을 하며 미니 스트림 데이터를 가리킴
+  writeDirEntry(
+    0,
+    "Root Entry",
+    5,
+    -1,
+    -1,
+    3,
+    miniStreamStartSec,
+    miniStreamData.length,
+  );
+
+  // HWP Root Entry CLSID 설정
+  const HWP_CLSID = [
+    0x20, 0xe9, 0xe3, 0xc0, 0x46, 0x35, 0xcf, 0x11, 0x8d, 0x81, 0x00, 0xaa,
+    0x00, 0x38, 0x9b, 0x71,
+  ];
+  for (let i = 0; i < 16; i++) {
+    dirBuf[0 * 128 + 80 + i] = HWP_CLSID[i];
+  }
+
+  // FileHeader (1번)
+  const fhStream = streamMap.get(1)!;
+  writeDirEntry(
+    1,
+    "FileHeader",
+    2,
+    -1,
+    -1,
+    -1,
+    fhStream.startSec!,
+    fhStream.data.length,
+  );
+
+  // DocInfo (2번) - 이미지가 있는 경우 BinData(5번)를 left로 지정
+  const diStream = streamMap.get(2)!;
+  const docInfoLeft = binImages.length > 0 ? 5 : -1;
+  writeDirEntry(
+    2,
+    "DocInfo",
+    2,
+    docInfoLeft,
+    -1,
+    -1,
+    diStream.startSec!,
+    diStream.data.length,
+  );
+
+  // BodyText (3번) - Root Entry 아래의 검색 허브 역할 (left: DocInfo(2), right: FileHeader(1), child: Section0(4))
+  writeDirEntry(3, "BodyText", 1, 2, 1, 4, ENDOFCHAIN, 0);
+
+  // Section0 (4번)
+  const s0Stream = streamMap.get(4)!;
+  writeDirEntry(
+    4,
+    "Section0",
+    2,
+    -1,
+    -1,
+    -1,
+    s0Stream.startSec!,
+    s0Stream.data.length,
+  );
+
+  // BinData (5번)
   if (binImages.length > 0) {
-    // Tree: Root(0)→FileHeader(1)→DocInfo(2)→BodyText(3)→Section0(4)
-    //                                          BodyText sibling=BinData(5)
-    //       BinData(5)→BIN0001.xxx(6)→BIN0002.xxx(7)→...
-    writeDirEntry(0, 'Root Entry', 5, -1, -1,  1, ENDOFCHAIN, 0);
-    writeDirEntry(1, 'FileHeader', 2, -1,  2, -1, fhSec, fileHeaderData.length);
-    writeDirEntry(2, 'DocInfo',    2, -1,  3, -1, diSec, docInfoData.length);
-    writeDirEntry(3, 'BodyText',   1, -1,  5,  4, ENDOFCHAIN, 0); // sibling=BinData(5)
-    writeDirEntry(4, 'Section0',   2, -1, -1, -1, s0Sec, section0Data.length);
-    writeDirEntry(5, 'BinData',    1, -1, -1,  6, ENDOFCHAIN, 0); // child=first image(6)
-    for (let ii = 0; ii < binImages.length; ii++) {
-      const img = binImages[ii];
-      const streamName = `BIN${String(img.id).padStart(4, '0')}.${img.ext}`;
-      const sibling = ii + 1 < binImages.length ? 7 + ii : -1;
-      writeDirEntry(6 + ii, streamName, 2, -1, sibling, -1, imgSecs[ii], img.data.length);
+    writeDirEntry(5, "BinData", 1, -1, -1, 6, ENDOFCHAIN, 0);
+
+    for (let i = 0; i < binImages.length; i++) {
+      const imgStream = streamMap.get(6 + i)!;
+      const sibling = i + 1 < binImages.length ? 7 + i : -1;
+      writeDirEntry(
+        6 + i,
+        imgStream.name,
+        2,
+        -1,
+        sibling,
+        -1,
+        imgStream.startSec!,
+        imgStream.data.length,
+      );
     }
-  } else {
-    // No images — original 5-entry structure
-    writeDirEntry(0, 'Root Entry', 5, -1, -1,  1, ENDOFCHAIN, 0);
-    writeDirEntry(1, 'FileHeader', 2, -1,  2, -1, fhSec, fileHeaderData.length);
-    writeDirEntry(2, 'DocInfo',    2, -1,  3, -1, diSec, docInfoData.length);
-    writeDirEntry(3, 'BodyText',   1, -1, -1,  4, ENDOFCHAIN, 0);
-    writeDirEntry(4, 'Section0',   2, -1, -1, -1, s0Sec, section0Data.length);
-  }
-
-  // Build OLE2 file header (512 bytes)
-  const hdr  = new Uint8Array(SS);
-  const hdv  = new DataView(hdr.buffer);
-  const MAGIC = [0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
-  MAGIC.forEach((b, i) => { hdr[i] = b; });
-  hdv.setUint16(24, 0x003E, true); // minor version
-  hdv.setUint16(26, 0x0003, true); // major version
-  hdv.setUint16(28, 0xFFFE, true); // byte order (LE)
-  hdv.setUint16(30, 9,      true); // sector size = 2^9 = 512
-  hdv.setUint16(32, 6,      true); // mini sector size = 2^6 = 64
-  hdv.setUint32(40, 0,          true); // num dir sectors (0 for v3)
-  hdv.setUint32(44, fatN,       true); // num FAT sectors
-  hdv.setUint32(48, dir1Sec,    true); // first directory sector
-  hdv.setUint32(52, 0,          true); // transaction signature (0)
-  hdv.setUint32(56, 0x1000,     true); // mini stream cutoff = 4096
-  hdv.setUint32(60, ENDOFCHAIN, true); // first mini FAT sector (none)
-  hdv.setUint32(64, 0,          true); // num mini FAT sectors (0)
-  hdv.setUint32(68, ENDOFCHAIN, true); // first DIFAT extension (none)
-  hdv.setUint32(72, 0,          true); // num DIFAT extensions (0)
+  }
+
+  // 헤더 생성 (512바이트)
+  const hdr = new Uint8Array(SS);
+  const hdv = new DataView(hdr.buffer);
+
+  // OLE2 시그니처 (Magic)
+  const MAGIC = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+  MAGIC.forEach((b, i) => {
+    hdr[i] = b;
+  });
+
+  hdv.setUint16(24, 0x003e, true); // Minor version
+  hdv.setUint16(26, 0x0003, true); // Major version
+  hdv.setUint16(28, 0xfffe, true); // Byte order (0xFFFE = 리틀 엔디안 BOM)
+  hdv.setUint16(30, 0x0009, true); // Sector size exponent (2^9 = 512)
+  hdv.setUint16(32, 0x0006, true); // Mini sector size exponent (2^6 = 64)
+
+  hdv.setUint32(40, 0, true); // Number of Directory Sectors (Version 3에서는 0으로 채움)
+  hdv.setUint32(44, fatN, true); // Number of FAT Sectors (0x002C)
+  hdv.setUint32(48, dirStartSec, true); // Starting Sector of Directory Stream (0x0030)
+  hdv.setUint32(52, 0, true); // Transaction Signature Number (0x0034)
+  hdv.setUint32(56, 0x1000, true); // Mini Stream Cutoff Size (0x0038)
+  hdv.setUint32(60, miniFatN > 0 ? miniFatStartSec : ENDOFCHAIN, true); // Starting Sector of Mini FAT (0x003C)
+  hdv.setUint32(64, miniFatN, true); // Number of Mini FAT Sectors (0x0040)
+  hdv.setUint32(68, ENDOFCHAIN, true); // Starting Sector of DIFAT (0x0044)
+  hdv.setUint32(72, 0, true); // Number of DIFAT Sectors (0x0048)
+
+  // Sector bitmap (DIFAT) 슬롯 채우기 (처음 109개 FAT 섹터 번호 지정)
   for (let i = 0; i < 109; i++) {
     hdv.setUint32(76 + i * 4, i < fatN ? i : FREESECT, true);
   }
 
-  // Assemble output
+  // 최종 바이트 어레이 조립 및 출력 생성
   const out = new Uint8Array(SS + totalSec * SS);
-  out.set(hdr, 0);
-  for (let i = 0; i < fatN; i++) {
-    out.set(fatBuf.subarray(i * SS, (i + 1) * SS), SS + i * SS);
+  let outOff = 0;
+
+  // 1. Header (Sector -1)
+  out.set(hdr, outOff);
+  outOff += SS;
+
+  // 2. FAT sectors
+  out.set(fatBuf, outOff);
+  outOff += fatN * SS;
+
+  // 3. Directory sectors
+  out.set(dirBuf, outOff);
+  outOff += dirN * SS;
+
+  // 4. Mini FAT sectors
+  if (miniFatN > 0) {
+    out.set(miniFatBuf, outOff);
+    outOff += miniFatN * SS;
   }
-  for (let i = 0; i < dirN; i++) {
-    out.set(dirBuf.subarray(i * SS, (i + 1) * SS), SS + (dir1Sec + i) * SS);
+
+  // 5. Mini Stream sectors (Root Entry Data)
+  if (miniStreamN > 0) {
+    const miniStreamPad = new Uint8Array(miniStreamN * SS);
+    miniStreamPad.set(miniStreamData);
+    out.set(miniStreamPad, outOff);
+    outOff += miniStreamN * SS;
   }
-  out.set(fhPad, SS + fhSec * SS);
-  out.set(diPad, SS + diSec * SS);
-  out.set(s0Pad, SS + s0Sec * SS);
-  for (let ii = 0; ii < imgPads.length; ii++) {
-    out.set(imgPads[ii], SS + imgSecs[ii] * SS);
+
+  // 6. Regular Streams sectors
+  for (let i = 0; i < regularStreams.length; i++) {
+    out.set(regPads[i], outOff);
+    outOff += regNs[i] * SS;
   }
+
   return out;
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   Utility
-   ═══════════════════════════════════════════════════════════════ */
+// ─── 유틸리티 ────────────────────────────────────────────────
 
 function concatU8(arrays: Uint8Array[]): Uint8Array {
   const total = arrays.reduce((s, a) => s + a.length, 0);
-  const out   = new Uint8Array(total);
+  const out = new Uint8Array(total);
   let off = 0;
-  for (const a of arrays) { out.set(a, off); off += a.length; }
+  for (const a of arrays) {
+    out.set(a, off);
+    off += a.length;
+  }
   return out;
 }
 
-/* ═══════════════════════════════════════════════════════════════
-   Encoder entry point
-   ═══════════════════════════════════════════════════════════════ */
+// ─── OLE2 검증 ──────────────────────────────────────────────
 
-export class HwpEncoder implements Encoder {
-  readonly format = 'hwp';
+function validateOle2Magic(hwp: Uint8Array): boolean {
+  const OLE_MAGIC = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+  return OLE_MAGIC.every((b, i) => hwp[i] === b);
+}
+
+// ─── Encoder 진입점 ──────────────────────────────────────────
+
+export class HwpEncoder extends BaseEncoder {
+  protected getFormat(): string {
+    return "hwp";
+  }
+  protected getAliases(): string[] {
+    return ["application/vnd.hancom.hwp"];
+  }
 
   async encode(doc: DocRoot): Promise<Outcome<Uint8Array>> {
     try {
-      // First pass: collect unique styles
-      const col = new StyleCollector();
+      // 패스 1: 스타일 수집 (HwpStyleBank — ANYTOHWP 방식 언어별 폰트)
+      const bank = new HwpStyleBank();
       for (const sheet of doc.kids) {
-        for (const node of sheet.kids) collectNode(node, col);
+        for (const node of sheet.kids) collectNode(node, bank);
       }
 
-      // Collect images from all paragraphs
+      // 이미지 수집 (ANYTOHWP 개선: 픽셀 치수는 encodePicPara에서 추출)
       const images: BinImage[] = [];
       const seenB64 = new Set<string>();
       let binIdCounter = 1;
 
+      function registerImg(img: any): void {
+        const key = img.b64.substring(0, 50);
+        if (seenB64.has(key)) return;
+        seenB64.add(key);
+        const raw = TextKit.base64Decode(img.b64);
+        const ext =
+          img.mime === "image/png"
+            ? "png"
+            : img.mime === "image/gif"
+              ? "gif"
+              : img.mime === "image/bmp"
+                ? "bmp"
+                : "jpg";
+        images.push({ id: binIdCounter++, ext, data: new Uint8Array(raw) });
+      }
+
       function collectImages(node: any): void {
-        if (node.tag === 'para') {
-          for (const kid of node.kids) {
-            if (kid.tag === 'img') {
-              const key = kid.b64.substring(0, 50);
-              if (!seenB64.has(key)) {
-                seenB64.add(key);
-                const raw = TextKit.base64Decode(kid.b64);
-                let ext = 'jpg';
-                if (kid.mime === 'image/png') ext = 'png';
-                else if (kid.mime === 'image/gif') ext = 'gif';
-                else if (kid.mime === 'image/bmp') ext = 'bmp';
-                images.push({ id: binIdCounter++, ext, data: new Uint8Array(raw) });
-              }
-            }
-          }
-        } else if (node.tag === 'grid') {
-          for (const row of node.kids) {
-            for (const cell of row.kids) {
+        if (node.tag === "para") {
+          for (const img of flatImgNodes(node.kids)) registerImg(img);
+        } else if (node.tag === "grid") {
+          for (const row of node.kids)
+            for (const cell of row.kids)
               for (const para of cell.kids) collectImages(para);
-            }
-          }
         }
       }
       for (const sheet of doc.kids) {
         for (const node of sheet.kids) collectImages(node);
       }
 
-      // Build streams (raw, uncompressed)
-      const docInfoRaw = buildDocInfoStream(col, images);
-      const bodyRaw    = buildBodyTextStream(doc, col, images);
+      // 패스 2: 스트림 빌드
+      const docInfoRaw = buildDocInfoStream(bank, images);
+      const bodyRaw = buildBodyTextStream(doc, bank, images);
 
-      // Compress with zlib (HWP uses zlib deflate for DocInfo and BodyText streams)
-      const docInfoCmp = pako.deflate(docInfoRaw);
-      const bodyCmp    = pako.deflate(bodyRaw);
+      // HWP 5.0: Zlib 헤더 없는 Raw Deflate
+      const docInfoCmp = pako.deflateRaw(docInfoRaw);
+      const bodyCmp = pako.deflateRaw(bodyRaw);
 
-      // Assemble OLE2 file (images go as raw streams in BinData storage, NOT compressed)
       const fileHdr = buildHwpFileHeader();
-      const hwp     = buildHwpOle2(fileHdr, docInfoCmp, bodyCmp, images);
+
+      // FileHeader 검증
+      if (fileHdr.length !== 256) {
+        return fail(
+          `HwpEncoder: FileHeader 크기 오류 - ${fileHdr.length} bytes (기대: 256 bytes)`,
+        );
+      }
+
+      const hwp = buildHwpOle2(fileHdr, docInfoCmp, bodyCmp, images);
+
+      if (!validateOle2Magic(hwp)) {
+        return fail("HwpEncoder: OLE2 매직 바이트 오류");
+      }
+
+      // HWP 파일 크기 검증 (최소 512 바이트 - OLE2 헤더 1 섹터)
+      if (hwp.length < 512) {
+        return fail(
+          `HwpEncoder: HWP 파일 크기 부족 - ${hwp.length} bytes (최소 512 bytes)`,
+        );
+      }
 
       return succeed(hwp);
     } catch (e: any) {