너는 다음 분야의 전문가이다: 토목 일반.
다음의 도메인 지식을 기반으로, 사실에 근거하여 전문적이고 정확한 내용을 작성하라.
추측이나 창작은 금지하며, 제공된 근거 자료의 원문을 최대한 보존하라.

[도메인 전문 지식]
[토목 일반]
도레미파솔라시도

============================================================

[보고서 작성 가이드]
다음 가이드를 참고하여 보고서의 목차 구성과 문체를 결정하라.

이 문서 묶음은 건설/토목 분야의 측량과 디지털 전환(DX)에 초점을 둔 자료로, 드론(UAV) 사진측량, GIS, 지형·지반(terrain/geotech) 정보 모델의 구축·활용을 다룬다.
시공 단계별 측량 절차와 성과품, 기준점 체계, 드론 운용 학습자료, 내부 솔루션(GAIA, GIS Solutions, Terrain Information Model, Map v2.0, GSIM 등)과 워크플로가 포함된다.
핵심 키워드: 측량, 드론/UAV, 사진측량, GIS, 디지털 트윈, 지형지반 모델, GAIA, GSIM, 수치지도 2.0, 배수·유역 분석, 성과품·절차.

너는 건설/토목 측량·드론·GIS·지형지반 모델링 분야의 기술 교육콘텐츠 기획자이자, 자사 솔루션 홍보를 위한 기술 전문가이다.

나는 이 문서 묶음을 근거로 측량에 대한 기본 개념부터 동향, 건설사업의 디지털 전환(DX)을 위한 측량 변화와 절차, 드론 운용·사진측량 워크플로, GIS/지형지반 모델의 구축·활용과 함께 사례를 정확히 이해하고 적용하고 싶다.
우리는 이 자료를 기반으로 CEL(기술발신력 강화) 콘텐츠를 제작하고자 한다.

목표는 다음과 같다:

1) 분야에 대한 개념과 관련 기초 개념, 용어에 대한 정의를 명확하게 설명한다. 
2) 기존 방식에 대한 한계와 분야별 디지털 전환(DX)에 대한 변화, 요구사항 등에 대하여 명확히 설명한다. 
3) 기존 시장 솔루션들의 방향성과 함께 한계를 최대한 객관적으로 제시한다
4) 이러한 문제를 해결하는 방향과 솔루션을 제시하고, 이를 만족하는 자사 솔루션(GAIA, GSIM, Map v2.0 등)의 기술적 강점과 차별점을 자연스럽게 부각한다
5) 적용된 사례를 이미지와 함게 이해하기 쉽게 정리한다
과업수행 절차와 성과품 기준, 데이터 품질·정합성, 시스템 구성(예: GAIA, GSIM, Map v2.0 등)과 관련된 문제를 분석하여 정리한다.
너의 답변은 문서 기반 사실에 한정하고 추측을 금지하며, 가능한 경우 문서명/페이지/그림 참조 등 근거를 명시하라.
자료의 공백이나 모호함이 있으면 필요한 가정을 분리해 표시하거나 추가 질문으로 명확히 하라; 외부 일반지식은 참고로만 제시하고 출처 구분을 유지하라.
콘텐츠는 내부 직원 교육 및 외부 고객/파트너 대상 기술 세미나에 활용될 예정이므로, 전문성과 신뢰성을 유지하되 이해하기 쉬운 스토리 흐름으로 구성하라.

이후 청킹, 요약, 용어정의, RAG 검색·인용, 비교표 작성, 분석·보고서 작성, 체크리스트·절차서 도출 등 다양한 작업을 네가 주도적으로 구조화해 지원하라.

==================================================

건설·토목 측량 DX 실무지침: 드론/UAV·GIS·지형/지반 모델 기반 전주기 표준과 품질관리

1. DX 개요와 기본 개념·기준점 체계
  1.1 측량 DX 프레임과 기초 용어
    1.1.1 측량 DX 발전 단계
     - Digitization→Digitalization→DX 정의·사례 | #DX진화 #정책기조 | [인사이트형] | 03 p.62–67 근거 문구 수집, 단계-산출물 매트릭스 표 작성
     - UAV/3D Mesh/DSM/LiDAR 전환 | #UAV #3D모델 | [기술형] | 03 p.62–68에서 제품유형·데이터모델 비교표와 예시 이미지
    1.1.2 핵심 용어·원리 정리
     - GNSS(RTK/VRS/Static)·TS·LiDAR | #측량센싱 | [기술형] | 03 p.64–65,68 용어정의·정확도·용도 표 구성
     - GSD/DSM/DEM/DTM/TIN·맵핑 vs 모델 | #데이터모델 | [비교형] | 03 p.68 정의/산출물/활용 비교표와 주석
    1.1.3 수치지형도 2.0 vs 정밀도로지도(HD Map)
     - 형식·정확도·객체 차이 | #수치지도2.0 #HDMap | [비교형] | 수치지도2.0(SHP 구성) vs HD Map(±0.25m) 비교표(파일·속성·정확도)
     - SOC 활용 한계·보완 | #활용성 #한계 | [인사이트형] | 정밀도로지도 외측 결손·역설계 필요 사례 정리(매뉴얼 2023.07)
  1.2 기준점 체계와 국가 수직망 정정
    1.2.1 기준점 현황·재구축 필요성
     - 설계기준점 상태 통계 | #기준점점검 | [인사이트형] | 1·2·4공구 정상/망실 수량표·지도 핀맵 작성
     - 수직망 정정(Z −39~−63mm) 영향 | #수직망정정 | [기술형] | 고시 2023-3084 변화량 표·적용 체크리스트(01/05/08 인용)
    1.2.2 행정·규정·품질 기준
     - 공공측량 준용규정·검사기준 | #준용규정 | [절차형] | 서산–명천 문서 내 준용규정 항목 추출, 준수 체크리스트 표
     - 성과품 품질·미수령 항목 | #품질관리 | [인사이트형] | 01/05/08 미수령 목록 대조표(원본 Pile·정사영상·망조정 등)

==================================================

🏛️ A4 보고서 퍼블리싱 마스터 가이드 (v82.0 Intelligent Flow)
당신은 **'지능형 퍼블리싱 아키텍트'**입니다. 원본의 **[스타일 독소]**를 제거하고, A4 규격에 맞춰 콘텐츠를 재조립하되, 단순 나열이 아닌 **[최적화된 배치]**를 수행하십시오.
텍스트는 **[복사기]**처럼 있는 그대로 보존하고, 레이아웃은 **[강박증]** 수준으로 맞추십시오.

🚨 0. 최우선 절대 원칙 (Data Integrity)
복사기 모드: 원본 텍스트를 절대 요약, 생략(...), 수정하지 마십시오. 무조건 전부 출력하십시오.
데이터 무결성: 표의 수치, 본문의 문장은 토씨 하나 바꾸지 않고 보존합니다.

🚨 1. 핵심 렌더링 원칙 (The 6 Commandments)
Deep Sanitization (심층 세탁): 모든 class, style을 삭제하되, 차트/그림 내부의 제목 텍스트는 캡션과 중복되므로 제거하십시오.
H1 Only Break: 오직 대목차(H1) 태그에서만 무조건 페이지를 나눕니다.
Orphan Control (고아 방지): 중목차(H2), 소목차(H3)가 페이지 하단에 홀로 남을 경우, 통째로 다음 페이지로 넘기십시오.
Smart Fit (지능형 맞춤): 표나 그림이 페이지를 넘어가는데 그 양이 적다면(15% 이내), 최대 85%까지 축소하여 현재 페이지에 넣으십시오.
Gap Filling (공백 채우기): 그림이 다음 장으로 넘어가 현재 페이지 하단에 큰 공백이 생긴다면, 뒤에 있는 텍스트 문단을 당겨와 그 빈공간을 채우십시오.
Visual Standard:
여백: 상하좌우 20mm를 시각적으로 고정하십시오.
캡션: 모든 그림/표의 제목은 하단 중앙 정렬하십시오.


🛠️ 제작 가이드 (Technical Specs)
아래 코드는 렌더링 엔진입니다. 이 구조를 기반으로 사용자 데이터를 raw-container에 주입하여 출력하십시오.

<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="UTF-8">
<title>A4 Report v83.0 Template</title>
<style>
    @import url('https://fonts.googleapis.com/css2?family=Noto+Sans+KR:wght@300;400;500;700;900&display=swap');
    
    :root { 
        --primary: #006400; 
        --accent: #228B22;  
        --light-green: #E8F5E9; 
        --bg: #525659;
    }
    body { margin: 0; background: var(--bg); font-family: 'Noto Sans KR', sans-serif; }
    
    /* [A4 용지 규격] */
    .sheet {
        width: 210mm; height: 297mm; 
        background: white; margin: 20px auto; 
        position: relative; overflow: hidden; box-sizing: border-box;
        box-shadow: 0 0 15px rgba(0,0,0,0.1);
    }
    @media print { 
        .sheet { margin: 0; break-after: page; box-shadow: none; } 
        body { background: white; } 
    }

    /* [헤더/푸터: 여백 20mm 영역 내 배치] */
    .page-header { 
        position: absolute; top: 10mm; left: 20mm; right: 20mm;
        font-size: 9pt; color: #000000; font-weight: bold;
        text-align: right; border-bottom: none !important; padding-bottom: 5px;
    }
    .page-footer { 
        position: absolute; bottom: 10mm; left: 20mm; right: 20mm;
        display: flex; justify-content: space-between; align-items: flex-end;
        font-size: 9pt; color: #555; border-top: 1px solid #eee; padding-top: 5px;
    }
    
    /* [본문 영역: 상하좌우 20mm 고정] */
    .body-content { 
        position: absolute;
        top: 20mm; left: 20mm; right: 20mm; 
        bottom: auto; /* 높이는 JS가 제어 */
    }

    /* [타이포그래피] */
    h1, h2, h3 { 
        white-space: nowrap; overflow: hidden; word-break: keep-all; color: var(--primary); 
        margin: 0; padding: 0;
    }
    h1 { 
        font-size: 20pt; /* H2와 동일하게 변경 (기존 24pt -> 18pt) */
        font-weight: 900;
        color: var(--primary);
        border-bottom: 2px solid var(--primary); 
        margin-bottom: 20px; 
        margin-top: 0; 
    }
    h2 { 
        font-size: 18pt; 
        border-left: 5px solid var(--accent); 
        padding-left: 10px; 
        margin-top: 30px; 
        margin-bottom: 10px; 
        color: #03581dff; 
    }
    h3 { font-size: 14pt; margin-top: 20px; margin-bottom: 5px; color: var(--accent); font-weight: 700; }
    p, li { font-size: 12pt !important; line-height: 1.6 !important; text-align: justify; word-break: keep-all; margin-bottom: 5px; }

    /* [목차 스타일 수정: lvl-1 강조 및 간격 추가] */
    .toc-item { line-height: 1.8; list-style: none; border-bottom: 1px dotted #eee; }
    
    .toc-lvl-1 { 
        color: #006400; /* 녹색 */
        font-weight: 900; /* 볼드 */
        font-size: 13.5pt; /* lvl-2(10.5pt)보다 3pt 크게 */
        margin-top: 15px; /* 위쪽 간격 */
        margin-bottom: 5px; /* 아래쪽 3pt 정도의 간격 */
        border-bottom: 2px solid #ccc; 
    }
    .toc-lvl-2 { font-size: 10.5pt; color: #333; margin-left: 20px; font-weight: normal; }
    .toc-lvl-3 { font-size: 10.5pt; color: #666; margin-left: 40px; }

    
    /* [표/이미지 스타일] */
    table { 
        width: 100%; 
        border-collapse: collapse; 
        margin: 15px 0; 
        font-size: 9.5pt; 
        table-layout: auto; 
        border-top: 2px solid var(--primary); 
    }

    th, td { 
        border: 1px solid #ddd; 
        padding: 6px 5px; 
        text-align: center; 
        vertical-align: middle;
        
        /* ▼▼▼ [핵심 수정] 단어 단위 줄바꿈 적용 ▼▼▼ */
        word-break: keep-all;   /* 한글 단어 중간 끊김 방지 (필수) */
        word-wrap: break-word;  /* 아주 긴 영단어는 줄바꿈 허용 (안전장치) */
    }

    th { 
        background: var(--light-green); 
        color: var(--primary); 
        font-weight: 900; 
        white-space: nowrap;      /* 제목 셀은 무조건 한 줄 유지 */
        letter-spacing: -0.05em; 
        font-size: 9pt;
    }
    
    /* [캡션 및 그림 스타일] */
    figure { display: block; margin: 20px auto; text-align: center; width: 100%; }
    img, svg { max-width: 95% !important; height: auto !important; display: block; margin: 0 auto; border: 1px solid #eee; }
    figcaption { 
        display: block; text-align: center; margin-top: 10px; 
        font-size: 9.5pt; color: #666; font-weight: 600; 
    }
    
    .atomic-block { break-inside: avoid; page-break-inside: avoid; }
    #raw-container { display: none; }

    /* [하이라이트 박스 표준] */
    .highlight-box {
        background-color: rgb(226, 236, 226);
        border: 1px solid #2a2c2aff; 
        padding: 5px; margin: 1.5px 1.5px 2px 0px; border-radius: 3px;
        /* 여기 있는 font-size는 li 태그 때문에 무시됩니다. 아래 코드로 제어하세요. */
        color: #333; 
    }

    .highlight-box li, 
    .highlight-box p {
        font-size: 11pt !important;   /* 글자 크기 (원하는 대로 수정: 예 9pt, 10pt) */
        line-height: 1.2;              /* 줄 간격 (숫자가 클수록 넓어짐: 예 1.4, 1.6) */
        letter-spacing: -0.6px;       /* 자간 (음수면 좁아짐: 예 -0.5px) */
        margin-bottom: 3px;            /* 항목 간 간격 */
        color: #1a1919ff;                   /* 글자 색상 */
    }

    .highlight-box h3, .highlight-box strong, .highlight-box b {
        font-size: 12pt !important; color: rgba(2, 37, 2, 1) !important;
        font-weight: bold; margin: 0; display: block; margin-bottom: 5px;
    }
    /* 수정 4 목차 스타일 : 대제목 녹색+크게, 그룹 단위 묶음 */
    .toc-group {
        margin-bottom: 12px; /* 기존 간격 유지 */
        break-inside: avoid;
        page-break-inside: avoid;
    }

    /* [수정] 점(Bullet) 제거를 위한 핵심 코드 */
    .toc-lvl-1, .toc-lvl-2, .toc-lvl-3 {
        list-style: none !important; 
    }

    .toc-item { 
        line-height: 1.8; 
        list-style: none; /* 안전장치 */
        border-bottom: 1px dotted #f3e1e1ff; /* 기존 점선 스타일 유지 */
    }
    
    .toc-lvl-1 { 
        color: #006400; /* 기존 녹색 유지 */
        font-weight: 900; 
        font-size: 13.5pt; /* 기존 폰트 크기 유지 */
        margin-top: 15px; /* 기존 상단 여백 유지 */
        margin-bottom: 5px; /* 기존 하단 여백 유지 */
        border-bottom: 2px solid #ccc; 
    }
    .toc-lvl-2 { 
        font-size: 10.5pt; 
        color: #333; 
        margin-left: 20px; /* 기존 들여쓰기 유지 */
        font-weight: normal; 
    }
    .toc-lvl-3 { 
        font-size: 10.5pt; 
        color: #666; 
        margin-left: 40px; /* 기존 들여쓰기 유지 */
    }

    /* [대목차 내부 스타일 보존] */
    .toc-lvl-1 .toc-number, 
    .toc-lvl-1 .toc-text {
        font-weight: 900;
        font-size: 1.2em;
        color: #006400;
    }
    
    .toc-lvl-1 .toc-number {
        float: left;
        margin-right: 14px; /* 기존 간격 유지 */
    }
    .toc-lvl-1 .toc-text {
        display: block;
        overflow: hidden;
    }

    /* [소목차 내부 스타일 보존] */
    .toc-lvl-2 .toc-number, .toc-lvl-3 .toc-number {
        font-weight: bold;
        color: #2c5282;
        margin-right: 11px; /* 기존 간격 유지 */
    }
    .toc-lvl-2 .toc-text, .toc-lvl-3 .toc-text {
        color: #4a5568;
        font-size: 1em;
    }

    /* [요약 페이지 전용 스타일 미세 조정] */
    .squeeze {
        line-height: 1.35 !important;
        letter-spacing: -0.5px !important;
        margin-bottom: 2px !important;
    }
    .squeeze-title {
        margin-bottom: 5px !important;
        padding-bottom: 2px !important;
    }


    /* 요약 페이지 안의 모든 P 태그에 대해 자간/행간을 좁힘 */
    #box-summary p, 
    #box-summary li {
        font-size: 10pt !important;      /* 본문보다 0.5pt~1pt 정도 작게 */
        line-height: 1.45 !important;    /* 줄 간격을 조금 더 촘촘하게 (기존 1.6) */
        letter-spacing: -0.04em !important; /* 자간을 미세하게 좁힘 */
        margin-bottom: 3px !important;   /* 문단 간 격을 줄임 */
        text-align: justify;             /* 양쪽 정렬 유지 */
    }

    /* 요약 페이지 제목 아래 간격도 조금 줄임 */
    #box-summary h1 {
        margin-bottom: 10px !important;
        padding-bottom: 5px !important;
    }
</style>
</head>
<body>

    <div id="raw-container">
        <div id="box-cover"></div>
        <div id="box-toc"></div>
        <div id="box-summary"></div>
        <div id="box-content"></div>
    </div>

    <template id="page-template">
        <div class="sheet">
            <div class="page-header"></div>
            <div class="body-content"></div>
            <div class="page-footer">
                <span class="rpt-title"></span>
                <span class="pg-num"></span>
            </div>
        </div>
    </template>

    <script>
        window.addEventListener("load", async () => {
            await document.fonts.ready; // 웹폰트 로딩 대기 (필수)
            // [Config] 297mm - 20mm(상) - 20mm(하) = 257mm ≈ 970px
            const CONFIG = { maxHeight: 970 }; 
            
            const rawContainer = document.getElementById('raw-container');
                if (rawContainer) {
                    rawContainer.innerHTML = rawContainer.innerHTML.replace(
                    /(<rect[^>]*?)\s+y="[^"]*"\s+([^>]*?y="[^"]*")/gi, 
                    "$1 $2"
                );
            }
            const raw = {
                cover: document.getElementById('box-cover'),
                toc: document.getElementById('box-toc'),            
                cover: document.getElementById('box-cover'),
                toc: document.getElementById('box-toc'),
                summary: document.getElementById('box-summary'),
                content: document.getElementById('box-content')
            };

            let globalPage = 1;
            let reportTitle = raw.cover.querySelector('h1')?.innerText || "Report";

            function cleanH1Text(text) {
                if (!text) return "";
                const parts = text.split("-");
                return parts[0].trim(); // 첫 번째 부분만 남기고 나머지는 버림
            }

            // [0] Sanitizer & Pre-processing (Integrity Preserved Version)
            function detox(node) {
                if (node.nodeType !== 1) return;

                // [Safety Check 1] SVG 내부는 절대 건드리지 않음 (차트 깨짐 방지)
                if (node.closest('svg')) return;

                // [Logic A] 클래스 속성 확인 및 변수 할당
                let cls = "";
                if (node.hasAttribute('class')) {
                    cls = node.getAttribute('class');
                }

                // [Logic B] 하이라이트 박스 감지 및 변환 (조건 정밀화)
                // 조건: 1. bg-, border-, box 중 하나라도 포함되어야 함
                //       2. 단, title-box(제목박스), toc-(목차), cover-(표지)는 절대 아니어야 함
                if ( (cls.includes('bg-') || cls.includes('border-') || cls.includes('box')) && 
                     !cls.includes('title-box') && 
                     !cls.includes('toc-') && 
                     !cls.includes('cover-') &&
                     !cls.includes('highlight-box') ) { // 이미 변환된 놈도 건드리지 않음
                    
                    // 1. 표준 클래스로 강제 교체
                    node.setAttribute('class', 'highlight-box atomic-block');
                    
                    // 2. 박스 내부 제목 스타일 초기화 (기존 스타일과의 충돌 방지)
                    const internalHeads = node.querySelectorAll('h3, h4, strong, b');
                    internalHeads.forEach(head => {
                        head.removeAttribute('style');
                        head.removeAttribute('class');
                    });
                    
                    // 3. 인라인 스타일 삭제 (Tailwind inline style 등 제거)
                    node.removeAttribute('style');
                    
                    // [중요] 여기서 return하면 안됨! 아래 공통 로직(표 테두리 등)도 타야 함.
                    // 대신, class는 이미 세팅했으므로 class 삭제 로직만 건너뛰게 플래그 변경
                    cls = 'highlight-box atomic-block'; 
                }

                // [Logic C] 일반 요소 세탁 (화이트리스트 유지)
                // 목차, 표지, 제목박스, 그리고 방금 변환된 하이라이트 박스는 살려둠
                if (node.hasAttribute('class')) {
                    // 위에서 cls 변수가 갱신되었을 수 있으므로 다시 확인하지 않고 기존 조건 활용
                    if (!cls.includes('toc-') && 
                        !cls.includes('cover-') && 
                        !cls.includes('highlight-') && 
                        !cls.includes('title-box') &&
                        !cls.includes('atomic-block')) {
                        
                        node.removeAttribute('class');
                    }
                }

                // [Logic D] 공통 정리 (인라인 스타일 삭제)
                // 단, 이미 변환된 박스는 위에서 지웠으니 중복 실행되어도 상관없음
                node.removeAttribute('style');
                
                // [Logic E] 표 테두리 강제 적용
                if (node.tagName === 'TABLE') node.border = "1";
                
                // [Logic F] 캡션 중복 텍스트 숨김 처리
                if (node.tagName === 'FIGURE') {
                    const internalTitles = node.querySelectorAll('h3, h4, .chart-title');
                    internalTitles.forEach(t => t.style.display = 'none');
                }
            }

            function getFlatNodes(element) {
                // [1] 목차(TOC) 처리 로직 (제목 생성 + 완벽한 그룹화)
                if(element.id === 'box-toc') {
                    // 1. 스타일 초기화
                    element.querySelectorAll('*').forEach(el => detox(el));
                    
                    // 2. 레벨 분석 (위의 formatTOC 실행)
                    formatTOC(element);

                    const tocNodes = [];

                    // [수정] 원본에 H1이 없으면 '목차' 타이틀 강제 생성
                    let title = element.querySelector('h1');
                    if (!title) {
                        title = document.createElement('h1');
                        title.innerText = "목차";
                        // 디자인 통일성을 위해 스타일 적용은 CSS에 맡김
                    }
                    tocNodes.push(title.cloneNode(true));

                    // 3. 그룹화 로직 (Flattened List -> Grouped Divs)
                    // 중첩이 엉망인 원본 무시하고, 모든 li를 긁어모음
                    const allLis = element.querySelectorAll('li');
                    let currentGroup = null;

                    allLis.forEach(li => {
                        const isLevel1 = li.classList.contains('toc-lvl-1');

                        // 대목차(Level 1)가 나오면 새로운 그룹 시작
                        if (isLevel1) {
                            // 이전 그룹이 있으면 저장
                            if (currentGroup) tocNodes.push(currentGroup);
                            
                            // 새 그룹 박스 생성
                            currentGroup = document.createElement('div');
                            currentGroup.className = 'toc-group atomic-block';
                            
                            // 내부 UL 생성 (들여쓰기 구조용)
                            const ulWrapper = document.createElement('ul');
                            ulWrapper.style.margin = "0";
                            ulWrapper.style.padding = "0";
                            currentGroup.appendChild(ulWrapper);
                        }

                        // 안전장치: 첫 시작이 소목차라 그룹이 없으면 하나 만듦
                        if (!currentGroup) {
                            currentGroup = document.createElement('div');
                            currentGroup.className = 'toc-group atomic-block';
                            const ulWrapper = document.createElement('ul');
                            ulWrapper.style.margin = "0";
                            ulWrapper.style.padding = "0";
                            currentGroup.appendChild(ulWrapper);
                        }

                        // 현재 그룹의 ul에 li 추가
                        currentGroup.querySelector('ul').appendChild(li.cloneNode(true));
                    });

                    // 마지막 그룹 저장
                    if (currentGroup) tocNodes.push(currentGroup);
                    
                    return tocNodes;
                }

                // [2] 본문(Body) 처리 로직 (기존 박스 보존 로직 유지)
                let nodes = [];
                Array.from(element.children).forEach(child => {
                    detox(child);

                    if (child.classList.contains('highlight-box')) {
                        child.querySelectorAll('h3, h4, strong, b').forEach(head => {
                            head.removeAttribute('style');
                            head.removeAttribute('class');
                        });
                        nodes.push(child.cloneNode(true));
                    }
                    else if(['DIV','SECTION','ARTICLE','MAIN'].includes(child.tagName)) {
                        nodes = nodes.concat(getFlatNodes(child));
                    } 
                    else if (['UL','OL'].includes(child.tagName)) {
                        Array.from(child.children).forEach((li, idx) => {
                            detox(li);
                            const w = document.createElement(child.tagName);
                            w.style.margin="0"; w.style.paddingLeft="20px";
                            if(child.tagName==='OL') w.start=idx+1;
                            const cloneLi = li.cloneNode(true);
                            cloneLi.querySelectorAll('*').forEach(el => detox(el));
                            w.appendChild(cloneLi);
                            nodes.push(w);
                        });
                    } else {
                        const clone = child.cloneNode(true);
                        detox(clone);
                        clone.querySelectorAll('*').forEach(el => detox(el));
                        nodes.push(clone);
                    }
                });
                return nodes;
            }

            // [Final Optimized Engine] Place -> Squeeze -> Check -> Split
            // 목적: 배치 즉시 자간을 줄여 2글자 고아를 방지하고, 공간을 확보하여 페이지 밀림을 막음
            function renderFlow(sectionType, sourceNodes) {
                if (!sourceNodes.length) return;
                
                let currentHeaderTitle = sectionType === 'toc' ? "목차" : (sectionType === 'summary' ? "요약" : reportTitle);
                
                let page = createPage(sectionType, currentHeaderTitle);
                let body = page.querySelector('.body-content');
                
                // 원본 노드 보존을 위해 큐에 담기
                let queue = [...sourceNodes];

                while (queue.length > 0) {
                    let node = queue.shift();
                    let clone = node.cloneNode(true);
                    
                    // [태그 판별]
                    let isH1 = clone.tagName === 'H1';
                    let isHeading = ['H2', 'H3'].includes(clone.tagName);
                    // LI도 텍스트로 취급하여 분할 대상에 포함
                    let isText = ['P', 'LI'].includes(clone.tagName) && !clone.classList.contains('atomic-block');
                    let isAtomic = ['TABLE', 'FIGURE', 'IMG', 'SVG'].includes(clone.tagName) || 
                                   clone.querySelector('table, img, svg') || 
                                   clone.classList.contains('atomic-block');

                    // [전처리] H1 텍스트 정제 ("-" 뒤 제거)
                    if (isH1 && clone.innerText.includes('-')) {
                        clone.innerText = clone.innerText.split('-')[0].trim();
                    }

                    // [Rule 1] H1 처리 (무조건 새 페이지)
                    if (isH1 && (sectionType === 'body' || sectionType === 'summary')) {
                        currentHeaderTitle = clone.innerText;
                        if (body.children.length > 0) {
                            page = createPage(sectionType, currentHeaderTitle);
                            body = page.querySelector('.body-content');
                        } else {
                            page.querySelector('.page-header').innerText = currentHeaderTitle;
                        }
                    }

                    // [Rule 2] Orphan Control (제목이 페이지 끝에 걸리는 것 방지)
                    if (isHeading) {
                        const spaceLeft = CONFIG.maxHeight - body.scrollHeight;
                        if (spaceLeft < 90) { 
                            page = createPage(sectionType, currentHeaderTitle);
                            body = page.querySelector('.body-content');
                        }
                    }

                    // ▼▼▼ [Step 1: 일단 배치 (Place)] ▼▼▼
                    body.appendChild(clone);

                    // ▼▼▼ [Step 2: 자간 최적화 (Squeeze Logic)] ▼▼▼
                    // 배치 직후, 자간을 줄여서 줄바꿈을 없앨 수 있는지 확인
                    // 대상: 10글자 이상인 텍스트 노드
                    if (isText && clone.innerText.length > 10) {
                        const originalHeight = clone.offsetHeight;
                        
                        // 1. 강력하게 줄여봄
                        clone.style.letterSpacing = "-1.0px";

                        // 2. 높이가 줄어들었는가? (줄바꿈이 사라짐 = Orphan 해결)
                        if (clone.offsetHeight < originalHeight) {
                            // 성공! 너무 빽빽하지 않게 -0.8px로 안착
                            clone.style.letterSpacing = "-0.8px";
                        } else {
                            // 실패! 줄여도 줄이 안 바뀌면 가독성을 위해 원상복구
                            clone.style.letterSpacing = "";
                        }
                    }
                    // ▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲

                    // [Rule 3] 넘침 감지 (Overflow Check)
                    if (body.scrollHeight > CONFIG.maxHeight) {
                        
                        // 3-1. 텍스트 분할 (Split) - LI 태그 포함
                        if (isText) {
                            body.removeChild(clone); // 일단 제거
                            
                            let textContent = node.innerText;
                            let tempP = node.cloneNode(false); // 태그 속성 유지 (li면 li, p면 p)
                            tempP.innerText = "";
                            
                            // 위에서 결정된 최적 자간 스타일 유지
                            if (clone.style.letterSpacing) tempP.style.letterSpacing = clone.style.letterSpacing;
                            
                            body.appendChild(tempP);

                            const words = textContent.split(' ');
                            let currentText = "";
                            
                            for (let i = 0; i < words.length; i++) {
                                let word = words[i];
                                let prevText = currentText;
                                currentText += (currentText ? " " : "") + word;
                                tempP.innerText = currentText;

                                // 단어 하나 추가했더니 넘쳤는가?
                                if (body.scrollHeight > CONFIG.maxHeight) {
                                    // 직전 상태(안 넘치는 상태)로 복구
                                    tempP.innerText = prevText;
                                    
                                    // [디자인 보정] 잘린 문단의 마지막 줄 양쪽 정렬
                                    tempP.style.textAlign = "justify";
                                    tempP.style.textAlignLast = "justify";
                                    
                                    // 남은 단어들을 다시 합쳐서 대기열 맨 앞으로
                                    let remainingText = words.slice(i).join(' ');
                                    let remainingNode = node.cloneNode(false);
                                    remainingNode.innerText = remainingText;
                                    
                                    queue.unshift(remainingNode);
                                    
                                    // 새 페이지 생성
                                    page = createPage(sectionType, currentHeaderTitle);
                                    body = page.querySelector('.body-content');
                                    
                                    // [중요] 새 페이지 갔으면 압축 플래그/스타일 초기화
                                    // 새 페이지에서는 다시 넉넉하게 시작해야 함
                                    body.style.lineHeight = "";
                                    body.style.letterSpacing = "";
                                    
                                    break; // for문 탈출
                                }
                            }
                        }

                        // 3-2. 표, 그림, 박스인 경우 -> 통째로 다음 장으로 이동
                        else {
                            body.removeChild(clone); // 일단 뺌

                            // [Gap Filling] 빈 공간 채우기
                            let spaceLeft = CONFIG.maxHeight - body.scrollHeight;
                            
                            // 공간이 50px 이상 있고, 앞에 글자가 이미 있을 때만 채우기 시도
                            if (body.children.length > 0 && spaceLeft > 50 && queue.length > 0) {
                                while(queue.length > 0) {
                                    let candidate = queue[0]; 
                                    if (['H1','H2','H3'].includes(candidate.tagName) || 
                                        candidate.classList.contains('atomic-block') ||
                                        candidate.querySelector('img, table')) break; 

                                    let filler = candidate.cloneNode(true);
                                    
                                    // 가져올 때도 최적화(Squeeze) 시도
                                    if(['P','LI'].includes(filler.tagName) && filler.innerText.length > 10) {
                                        const hBefore = filler.offsetHeight; // (가상)
                                        filler.style.letterSpacing = "-1.0px";
                                        // 실제 DOM에 붙여봐야 높이를 알 수 있으므로 일단 적용
                                    }

                                    body.appendChild(filler);

                                    if (body.scrollHeight <= CONFIG.maxHeight) {
                                        // 들어갔으면 확정하고 대기열 제거
                                        // 최적화 스타일 유지 (-1.0px -> -0.8px 조정 등은 생략해도 무방하나 디테일 원하면 추가 가능)
                                        if(filler.style.letterSpacing === "-1.0px") filler.style.letterSpacing = "-0.8px";
                                        queue.shift(); 
                                    } else {
                                        body.removeChild(filler);
                                        break; 
                                    }
                                }
                            }

                            // 2. 이미지 배치 (수정된 핵심 로직)
                            // [버그 수정] 현재 페이지가 비어있지 않을 때만 새 페이지 생성!
                            if (body.children.length > 0) {
                                page = createPage(sectionType, currentHeaderTitle);
                                body = page.querySelector('.body-content');
                            }
                            
                            // 이미지를 붙임
                            body.appendChild(clone);
                            
                            // [Smart Fit] 넘치면 축소 (기존 유지)
                            if (isAtomic && body.scrollHeight > CONFIG.maxHeight) {
                                const currentH = clone.offsetHeight;
                                const overflow = body.scrollHeight - CONFIG.maxHeight;
                                body.removeChild(clone);

                                if (overflow > 0 && overflow < (currentH * 0.15)) {
                                    clone.style.transform = "scale(0.85)";
                                    clone.style.transformOrigin = "top center";
                                    clone.style.marginBottom = `-${currentH * 0.15}px`;
                                    body.appendChild(clone);
                                } else {
                                    body.appendChild(clone); // 너무 크면 그냥 둠
                                }
                            }
                        }
                    }
                }
            }

            function createPage(type, headerTitle) {
                const tpl = document.getElementById('page-template');
                const clone = tpl.content.cloneNode(true);
                const sheet = clone.querySelector('.sheet');
                
                if (type === 'cover') {
                    sheet.innerHTML = "";
                    const title = raw.cover.querySelector('h1')?.innerText || "Report";
                    const sub = raw.cover.querySelector('h2')?.innerText || "";
                    const pTags = raw.cover.querySelectorAll('p');
                    const infos = pTags.length > 0 ? Array.from(pTags).map(p => p.innerText).join(" / ") : "";
                    
                    // [표지 스타일] 테두리 제거 및 중앙 정렬
                    sheet.innerHTML = `
                        <div style="position:absolute; top:20mm; right:20mm; text-align:right; font-size:11pt; color:#666;">${infos}</div>
                        <div style="display:flex; flex-direction:column; justify-content:center; align-items:center; height:100%; text-align:center; width:100%;">
                            <div style="width:85%;">
                                <div style="font-size:32pt; font-weight:900; color:var(--primary); line-height:1.2; margin-bottom:30px; word-break:keep-all;">${title}</div>
                                <div style="font-size:20pt; font-weight:300; color:#444; word-break:keep-all;">${sub}</div>
                            </div>
                        </div>`;
                } else {
                    // ... (나머지 페이지 생성 로직 기존 유지) ...
                    clone.querySelector('.page-header').innerText = headerTitle;
                    clone.querySelector('.rpt-title').innerText = reportTitle;
                    if (type !== 'toc') clone.querySelector('.pg-num').innerText = `- ${globalPage++} -`;
                    else clone.querySelector('.pg-num').innerText = "";
                }
                document.body.appendChild(sheet);
                return sheet;
            }

            createPage('cover');
            if(raw.toc) renderFlow('toc', getFlatNodes(raw.toc));

            // [요약 페이지 지능형 맞춤 로직 (Smart Squeeze)]
            const summaryNodes = getFlatNodes(raw.summary);
            
            // 1. 가상 공간에 미리 렌더링하여 높이 측정
            const tempBox = document.createElement('div');
            tempBox.style.width = "210mm"; 
            tempBox.style.position = "absolute"; 
            tempBox.style.visibility = "hidden";
            tempBox.id = 'box-summary'; // CSS 적용
            document.body.appendChild(tempBox);
            
            // 노드 복제하여 주입
            summaryNodes.forEach(node => tempBox.appendChild(node.cloneNode(true)));
            
            // 2. 높이 분석 (Smart Runt Control)
            const totalHeight = tempBox.scrollHeight;
            const pageHeight = CONFIG.maxHeight; // 1페이지 가용 높이 (약 970px)
            const lastPart = totalHeight % pageHeight; 

            // [조건] 넘친 양이 100px 미만일 때 압축
            if (totalHeight > pageHeight && lastPart > 0 && lastPart < 180) { 
                summaryNodes.forEach(node => {
                    if(node.nodeType === 1) { 
                        node.classList.add('squeeze');
                        if(node.tagName === 'H1') node.classList.add('squeeze-title');
                        
                        // [추가] P, LI 태그에 더 강력한 인라인 스타일 강제 주입 (폰트 축소 포함)
                        if(node.tagName === 'P' || node.tagName === 'LI') {
                             node.style.fontSize = "9.5pt"; 
                             node.style.lineHeight = "1.4"; 
                             node.style.letterSpacing = "-0.8px";
                        }
                    }
                });
            }
            // 뒷정리
            document.body.removeChild(tempBox);
            // 3. 렌더링 실행
            renderFlow('summary', summaryNodes);

            // ▼▼▼ [기존 유지] 본문 렌더링 및 마무리 작업 ▼▼▼
            renderFlow('body', getFlatNodes(raw.content));
            
            // 긴 제목 자동 축소 (기존 기능 유지)
            document.querySelectorAll('.sheet h1, .sheet h2').forEach(el => {
                let fs = 100;
                while(el.scrollWidth > el.clientWidth && fs > 50) { el.style.fontSize = (--fs)+"%"; }
            });

            // ▼▼▼▼▼ [수정된 핵심 로직: 통합 자간 조정] ▼▼▼▼▼
            // 변경점 1: 'li' 태그 포함
            // 변경점 2: 표, 그림 내부 텍스트 제외
            // 변경점 3: 글자수 제한 완화 (10자 이상이면 검사)
            const allTextNodes = document.querySelectorAll('.sheet .body-content p, .sheet .body-content li');
            
            allTextNodes.forEach(el => {
                // 1. [제외 대상] 표(table), 그림(figure), 차트 내부는 건드리지 않음
                if (el.closest('table') || el.closest('figure') || el.closest('.chart')) return;

                // 2. [최소 길이] 10자 미만은 무시
                if (el.innerText.trim().length < 10) return;

                // 3. [테스트]
                const originH = el.offsetHeight;
                const originSpacing = el.style.letterSpacing;
                el.style.fontSize = "12pt";

                // 강력하게 당겨봄
                el.style.letterSpacing = "-1.4px"; 
                
                const newH = el.offsetHeight;

                // 성공(높이 줄어듦) 시
                if (newH < originH) {
                    el.style.letterSpacing = "-1.0px"; // 적당히 안착
                } 
                else {
                    el.style.letterSpacing = originSpacing; // 원상복구
                }
            });
            // ▲▲▲▲▲ [수정 끝] ▲▲▲▲▲

            // 제목 자동 축소 (중복 실행 방지를 위해 제거해도 되지만, 안전하게 둠)
            document.querySelectorAll('.sheet h1, .sheet h2').forEach(el => {
                let fs = 100;
                while(el.scrollWidth > el.clientWidth && fs > 50) { el.style.fontSize = (--fs)+"%"; }
            });

            const pages = document.querySelectorAll('.sheet'); // .page 대신 .sheet로 수정하여 정확도 높임
            if (pages.length >= 2) {
                const lastSheet = pages[pages.length - 1];
                const prevSheet = pages[pages.length - 2];
                // 커버나 목차가 아닐때만 진행
                if(lastSheet.querySelector('.rpt-title')) {
                    const lastBody = lastSheet.querySelector('.body-content');
                    const prevBody = prevSheet.querySelector('.body-content');

                    // 마지막 페이지 내용이 3줄(약 150px) 이하인가?
                    if (lastBody.scrollHeight < 150 && lastBody.innerText.trim().length > 0) {
                        prevBody.style.lineHeight = "1.3"; // 앞 페이지 압축
                        prevBody.style.paddingBottom = "0px";
                        
                        const contentToMove = Array.from(lastBody.children);
                        contentToMove.forEach(child => prevBody.appendChild(child.cloneNode(true)));

                        if (prevBody.scrollHeight <= CONFIG.maxHeight + 5) {
                            lastSheet.remove(); // 성공 시 마지막 장 삭제
                        } else {
                            // 실패 시 원상 복구
                            for(let i=0; i<contentToMove.length; i++) prevBody.lastElementChild.remove();
                            prevBody.style.lineHeight = "";
                        }
                    }
                }
            }
            // 원본 데이터 삭제
            const rawContainer = document.getElementById('raw-container');
            if(rawContainer) rawContainer.remove();
        });
    </script>
</body>
</html>


⚠️ [최종 경고 - 출력 직전 필수 확인]
1. 원본의 모든 텍스트가 100% 포함되었는가?
2. "..." 또는 요약된 문장이 없는가?
3. 생략된 문단이 단 하나도 없는가?

위 3가지 중 하나라도 위반 시, 출력을 중단하고 처음부터 다시 작성하십시오.
원본 텍스트 글자 수와 출력 텍스트 글자 수가 동일해야 합니다.