deel-local-cli 1.20.13 → 2.0.1

package/src/tools/pdf.js

@@ -122,6 +122,9 @@ function 괄호글자읽기(b, i) {
     }
     if (c === 0x28) 깊이 += 1;
     if (c === 0x29) { 깊이 -= 1; if (!깊이) { i += 1; break; } }
+    // 역슬래시 없는 줄끝(CR · CRLF · LF)은 LF 하나로 읽는다 (PDF 규격 7.3.4.2 · 2.0.0 6회차 문서6좁).
+    // 그대로 실으면 윈도에서 만든 PDF 의 글에 CR 이 섞여, 줄이 두 번 바뀌거나 CR 이 글자로 남는다.
+    if (c === 0x0d) { 조각.push(0x0a); i += b[i + 1] === 0x0a ? 2 : 1; continue; }
     조각.push(c); i += 1;
   }
   return [{ 바이트: Buffer.from(조각) }, i];
@@ -263,13 +266,26 @@ function 사전읽기(b, i, 흐름풀기) {
  * 3. 걸러내기 (filters)
  * ──────────────────────────────────────────────────────────────────────── */
 
-/** 앞자리 예측(PNG predictor). xref 흐름과 그림에 쓴다. */
+/**
+ * 앞자리 예측(PNG predictor). xref 흐름과 그림에 쓴다.
+ *
+ * @returns {Buffer|null}  null 이면 **되돌릴 수 없는 자료다** — 빈 자료로 넘기지 않는다.
+ */
 function 예측되돌리기(자료, { 예측, 칸수, 색수, 비트 }) {
   if (!예측 || 예측 < 2) return 자료;
   if (예측 === 2) return 자료;                   // TIFF 예측 — 흔치 않고 xref 엔 안 쓴다
   const 한칸 = Math.ceil((색수 * 비트) / 8);
   const 한줄 = Math.ceil((색수 * 비트 * 칸수) / 8);
   const 줄수 = Math.floor(자료.length / (한줄 + 1));
+  /*
+   * 한 줄도 못 채우는 자료는 되돌린 것이 아니라 **못 되돌린 것**이다.
+   *
+   * 여태는 줄수 0 으로 빈 버퍼를 지어 ok 로 올려 보냈다. 그러면 그 쪽은
+   * 「글이 없는 쪽」 이 되어 스캔본과 구분이 안 되고, Columns 가 틀린 것뿐인데
+   * 사람은 원본을 의심한다. 게다가 쓰지도 않을 앞줄 버퍼를 먼저 잡았는데,
+   * Columns 가 큰 값이면 그것만으로 1GB 다 (규격이 허락하는 최대치다).
+   */
+  if (줄수 < 1) return null;
   const 나온것 = Buffer.alloc(줄수 * 한줄);
   let 앞줄 = Buffer.alloc(한줄);
   for (let r = 0; r < 줄수; r += 1) {
@@ -346,30 +362,69 @@ function 되풀이풀기(buf) {
   return Buffer.from(나온것);
 }
 
-/** zlib 머리가 깨진 흐름이 흔해서, 날것(raw)으로도 한 번 더 해 본다. */
+/**
+ * zlib 머리가 깨진 흐름이 흔해서, 날것(raw)으로도 한 번 더 해 본다.
+ *
+ * @returns {{자료:Buffer, 잘림?:true}|null}  잘림 이 붙었으면 **끝까지 못 풀었다.**
+ */
 function 부풀리기(buf) {
-  try { return inflateSync(buf); } catch { /* 아래로 */ }
-  try { return inflateRawSync(buf); } catch { /* 아래로 */ }
+  const 틀 = { maxOutputLength: 흐름풀기상한 };
+  try { return { 자료: inflateSync(buf, 틀) }; } catch (e) { if (넘쳤나(e)) return { 넘침: true }; }
+  try { return { 자료: inflateRawSync(buf, 틀) }; } catch (e) { if (넘쳤나(e)) return { 넘침: true }; }
   // 앞머리에 쓰레기가 붙은 것들 — zlib 머리(0x78)를 찾아 다시.
+  const 머리자리 = [];
   for (let i = 1; i < Math.min(buf.length, 32); i += 1) {
     if (buf[i] === 0x78) {
-      try { return inflateSync(buf.subarray(i)); } catch { /* 다음 */ }
+      머리자리.push(i);
+      try { return { 자료: inflateSync(buf.subarray(i), 틀) }; } catch (e) { if (넘쳤나(e)) return { 넘침: true }; }
     }
   }
   /*
-   * 끝이 잘린 흐름은 통째로 버리지 않는다.
+   * ── 반쯤 푼 것을 다 푼 척했다 ──────────────────────────────────────
    *
-   * 마지막 쪽이 잘린 PDF 가 실제로 있다. 여기서 빈 것을 돌려주면 그 쪽이
-   * 「글 없는 쪽」이 되어 스캔본과 구분이 안 된다. 부풀린 데까지는 건진다.
+   * 끝이 잘린 흐름을 통째로 버리지 않는 것은 그대로 둔다 — 마지막 쪽이 잘린
+   * PDF 가 실제로 있고, 여기서 빈 것을 돌려주면 그 쪽이 「글 없는 쪽」이 되어
+   * 스캔본과 구분이 안 된다. 부풀린 데까지는 건지는 것이 맞다.
+   *
+   * 틀린 것은 **건졌다는 말을 안 한 것**이다. Z_SYNC_FLUSH 로 반 토막을
+   * 받아 놓고 성공과 똑같은 모양으로 돌려주니, 위에서는 온전한 흐름과
+   * 구분할 길이 없었다. 그래서 표 절반이 없는 쪽이 「다 읽은 쪽」으로
+   * 올라갔고, 모델은 없는 줄 알고 답했다.
+   *
+   * 이제 지키는 규칙: 반 토막이면 반 토막이라고 같이 돌려준다.
    */
   try {
-    return inflateSync(buf, { finishFlush: Z_SYNC_FLUSH });
-  } catch { /* 아래로 */ }
+    return { 자료: inflateSync(buf, { ...틀, finishFlush: Z_SYNC_FLUSH }), 잘림: true };
+  } catch (e) { if (넘쳤나(e)) return { 넘침: true }; }
   try {
-    return inflateRawSync(buf, { finishFlush: Z_SYNC_FLUSH });
-  } catch { return null; }
+    return { 자료: inflateRawSync(buf, { ...틀, finishFlush: Z_SYNC_FLUSH }), 잘림: true };
+  } catch (e) { if (넘쳤나(e)) return { 넘침: true }; }
+  /*
+   * 앞머리 쓰레기와 끝 잘림은 겹쳐서 온다 — 둘 다 「저장하다 만 파일」의 흔적이다.
+   *
+   * 위 두 갈래(쓰레기머리 · 반 토막)를 따로따로만 해 봐서, 겹친 흐름은 반 토막도
+   * 못 건지고 null 로 버려졌다. 쓰레기머리 하나만 붙어도, 잘리기만 해도 건지던
+   * 흐름이 둘이 겹치면 통째로 사라지는 것은 앞뒤가 안 맞는다.
+   */
+  for (const i of 머리자리) {
+    try {
+      return { 자료: inflateSync(buf.subarray(i), { ...틀, finishFlush: Z_SYNC_FLUSH }), 잘림: true };
+    } catch (e) { if (넘쳤나(e)) return { 넘침: true }; }
+  }
+  return null;
 }
 
+/*
+ * 흐름 하나를 풀어 담는 상한 (2.0.0 6회차 문서6).
+ *
+ * 상한 없이 풀었더니 4.6MB 짜리 PDF 한 장(1GiB 공백을 눌러 담은 흐름 하나)에 최고 RSS 가 2GB 를 넘었다 —
+ * 그런 흐름 몇 개면 deel 이 메모리 부족으로 죽는다. PDF 는 남이 보낸 바이트다. 글 흐름·글꼴 표·xref 는
+ * 이 크기에 한참 못 미친다. 넘으면 끝까지 풀지 않고 그 까닭을 쪽의 「못 읽은 까닭」 으로 올린다.
+ * (zip.js 의 풀기총상한 과 같은 생각이다.)
+ */
+const 흐름풀기상한 = 64 * 1024 * 1024;
+const 넘쳤나 = (e) => e?.code === 'ERR_BUFFER_TOO_LARGE';
+
 /** 못 푸는 걸개를 만나면 이름을 돌려준다 — 「왜 안 읽혔나」에 그대로 쓴다. */
 export function 흐름풀기(흐름, 풀기) {
   if (!흐름?.날것) return { ok: false, 왜: '흐름이 아닙니다' };
@@ -377,14 +432,33 @@ export function 흐름풀기(흐름, 풀기) {
   let 자료 = 흐름.날것;
   const 걸개들 = [].concat(풀기(사전.Filter) ?? []).map((f) => 풀기(f)).filter(Boolean);
   const 맞춤들 = [].concat(풀기(사전.DecodeParms) ?? 풀기(사전.DP) ?? []);
+  let 잘렸나 = false;   // 끝까지 못 푼 흐름 — ok 로 돌려주더라도 이 표는 들고 간다
 
   for (let i = 0; i < 걸개들.length; i += 1) {
     const 이름 = 걸개들[i]?.이름;
-    const 맞춤 = 풀기(맞춤들[i]) ?? (걸개들.length === 1 ? 풀기(맞춤들[0]) : null) ?? {};
+    /*
+     * DecodeParms 가 배열이 아니라 **사전 하나**로 적힌 파일이 흔하다.
+     *
+     * 걸개가 하나면 말이 되는데, 걸개가 둘일 때 그 사전을 자리(i)로 짝지어
+     * 첫 걸개에 붙이면 아직 눌려 있는 바이트에 예측을 되돌리게 되어 흐름이
+     * 통째로 깨졌다 — `/Filter [/ASCIIHexDecode /FlateDecode]` 에 예측 사전
+     * 하나를 적은 흔한 꼴이 그대로 「압축을 못 풀었습니다」가 됐다.
+     *
+     * 규격상 맞춤을 받는 걸개는 Flate·LZW 뿐이다(ASCII85·ASCIIHex·RunLength 는
+     * 받는 맞춤이 없다). 그러니 짝지을 수 없는 사전 하나는 **맞춤을 받는 걸개**
+     * 것이다.
+     */
+    const 맞춤받나 = 이름 === 'FlateDecode' || 이름 === 'Fl' || 이름 === 'LZWDecode' || 이름 === 'LZW';
+    const 짝 = 맞춤들.length < 걸개들.length ? (맞춤받나 ? 맞춤들[0] : null) : 맞춤들[i];
+    const 맞춤 = 풀기(짝) ?? {};
     if (이름 === 'FlateDecode' || 이름 === 'Fl') {
       const 푼것 = 부풀리기(자료);
+      if (푼것?.넘침) {
+        return { ok: false, 왜: `풀면 ${흐름풀기상한 / 1024 / 1024}MB 를 넘는 흐름이라 풀지 않았습니다 — 압축 폭탄일 수 있습니다` };
+      }
       if (!푼것) return { ok: false, 왜: '압축을 못 풀었습니다' };
-      자료 = 푼것;
+      if (푼것.잘림) 잘렸나 = true;
+      자료 = 푼것.자료;
     } else if (이름 === 'ASCII85Decode' || 이름 === 'A85') 자료 = 아스키85풀기(자료);
     else if (이름 === 'ASCIIHexDecode' || 이름 === 'AHx') 자료 = 아스키16풀기(자료);
     else if (이름 === 'RunLengthDecode' || 이름 === 'RL') 자료 = 되풀이풀기(자료);
@@ -395,15 +469,28 @@ export function 흐름풀기(흐름, 풀기) {
     }
     const 예측 = 풀기(맞춤?.Predictor);
     if (예측 && 예측 > 1) {
-      자료 = 예측되돌리기(자료, {
-        예측,
-        칸수: 풀기(맞춤.Columns) ?? 1,
-        색수: 풀기(맞춤.Colors) ?? 1,
-        비트: 풀기(맞춤.BitsPerComponent) ?? 8,
-      });
+      const 칸수 = 풀기(맞춤.Columns) ?? 1;
+      const 색수 = 풀기(맞춤.Colors) ?? 1;
+      const 비트 = 풀기(맞춤.BitsPerComponent) ?? 8;
+      /*
+       * 남이 보낸 수를 그대로 크기로 쓰지 않는다. Columns 가 이름(`/x`)이거나 Colors 가 음수면
+       * 예측되돌리기 의 `Buffer.alloc` 이 RangeError 를 던졌고, 그게 readPdf **밖으로** 나와
+       * 멀쩡한 다른 쪽까지 통째로 못 읽었다. 규격이 허락하는 값이 아니면 이 흐름만 못 푼 것이다.
+       * (6회차 Gemini 피디에프6c 를 재다 찾음)
+       */
+      const 성한수 = (n, 큰것) => Number.isInteger(n) && n >= 1 && n <= 큰것;
+      if (!성한수(칸수, 1 << 24) || !성한수(색수, 32) || ![1, 2, 4, 8, 16].includes(비트)) {
+        const 보임 = (v) => (v && typeof v === 'object' && v.이름 ? `/${v.이름}` : String(v));
+        return { ok: false, 왜: `예측 설정(DecodeParms)이 망가져 풀지 않았습니다 — Columns ${보임(칸수)} · Colors ${보임(색수)} · BitsPerComponent ${보임(비트)}` };
+      }
+      const 편자료 = 예측되돌리기(자료, { 예측, 칸수, 색수, 비트 });
+      if (!편자료) {
+        return { ok: false, 왜: `예측(Predictor ${예측})을 되돌릴 자료가 모자랍니다 — ${자료.length}바이트로는 한 줄(${Math.ceil((색수 * 비트 * 칸수) / 8) + 1}바이트)도 못 채웁니다` };
+      }
+      자료 = 편자료;
     }
   }
-  return { ok: true, 자료 };
+  return 잘렸나 ? { ok: true, 자료, 잘림: true } : { ok: true, 자료 };
 }
 
 /* ────────────────────────────────────────────────────────────────────────
@@ -425,7 +512,8 @@ class 문서 {
     this.자리 = new Map();          // 객체번호 → 파일 위치
     this.푼것 = new Map();          // 객체번호 → 읽어 둔 값
     this.묶음속 = new Map();        // 객체번호 → ObjStm 안에서 읽은 값
-    this.xref정함 = new Set();      // 최신 xref 가 자리를 정해 준 객체 (옛 판이 못 덮는다)
+    this.xref정함 = new Set();      // 최신 xref 가 「낱개로 여기 있다」 고 정해 준 객체
+    this.묶음자리 = new Map();      // 객체번호 → 그 객체가 든 ObjStm 번호 (최신 xref 가 정한 것)
     this.trailer = {};
     this.훑기();
     this.xref읽기();
@@ -453,16 +541,34 @@ class 문서 {
   /**
    * xref 가 말하는 자리를 받아 적는다.
    *
-   * xref 는 **최신 판부터** 거슬러 읽는다(startxref → /Prev). 그래서 한 번
-   * 정해진 객체를 나중에(= 더 옛 판에서) 다시 적으면 안 된다. 증분 저장한
-   * PDF 는 고친 객체가 파일 뒤에 새로 붙고 옛것이 그대로 남아 있는데, 옛
-   * 자리로 덮으면 **고치기 전 값을 읽는다** — 폼에 채운 값이 빈칸으로,
+   * ── 어느 판(generation)이 이기나 — 규칙 하나 ──────────────────────────
+   *
+   * **최신 판이 이긴다.** 최신이 어느 것인지는 둘로 안다.
+   *
+   *   · xref 가 그 객체를 말하면 — xref 는 **최신 판부터** 거슬러 읽으니
+   *     (startxref → /Prev) **먼저 정해진 것**이 최신이다. 낱개든 묶음(ObjStm)
+   *     이든 한 번 정해지면 더 옛 판이 못 덮는다.
+   *   · 최신 xref 가 그 객체를 모르면 — 증분 저장은 파일 **뒤에** 붙으니
+   *     최신 xref 보다 뒤에 있는 진짜 객체가 나중 판이다.
+   *
+   * 옛 자리로 덮으면 **고치기 전 값을 읽는다** — 폼에 채운 값이 빈칸으로,
    * 고친 금액이 옛 금액으로 돌아간다. 빈 글은 보이지만 옛 글은 안 보인다.
+   * 이 규칙은 여기와 xref흐름읽기 · 묶음펼치기 세 자리가 **같이** 지켜야 한다.
    */
   자리정하기(번호, 자리) {
     if (this.xref정함.has(번호)) return;
+    /*
+     * 최신 xref 가 「이 객체는 묶음 안에 있다」 고 정한 것을 더 옛 판의 낱개
+     * 자리가 덮으면 안 된다. 자리는 안전망으로 적어만 둔다 — 묶음을 못 펼치면
+     * 그거라도 읽어야 하니까. 읽을 때는 묶음 쪽을 먼저 본다(풀기).
+     */
+    if (this.묶음자리.has(번호)) {
+      if (!this.자리.has(번호)) this.자리.set(번호, 자리);
+      return;
+    }
     // 훑기가 찾은 자리를 못 믿을 때만 xref 를 쓴다. 둘 다 있으면 그 자리에
-    // 진짜 `N obj` 가 있는 쪽을 고른다.
+    // 진짜 `N obj` 가 있는 쪽을 고른다. (xref 가 아예 모르는 객체는 아래
+    // 덧붙은판되찾기 가 xref 를 다 읽은 뒤에 되돌린다.)
     if (this.진짜객체인가(자리, 번호)) {
       this.자리.set(번호, 자리);
       this.xref정함.add(번호);
@@ -473,22 +579,29 @@ class 문서 {
 
   /** ② xref 를 따라가며 trailer 를 모은다. */
   xref읽기() {
+    const 훑은자리 = new Map(this.자리);      // xref 가 덮기 전의 훑기 결과
     const s = this.b.toString('latin1');
     const 끝 = s.lastIndexOf('startxref');
     let 자리 = 끝 >= 0 ? Number((s.slice(끝 + 9, 끝 + 40).match(/\d+/) ?? [])[0]) : NaN;
     const 봤다 = new Set();
     let 걸음 = 0;
+    let xref끝 = -1;                          // 본 xref 칸 중 파일에서 가장 뒤에 있는 것
     while (Number.isInteger(자리) && 자리 >= 0 && 자리 < this.b.length && !봤다.has(자리) && 걸음 < 64) {
       봤다.add(자리); 걸음 += 1;
+      if (자리 > xref끝) xref끝 = 자리;
       const t = this.xref한칸(자리);
       if (!t) break;
       // 먼저 만난 것이 최신이다 — 이미 있는 열쇠는 안 덮는다.
       for (const [k, v] of Object.entries(t)) if (!(k in this.trailer)) this.trailer[k] = v;
       const 다음 = typeof t.Prev === 'number' ? t.Prev : null;
       // 혼합 파일(XRefStm)은 표와 흐름이 같이 있다.
-      if (typeof t.XRefStm === 'number' && !봤다.has(t.XRefStm)) this.xref한칸(t.XRefStm);
+      if (typeof t.XRefStm === 'number' && !봤다.has(t.XRefStm)) {
+        if (t.XRefStm > xref끝) xref끝 = t.XRefStm;
+        this.xref한칸(t.XRefStm);
+      }
       자리 = 다음;
     }
+    this.덧붙은판되찾기(훑은자리, xref끝);
     if (!this.trailer.Root) {
       // trailer 를 못 찾았으면 카탈로그를 직접 찾는다.
       // `[^>]` 로 막으면 카탈로그 앞에 속사전(`<< … >>`)이 하나라도 있으면
@@ -499,6 +612,30 @@ class 문서 {
     }
   }
 
+  /**
+   * **어떤 xref 도 모르는** 객체를 되찾는다 — 마지막 xref 보다 뒤에 붙은 것들.
+   *
+   * 증분 저장은 고친 객체를 파일 뒤에 덧붙이는데, 새 xref 를 못 붙이고 끊긴
+   * 파일이 있다(저장하다 멈춘 것, 잘라 붙인 것). 그때 xref 는 옛 자리만 알고,
+   * 코드는 그 자리에 진짜 객체가 있다는 이유로 무조건 덮어써 **고치기 전 값**을
+   * 읽었다 — 「NEW price 2000」 자리에 「OLD price 1000」 이 나오는데 아무 말도 없다.
+   *
+   * 자리 한 칸씩 비교하지 않고 **xref 를 다 읽은 뒤** 한 번에 보는 것이 요령이다.
+   * 선형화(linearized)한 파일은 맨 끝 startxref 가 **파일 앞머리**의 첫쪽 xref 를
+   * 가리켜서, 「최신 xref 보다 뒤면 새 판」 으로 재면 거의 모든 객체가 걸린다.
+   * 그러면 본문에 `3 0 obj` 라고 적힌 문서를 xref 가 바로잡아 주던 길이 막힌다.
+   * 여기서 견주는 것은 **본 xref 칸 중 가장 뒤엣것**이라 그 함정을 안 밟는다.
+   */
+  덧붙은판되찾기(훑은자리, xref끝) {
+    if (!(xref끝 >= 0)) return;
+    for (const [번호, 자리] of 훑은자리) {
+      if (자리 <= xref끝 || !this.진짜객체인가(자리, 번호)) continue;
+      this.자리.set(번호, 자리); this.xref정함.add(번호);
+      this.묶음자리.delete(번호);              // 뒤에 낱개로 붙은 것이 묶음보다 새 판이다
+      this.푼것.delete(번호);                  // 옛 자리로 읽어 둔 것이 있으면 버린다
+    }
+  }
+
   /** xref 한 칸 — 고전 표이거나 흐름이다. trailer 사전을 돌려준다. */
   xref한칸(자리) {
     const 앞 = 건너뛰기(this.b, 자리);
@@ -576,10 +713,9 @@ class 문서 {
         }
         const 갈래 = 밭[0] === null ? 1 : 밭[0];
         if (갈래 === 1) this.자리정하기(번호, 밭[1]);
-        else if (갈래 === 2 && !this.xref정함.has(번호)) {
-          // 여기도 최신 판이 이긴다 — 옛 ObjStm 이 고친 객체를 덮으면 안 된다.
-          this.묶음자리 = this.묶음자리 ?? new Map();
-          if (!this.묶음자리.has(번호)) this.묶음자리.set(번호, 밭[1]);
+        else if (갈래 === 2 && !this.xref정함.has(번호) && !this.묶음자리.has(번호)) {
+          // 여기도 같은 규칙이다 — 먼저 정해진 판이 최신이니 옛 ObjStm 이 못 덮는다.
+          this.묶음자리.set(번호, 밭[1]);
         }
         번호 += 1;
       }
@@ -597,12 +733,24 @@ class 문서 {
 
   /** ③ 객체 흐름을 펼친다. 여기 든 객체는 파일에 낱개로 없다. */
   묶음펼치기() {
-    const 볼것 = new Set(this.묶음자리 ? [...this.묶음자리.values()] : []);
-    // 훑기로 찾은 것 중 ObjStm 도 마저 본다 (xref 가 없거나 틀린 파일).
+    /*
+     * 볼 차례가 곧 판 차례다 — 먼저 담은 값을 안 덮으니, **최신을 먼저** 봐야 한다.
+     *
+     *   ① 최신 xref 가 짚어 준 묶음 (거슬러 읽었으니 앞이 최신이다)
+     *   ② 훑기로 찾은 묶음 — 이건 xref 를 못 믿는 파일이다. 그때 최신을 가르는
+     *      것은 파일 안 자리뿐이니 **뒤에 있는 것부터** 본다 (증분 저장은 뒤에 붙는다).
+     *
+     * 앞서는 ②를 훑기가 만난 차례(= 대개 옛것부터)로 봐서, 옛 묶음이 먼저
+     * 들어가 새 묶음의 고친 값을 막았다.
+     */
+    const 볼것 = new Set(this.묶음자리.values());
+    const 훑은묶음 = [];
     for (const [번호] of this.자리) {
       const v = this.낱개읽기(번호);
-      if (v?.사전?.Type?.이름 === 'ObjStm') 볼것.add(번호);
+      if (v?.사전?.Type?.이름 === 'ObjStm') 훑은묶음.push(번호);
     }
+    훑은묶음.sort((a, b) => (this.자리.get(b) ?? 0) - (this.자리.get(a) ?? 0));
+    for (const 번호 of 훑은묶음) 볼것.add(번호);
     for (const 번호 of 볼것) {
       const 흐름 = this.낱개읽기(번호);
       if (!흐름?.날것) continue;
@@ -829,14 +977,19 @@ export function 유니코드표읽기(글) {
     for (const p of 몸.matchAll(/<([0-9A-Fa-f]+)>\s*<([0-9A-Fa-f]+)>\s*<([0-9A-Fa-f]+)>/g)) {
       const 시작 = 열여섯값(p[1]);
       const 끝 = 열여섯값(p[2]);
-      const 첫 = 열여섯글자(p[3]);
       코드폭.add(Math.ceil(p[1].length / 2));
       if (시작 === null || 끝 === null || 끝 < 시작 || 끝 - 시작 > 65535) continue;
-      if (!첫) continue;                        // `<0000>` 에서 시작하는 범위 — 셀 밑자리가 없다
-      const 밑 = 첫.charCodeAt(첫.length - 1);
+      /*
+       * 밑자리는 **마지막 네 자리 16진 값**에서 바로 읽는다 (2.0.0 6회차 문서6). 글로 바꾼 뒤 끝 글자를
+       * 봤더니 `<0000>` 은 NUL 을 빼느라 빈 글이 되어 범위를 통째로 건너뛰었다 — `<0000> <00FF> <0000>`
+       * 같은 0 기준 표를 쓰는 글꼴은 글이 한 자도 안 나왔다. 0 번 글자(NUL)는 여전히 안 싣는다.
+       */
+      const 날 = p[3].length % 4 ? p[3].padStart(p[3].length + 4 - (p[3].length % 4), '0') : p[3];
+      const 앞글 = 열여섯글자(날.slice(0, -4));
+      const 밑 = parseInt(날.slice(-4), 16);
       for (let k = 0; k <= 끝 - 시작; k += 1) {
-        if (표.has(시작 + k)) continue;
-        표.set(시작 + k, 첫.slice(0, -1) + String.fromCharCode(밑 + k));
+        if (표.has(시작 + k) || 밑 + k === 0) continue;
+        표.set(시작 + k, 앞글 + String.fromCharCode(밑 + k));
       }
     }
   }
@@ -917,16 +1070,14 @@ function 글꼴만들기(문, 글꼴사전) {
   const 너비 = 너비표읽기(문, 안, 두바이트);
 
   // ① /ToUnicode 가 있으면 그것이 가장 정확하다.
-  let 표 = new Map();
   let 폭 = 두바이트 ? 2 : 1;
   const 투 = 문.풀기(안.ToUnicode);
   if (투?.날것) {
     const r = 흐름풀기(투, (x) => 문.풀기(x));
     if (r.ok) {
       const 읽은것 = 유니코드표읽기(r.자료.toString('latin1'));
-      표 = 읽은것.표;
       if (읽은것.폭) 폭 = 읽은것.폭;
-      if (표.size) return { 폭, 표, 읽나: true, 너비 };
+      if (읽은것.표.size) return { 폭, 표: 읽은것.표, 읽나: true, 너비 };
     }
   }
 
@@ -1075,6 +1226,7 @@ function 흐름에서글(문, 자료, 자원, 깊이 = 0) {
   let 앞y = null;
   let 앞x = null;
   let 펜x = null;   // 붓이 지금 어디까지 갔다고 보는가 (자리바뀜 참고)
+  let BT뒤그대로 = false;   // BT 로 자리를 (0,0) 에 되돌린 뒤 아직 안 옮겼다 (아래 BT 머리말)
   let 못읽은코드 = 0;
   let 글낸적 = false;
   let 그림낸적 = false;
@@ -1114,6 +1266,7 @@ function 흐름에서글(문, 자료, 자원, 깊이 = 0) {
       if (틈 > 0.25 * 글꼴크기 * Math.abs(Tm[0] || 1)) 이번줄 += ' ';
     }
     앞y = y; 앞x = x; 펜x = x;
+    BT뒤그대로 = false;
   };
 
   const 글쓰기 = (바이트들) => {
@@ -1158,8 +1311,12 @@ function 흐름에서글(문, 자료, 자원, 깊이 = 0) {
        * 「Total 1,000,000 won」 이 세 줄로 쪼개진다. 줄이 바뀌었는지는 ET 가
        * 아니라 **세로로 움직였는지**가 말해 준다 — 그래서 앞자리를 그대로
        * 들고 다음 덩이의 첫 자리와 견준다.
+       *
+       * BT 는 글 자리도 (0,0) 으로 되돌린다. 거기서 Td·Tm 없이 곧장 찍으면 그 자리를 앞 덩이와 안
+       * 견줘서 앞 글 끝에 붙었다 — 「Hello」 다음 줄의 「World」 가 「HelloWorld」 (2.0.0 6회차 문서6).
+       * 그래서 BT 뒤 첫 찍기가 자리를 안 옮겼으면 그때 한 번 견준다. Td 가 오면 거기서 이미 견줬다.
        */
-      case 'BT': Tm = [1, 0, 0, 1, 0, 0]; Tlm = Tm.slice(); break;
+      case 'BT': Tm = [1, 0, 0, 1, 0, 0]; Tlm = Tm.slice(); BT뒤그대로 = true; break;
       case 'ET': break;
       case 'TL': TL = Number(인자[0]) || 0; break;
       case 'Td': {
@@ -1193,6 +1350,7 @@ function 흐름에서글(문, 자료, 자원, 깊이 = 0) {
       }
       case 'Tj': case 'TJ': case "'": case '"': {
         if (op === "'" || op === '"') { Tlm = 곱하기([1, 0, 0, 1, 0, -TL], Tlm); Tm = Tlm.slice(); 자리바뀜(); }
+        if (BT뒤그대로) 자리바뀜();
         const 몫 = op === '"' ? 인자[2] : 인자[인자.length - 1];
         if (op === 'TJ') {
           const 배열 = Array.isArray(몫) ? 몫 : [];
@@ -1293,10 +1451,58 @@ export function readPdf(경로또는버퍼) {
   const 쪽나무 = 문.꺼내기(뿌리?.사전 ?? 뿌리, 'Pages');
   let 쪽들 = [];
   if (쪽나무) 쪽모으기(문, 쪽나무, {}, 쪽들, new Set());
-  if (!쪽들.length) 쪽들 = 쪽줍기(문);
+  /*
+   * ── 「3쪽」 이라고 적어 놓고 그 3 을 우리도 모를 때 ────────────────────
+   *
+   * 사람이 본 것 —
+   *
+   *   ◧ Read(계약서.pdf)  →  pdf · 12쪽
+   *     --- 3쪽 ---
+   *     제7조 (하자담보책임) …
+   *
+   *   「3쪽에 하자담보 조항이 있다」 고 답이 나갔다. 실제 문서 3쪽은 다른
+   *   조항이었다. 근거로 댄 쪽 번호가 틀린 답은 안 읽은 것보다 나쁘다 —
+   *   사람이 그 쪽을 펴 보고 나서야 어긋난 걸 안다.
+   *
+   * 속에서 벌어진 일 — 쪽 나무(/Root → /Pages)를 못 걸으면(xref 가 깨졌거나
+   * 덧붙여 저장한 파일) 파일에 있는 /Type /Page 를 **객체 번호 순으로** 줍는다.
+   * 객체 번호는 쪽 차례와 아무 상관이 없다. 선형화(linearized)한 파일은 첫 쪽을
+   * 맨 뒤 번호로 두기도 하고, 덧붙여 저장하면 고친 쪽만 큰 번호로 붙는다.
+   * 그렇게 주운 차례에 순번+1 로 「N쪽」 이라는 **또렷한 번호를 찍어 놨다.**
+   * 못읽은쪽에도, 요약에도 아무 표가 안 났으니 누구도 의심할 수 없었다.
+   *
+   * 이제 지키는 규칙: 주워서 세운 차례면 「차례를 확인 못 했다」고 말한다.
+   * 번호를 안 붙일 수는 없다(쪽을 가리킬 말이 없어진다). 대신 그 번호가
+   * 문서의 번호라고 **믿게 두지는 않는다.**
+   */
+  let 쪽차례모름 = false;
+  if (!쪽들.length) {
+    쪽들 = 쪽줍기(문);
+    쪽차례모름 = 쪽들.length > 0;
+  }
   if (!쪽들.length) {
     return { ok: false, error: 'PDF 안에서 쪽을 못 찾았습니다 — 파일이 깨졌을 수 있습니다.' };
   }
+  /*
+   * ── 나무가 **반만** 걸렸을 때 ──────────────────────────────────────────
+   *
+   * 위 갈래는 나무를 **하나도** 못 걸었을 때만 선다. /Kids 셋 중 둘이 끊긴 파일
+   * (덧붙여 저장하다 끊긴 계약서·서명 PDF 에 흔하다)에서는 한 쪽만 건지고도
+   * 못읽은쪽 0 · 「pdf · 1쪽」 으로 올라갔다 — 나머지 두 쪽이 「없는 것」 이 되고,
+   * 모델은 한 쪽으로 문서 전체를 판단한다. 바로 위 머리말이 예순 줄에 걸쳐
+   * 경계하는 그 고장인데, 쪽 **차례**만 고치고 쪽 **수**는 안 봤다.
+   *
+   * 문서는 제 입으로 몇 쪽인지 적어 둔다(/Pages 의 /Count). 그 숫자를 pdf.js
+   * 어디서도 안 읽고 있었다. 우리가 건진 것보다 많으면 그 차이를 적는다.
+   * 적힌 수가 더 적은 판(덧붙여 저장하며 /Count 를 안 고친 파일)은 안 적는다 —
+   * 그건 우리가 더 찾은 것이라 잃은 것이 없다.
+   *
+   * 주워 온 차례(쪽차례모름)에는 안 잰다. 그때는 이미 「차례를 못 믿는다」 고
+   * 말하고 있고, /Count 와 견주면 같은 흠을 두 번 말하게 된다.
+   */
+  const 적힌쪽수 = Number(문.꺼내기(쪽나무?.사전 ?? 쪽나무, 'Count'));
+  const 못건진쪽 = (!쪽차례모름 && Number.isFinite(적힌쪽수) && 적힌쪽수 > 쪽들.length)
+    ? 적힌쪽수 - 쪽들.length : 0;
 
   const 덩이들 = [];
   const 못읽은쪽 = [];
@@ -1314,13 +1520,41 @@ export function readPdf(경로또는버퍼) {
       return;
     }
 
+    /*
+     * ── 반만 읽은 쪽을 다 읽은 쪽으로 세었다 ───────────────────────────
+     *
+     * 사람이 본 것 —
+     *
+     *   ◧ Read(사양서.pdf)  →  pdf · 8쪽        (못 읽은 쪽: 없음)
+     *     --- 4쪽 ---
+     *     2. 적용 범위
+     *
+     *   4쪽에 있던 조건표가 통째로 없는데 「4쪽은 다 읽었다」고 나갔다.
+     *   모델은 "그런 조건은 문서에 없습니다" 라고 답했다. 없는 것이 아니라
+     *   못 꺼낸 것이었다.
+     *
+     * 속에서 벌어진 일 — 한 쪽의 /Contents 는 흐름 **여러 개**일 수 있다.
+     * 그중 하나가 못 푸는 걸개(LZWDecode·CCITTFaxDecode)거나 참조가 끊겼거나
+     * 끝이 잘려 있으면 막힌걸개에 까닭을 적고 넘어갔는데, 그 까닭을 쓰는 자리가
+     * **자료들이 아예 빈 경우뿐**이었다. 하나만 살아나면 그 쪽은 온전한 쪽이
+     * 됐다. 글이 한 줄이라도 나왔는지(글있나)만 봤으니 표가 날 데가 없었다.
+     *
+     * 바로 아래(글리프를 못 되돌린 쪽)는 이미 `일부: true` 로 정직하게 적고
+     * 있었다. 같은 정직이 여기만 빠져 있었다.
+     *
+     * 이제 지키는 규칙: 흐름 하나라도 막혔으면, 글이 나왔어도 그 쪽은 일부다.
+     */
     const 자료들 = [];
     let 막힌걸개 = null;
     for (const c of 조각들) {
       const 하나 = 문.풀기(c);
-      if (!하나?.날것) continue;
+      if (!하나?.날것) {
+        막힌걸개 = 막힌걸개 ?? '내용 흐름 하나를 못 찾았습니다 (참조가 끊겼습니다)';
+        continue;
+      }
       const r = 흐름풀기(하나, (x) => 문.풀기(x));
       if (!r.ok) { 막힌걸개 = 막힌걸개 ?? r.왜; continue; }
+      if (r.잘림) 막힌걸개 = 막힌걸개 ?? '내용 흐름의 끝이 잘렸습니다 (압축이 끝나기 전에 파일이 끝났습니다)';
       자료들.push(r.자료);
       자료들.push(Buffer.from('\n'));
     }
@@ -1353,28 +1587,45 @@ export function readPdf(경로또는버퍼) {
        * 머리말 로고가 위쪽 자원에 물려 있으면 정말 빈 쪽도 「OCR 이 필요」
        * 가 됐다. 그린 것을 본 쪽은 파서다.
        */
+      /*
+       * 막힌 흐름이 있었으면 **그 까닭이 먼저다.**
+       *
+       * 여태는 여기서 막힌걸개 를 통째로 버리고 「글이 없는 쪽입니다」 로 덮었다.
+       * 흐름 둘 중 하나가 LZW 라 막히고 남은 하나엔 글이 없었을 뿐인데, 사람에게는
+       * 스캔본으로 보였다 — 그러면 있지도 않은 OCR 을 찾으러 간다. 자료들이 아예
+       * 빈 경우(바로 위)는 이미 까닭을 적고 있었다. 같은 정직이 여기만 빠져 있었다.
+       */
       const 그림있나 = 뽑은것.그림낸적;
+      const 까닭들 = [
+        막힌걸개,
+        뽑은것.못읽은코드 ? '글꼴에 /ToUnicode 표가 없어 글자를 되돌릴 수 없습니다' : null,
+      ].filter(Boolean);
       못읽은쪽.push({
         번호,
-        왜: 뽑은것.못읽은코드
-          ? '글꼴에 /ToUnicode 표가 없어 글자를 되돌릴 수 없습니다'
+        왜: 까닭들.length
+          ? 까닭들.join(' · ')
           : (그림있나 ? '글이 없는 쪽입니다 (스캔한 사진일 수 있습니다 — OCR 이 필요합니다)' : '글이 없는 쪽입니다'),
       });
       덩이들.push({ 이름: `${번호}쪽`, 문단들: [] });
       return;
     }
 
-    if (뽑은것.못읽은코드 > 0) {
-      못읽은쪽.push({
-        번호,
-        왜: `${뽑은것.못읽은코드}자를 못 되돌렸습니다 (글꼴 표에 없는 글리프) — 이 쪽은 일부만 읽었습니다`,
-        일부: true,
-      });
+    // 막힌 흐름과 못 되돌린 글리프는 둘 다 「일부」다. 한 쪽에 한 줄로 적는다 —
+    // 같은 번호를 두 번 올리면 「몇 쪽이 성한가」 를 세는 쪽에서 셈이 어긋난다.
+    if (막힌걸개 || 뽑은것.못읽은코드 > 0) {
+      const 까닭 = [
+        막힌걸개,
+        뽑은것.못읽은코드 > 0 ? `${뽑은것.못읽은코드}자를 못 되돌렸습니다 (글꼴 표에 없는 글리프)` : null,
+      ].filter(Boolean).join(' · ');
+      // 「일부만 읽었다」 는 말은 여기 적지 않는다 — 일부:true 를 보고 말하는
+      // 자리(toText·못읽은말·summarize)가 저마다 제 말투로 붙인다. 여기까지
+      // 적어 두었더니 toText 에서 앞뒤로 두 번 붙어 한 줄에 같은 말이 겹쳤다.
+      못읽은쪽.push({ 번호, 왜: 까닭, 일부: true });
     }
     덩이들.push({ 이름: `${번호}쪽`, 문단들: 뽑은것.줄들 });
   });
 
-  return { ok: true, 갈래: 'pdf', 판, 쪽수: 쪽들.length, 덩이들, 못읽은쪽 };
+  return { ok: true, 갈래: 'pdf', 판, 쪽수: 쪽들.length, 덩이들, 못읽은쪽, 쪽차례모름, 못건진쪽, 적힌쪽수: Number.isFinite(적힌쪽수) ? 적힌쪽수 : null };
 }
 
 /**
@@ -1399,6 +1650,12 @@ export function toText(r, { maxChars = 최대글자 } = {}) {
     }
     for (const 문단 of d.문단들) {
       if (셈 + 문단.length > maxChars) {
+        // 남은 만큼은 싣는다 (2.0.0 6회차 문서6). 통째로 버렸더니 첫 문단이 긴 쪽은 「N자에서 잘랐습니다」 와
+        // 머리말만 나가고 본문이 한 자도 없었다. 끝이 서로게이트 앞쪽이면 그 한 자는 뗀다.
+        let 앞 = 문단.slice(0, Math.max(0, maxChars - 셈));
+        const 끝코드 = 앞.charCodeAt(앞.length - 1);
+        if (끝코드 >= 0xd800 && 끝코드 <= 0xdbff) 앞 = 앞.slice(0, -1);
+        if (앞) 조각.push(앞);
         잘림.push(`${maxChars.toLocaleString('en-US')}자에서 잘랐습니다 — 뒷부분은 안 실렸습니다`);
         return { text: 조각.join('\n'), 잘림 };
       }
@@ -1413,8 +1670,23 @@ export function toText(r, { maxChars = 최대글자 } = {}) {
 /** 한 줄 요약. Read 의 summary 자리로 간다. */
 export function summarize(r) {
   if (!r?.ok) return '';
+  // 쪽 차례를 못 세운 것은 「못 읽은 쪽」과 다른 종류의 흠이라 따로 붙인다.
+  // 글은 다 나왔는데 번호만 못 믿는 경우가 있어서, 못 읽은 쪽이 없어도 떠야 한다.
+  const 차례 = r.쪽차례모름 ? ' · 쪽 차례 확인 못 함' : '';
+  // 문서가 적어 둔 쪽 수(/Count)보다 적게 건졌으면 그 차이를 요약에 올린다.
+  // 「pdf · 1쪽」 은 온전한 한 쪽짜리 문서와 글자 하나 다르지 않다.
+  const 못건짐 = r.못건진쪽 ? ` · ${r.못건진쪽}쪽 못 건짐` : '';
   const 통째로못읽음 = (r.못읽은쪽 ?? []).filter((x) => !x.일부).length;
-  if (!통째로못읽음) return `pdf · ${r.쪽수}쪽`;
+  /*
+   * 일부만 읽은 쪽도 화면에 올린다.
+   *
+   * 표 절반이 빠진 쪽만 있는 문서는 여태 `pdf · 8쪽` 으로만 찍혔다 — 화면만 보는
+   * 사람에게는 온전히 읽은 문서와 글자 하나 다르지 않았다. 본문 알림에는 적혀
+   * 있었지만, 요약 한 줄이 「다 읽었다」고 말해 버리면 본문은 안 읽는다.
+   */
+  const 일부수 = (r.못읽은쪽 ?? []).filter((x) => x.일부).length;
+  const 일부말 = 일부수 ? ` · ${일부수}쪽 일부만 읽음` : '';
+  if (!통째로못읽음) return `pdf · ${r.쪽수}쪽${못건짐}${일부말}${차례}`;
   /*
    * **왜** 못 읽었는지를 화면 요약에 올린다.
    *
@@ -1425,7 +1697,7 @@ export function summarize(r) {
    */
   const 까닭들 = new Set((r.못읽은쪽 ?? []).filter((x) => !x.일부).map((x) => 짧은까닭(x.왜)));
   const 왜 = 까닭들.size === 1 ? ` (${[...까닭들][0]})` : '';
-  return `pdf · ${r.쪽수}쪽 · ${통째로못읽음}쪽 못 읽음${왜}`;
+  return `pdf · ${r.쪽수}쪽${못건짐} · ${통째로못읽음}쪽 못 읽음${왜}${일부말}${차례}`;
 }
 
 /** 화면 한 줄에 들어갈 만큼 줄인 까닭. */
@@ -1449,12 +1721,26 @@ export function 한쪽도못읽음말(r, 보인이름) {
   const 까닭들 = [...new Set((r?.못읽은쪽 ?? []).map((x) => String(x.왜)))];
   const 줄 = [`${r?.쪽수 ?? 0}쪽을 전부 글로 못 읽었습니다: ${보인이름}`];
   for (const 왜 of 까닭들.slice(0, 3)) 줄.push(`  · ${왜}`);
+  /*
+   * 길은 **왜 못 읽었는지에 따라 다르다.** 여태는 글꼴 표가 없는 것만 갈라 놓고
+   * 나머지는 전부 「그림으로만 들어 있습니다 — OCR 이 필요」 로 보냈다. 그래서
+   * 빈 쪽뿐인 문서에도, 흐름이 막혀 못 푼 문서에도 OCR 을 찾으러 가게 했다.
+   * 위 1459 에서 「빈 쪽이다 → OCR 은 할 일이 없다」 고 이미 갈라 놨는데,
+   * 그 갈림이 사람에게 나가는 말에는 안 닿아 있었다.
+   */
   if (까닭들.some((x) => /ToUnicode/.test(x))) {
     줄.push('  글꼴이 글자표를 안 싣고 있어 되돌릴 수 없습니다. 이 PDF 를 만든 원본');
     줄.push('  (pptx·docx 등)이 있으면 그쪽을 읽으세요. 훨씬 정확합니다.');
-  } else {
+  } else if (까닭들.some((x) => /스캔|OCR/.test(x))) {
     줄.push('  글이 그림으로만 들어 있습니다. 이 도구로는 더 해 볼 것이 없습니다 —');
     줄.push('  OCR 이 필요하거나, 이 PDF 를 만든 원본 파일을 읽어야 합니다.');
+  } else if (까닭들.length && 까닭들.every((x) => /빈 쪽|글이 없는 쪽/.test(x))) {
+    줄.push('  쪽에 그린 것이 아예 없습니다 — 글도 그림도 없는 빈 쪽입니다.');
+    줄.push('  OCR 도 할 일이 없습니다. 이 PDF 를 만든 원본 파일을 찾으세요.');
+  } else {
+    줄.push('  글이 없어서가 아니라 **내용 흐름을 못 풀어서** 못 읽었습니다 (위 까닭).');
+    줄.push('  파일이 깨졌거나 이 도구가 못 푸는 압축입니다. 원본 파일이 있으면 그쪽을,');
+    줄.push('  없으면 이 PDF 를 다시 내려받거나 다시 뽑아 보세요.');
   }
   줄.push('  **같은 파일을 다시 Read 하지 마세요. 결과는 같습니다.**');
   return 줄.join('\n');
@@ -1468,10 +1754,32 @@ export function 한쪽도못읽음말(r, 보인이름) {
  */
 export function 못읽은말(r) {
   const 것들 = r?.못읽은쪽 ?? [];
-  if (!것들.length) return '';
   const 통째 = 것들.filter((x) => !x.일부);
   const 일부 = 것들.filter((x) => x.일부);
   const 줄 = [];
+  /*
+   * 쪽 번호를 못 믿는다는 말이 **본문과 같이** 가야 한다.
+   *
+   * 글은 다 나왔으니 못 읽은 쪽이 하나도 없을 수 있다 — 그래도 여기서
+   * 말해야 한다. 모델이 근거로 대는 것이 「N쪽」 이라서, 이 한 줄이 없으면
+   * 주워 세운 차례가 문서의 차례로 그대로 답에 실린다.
+   */
+  /*
+   * 쪽 나무가 반만 걸린 것도 **본문에** 적는다. 요약만 보고 넘어가는 자리가 아니라,
+   * 모델이 「문서에 그런 조항은 없습니다」 라고 답하는 자리가 여기다.
+   */
+  if (r?.못건진쪽) {
+    줄.push(`이 문서는 스스로 ${r.적힌쪽수}쪽이라고 적어 두었는데 ${r.쪽수}쪽만 건졌습니다 (${r.못건진쪽}쪽 못 건짐).`);
+    줄.push('  쪽 나무(/Kids)의 일부가 끊겨 있습니다 — 덧붙여 저장하다 끊긴 파일에 흔합니다.');
+    줄.push('  못 건진 쪽의 내용은 여기 없습니다. 「문서에 없다」 고 답하지 마세요.');
+  }
+  if (r?.쪽차례모름) {
+    줄.push('쪽 차례를 확인 못 했습니다 — 나온 차례가 문서 차례가 아닐 수 있습니다.');
+    줄.push('  쪽 나무(/Root → /Pages)가 깨져 있어, 파일에 있는 쪽을 객체 번호 순으로 주웠습니다.');
+    줄.push('  객체 번호는 쪽 차례와 상관이 없습니다. 「N쪽」 은 나온 차례일 뿐이니,');
+    줄.push('  답에 쪽 번호를 근거로 쓰지 마세요.');
+  }
+  if (!것들.length) return 줄.join('\n');
   if (통째.length) {
     const 쪽말 = 통째.map((x) => x.번호).join(' · ');
     줄.push(`${r.쪽수}쪽 중 ${통째.length}쪽을 글로 못 읽었습니다 (${쪽말}쪽).`);