TrendShift 딥다이브 · 2026-07-13 · Monthly #13

pxpipe 딥다이브
— 텍스트를 "그림"으로 바꿔 LLM 입력 토큰을 60~70% 깎는 로컬 프록시

Claude Code가 매 턴 다시 보내는 시스템 프롬프트·툴 문서·오래된 대화 히스토리를, 내 컴퓨터 안 프록시가 조밀한 PNG 이미지 한 장으로 렌더해 모델의 비전(vision) 채널로 우회시킨다. 모델 응답은 손대지 않고 "요청"만 압축한다. 이 문서는 README를 넘어 실제 소스(src/core/*.ts)를 뜯어, "왜 글자를 그림으로 만들면 토큰이 줄어드는가"라는 반직관적 트릭의 작동 원리와 그 한계를 초보자용으로 풀어낸다.
목차
  1. 프로젝트 한줄 요약
  2. 왜 주목받는가 (핵심 트릭의 원리)
  3. 기술 스택 전체 지도
  4. 아키텍처 심화 분석
  5. 디렉토리 구조 해부
  6. 학습 포인트
  7. 설치·시스템 요구사항
  8. 직접 해볼 수 있는 실습 과제
  9. 관련 기술 심화 학습 로드맵
  10. 핵심 키워드 사전
  11. 참고 링크

1프로젝트 한줄 요약

이 저장소가 대체 무엇인가.

pxpipe(npm 패키지명 pxpipe-proxy)는 Claude Code나 Codex 같은 AI 코딩 에이전트와 실제 모델 API 사이에 끼어 앉는 로컬 프록시(local proxy)다. 에이전트가 API로 보내는 요청에서 부피가 큰 텍스트 덩어리 — 시스템 프롬프트, 툴 설명 문서, 이미 지나간 대화 기록 — 를 가로채, 그것을 작고 조밀한 PNG 이미지로 그려서 대신 실어 보낸다. 그 결과 입력 토큰이 대략 60~70% 줄어든다.

TERM
프록시 (proxy)
두 프로그램 사이에 서서 오가는 데이터를 중계·가공하는 중간자. pxpipe는 127.0.0.1:47821에 떠서 "에이전트 → (pxpipe) → api.anthropic.com" 흐름의 가운데를 맡는다. 에이전트 입장에선 그냥 API처럼 보인다.
한 문장 비유

매번 두꺼운 설명서를 통째로 팩스로 보내는 대신, 그 페이지를 사진 한 장으로 찍어 보낸다.

AI 에이전트는 대화가 이어질수록 매 턴마다 "너는 이런 도구를 쓸 수 있고, 규칙은 이렇고, 지금까지 이런 얘기를 했어"를 텍스트로 처음부터 다시 보낸다. 이 재전송 분량이 입력 요금의 대부분이다.

pxpipe는 그 반복되는 두꺼운 부분을 글자가 빼곡히 박힌 사진 한 장으로 바꿔 보낸다. 사람이 스크린샷 속 글자를 읽듯, 요즘 모델은 이미지 속 글자를 읽는다. 그런데 사진의 요금은 담긴 글자 수가 아니라 사진의 픽셀 크기로 고정돼 있어서, 같은 내용을 훨씬 싸게 실어 나른다.

핵심 수치
글자 28,080자 → 이미지 1장 ≈ 1,522 토큰

텍스트로 보내면 약 7,000 토큰인 분량을, 이미지로는 약 1,522 토큰에 담는다 (약 4.6배 밀도). 실제 코딩 트래픽에서는 텍스트 토큰이 더 잘게 쪼개져서, 체감 절감이 약 68%까지 나온다. 버전 0.8.0, 라이선스 MIT, 주 언어 TypeScript.

먼저 알아둘 함정
이건 "무손실 압축"이 아니다 — 조용히 틀릴 수 있다

이미지 속 정확한 문자열(긴 ID, 해시, 시크릿)을 모델이 글자 하나 안 틀리고 되읽는 것은 보장되지 않는다. 그것도 에러를 내는 게 아니라 그럴듯한 값으로 조용히 지어낸다. 그래서 pxpipe는 최근 대화·정확값은 텍스트로 남기고, 기본적으로 Fable 5 모델에서만 켠다. 자세한 원리는 §2·§4에서.

2왜 주목받는가

트렌딩 이유와, 왜 하필 지금 이게 통하게 됐는가.

핵심 통찰은 딱 한 줄이다. 이미지의 토큰 비용은 그 안에 담긴 글자 수가 아니라, 이미지의 픽셀 크기로 결정된다. 이 비대칭을 극한까지 밀어붙인 게 pxpipe다.

왜 이미지가 더 싼가 — 요금 규칙을 역이용

소스의 src/core/render.ts 주석에는 2026-07-01에 직접 측정한 근거가 박혀 있다. Anthropic API는 이미지를 이렇게 과금한다:

# Anthropic 이미지 토큰 과금 규칙 (측정값) 1) 이미지를 리샘플: 긴 변 ≤ 1568px 그리고 전체 ≈ 1.15 메가픽셀(약 1,143,750px) 이내로 2) 토큰 ≈ (가로 × 세로) / 750 3) 이미지 한 장당 상한 ≈ 1,525 토큰 # pxpipe의 Claude용 페이지 설계 페이지 크기 = 1568 × 728 = 1,141,504 px → 두 경계를 딱 만족(리샘플 없음) 과금 ≈ 1,141,504 / 750 ≈ 1,522 토큰 담기는 글자 = 312열 × 90행 = 28,080 자
TERM
비전 토큰 / 패치 임베딩 (vision token / patch embedding)
모델은 이미지를 작은 사각 조각(patch)들로 잘라 각 조각을 하나의 벡터로 바꿔 먹는다. 이 조각의 개수가 곧 "이미지 토큰 수"이고, 조각 개수는 픽셀 크기로 정해진다. 그래서 같은 픽셀 안에 글자를 더 빽빽이 넣을수록 "토큰당 글자 수"가 올라간다 — pxpipe가 노리는 지점.

즉 28,080자를 텍스트로 보내면(프로즈 기준 대략 4자/토큰) 약 7,020 토큰이지만, 이미지로는 약 1,522 토큰이다. 게다가 코드·JSON처럼 토큰이 잘게 쪼개지는 조밀한 콘텐츠에서는 텍스트 효율이 1자/토큰 근처까지 나빠지기 때문에, 이미지 쪽의 상대 이득이 더 커져 실측 절감이 59% → 70% 구간으로 나온다.

비유로 다시

택배 요금이 "상자 안 물건 개수"가 아니라 "상자 크기"로만 매겨진다고 하자. 그러면 같은 크기 상자에 물건을 최대한 빽빽하게 채워 넣는 사람이 이긴다. pxpipe의 reflow가 하는 일이 정확히 이거다 — 글자를 페이지에 빈틈없이 채워 "상자 채움률"을 29%에서 75~80%로 끌어올린다.

왜 하필 지금? — 프론티어 모델이 드디어 "조밀 렌더"를 읽는다

이 아이디어 자체는 새롭지 않다. 2025년 10월 DeepSeek-OCR이 "이미지가 텍스트 컨텍스트의 채널이 될 수 있다"를 전용 인코더로 증명했다. 하지만 당시엔 어떤 상용 프로덕션 모델도 이렇게 빽빽한 렌더를 제대로 못 읽었다. pxpipe의 README가 지목하는 변곡점은 Fable 5다 — 같은 페이지에서 12자리 hex를 Fable 5는 15개 중 13개 읽었고, Opus 4.8은 0개를 읽었다. "이제 최전선 모델이 조밀 렌더를 읽는다"는 이 변화에 올라탄 첫 프로덕션 프록시라는 점이 트렌딩의 핵심이다.

구분DeepSeek-OCR (2025.10)pxpipe (2026)
목적"이미지=컨텍스트 채널" 가능성 증명실제 프로덕션 트래픽에서 요금 절감
모델전용 인코더/디코더 필요stock Fable 5 등 상용 모델 그대로
형태연구 데모npx 한 방 로컬 프록시 + 대시보드
대상-Claude Code · Codex(OpenAI 호환)
재현 가능한 벤치 (README)
"진짜 일을 시켜도 품질이 안 무너지나"를 직접 측정

SWE-bench Lite 파일럿에서 켠 쪽·끈 쪽 모두 10/10 통과에 요청 토큰은 −65%. 13,709개 요청 스냅샷에서 59% 절감($100→~$41), 이후 8,904개 압축 요청 추적에서 ~70%. 자기참조적으로 흥미로운 점: 이 레포의 커밋 대부분을, pxpipe 뒤에서 도는 에이전트가 자기 대화 기록을 이미지로 읽으며 작성했다고 README가 밝힌다.

3기술 스택 전체 지도

무엇으로 만들어졌나 — 언어·의존성·렌더러·빌드.

가장 놀라운 사실부터: 이 프로젝트는 런타임 의존성이 딱 1개다. 이미지를 그리는데 흔히 쓰는 무거운 네이티브 캔버스 라이브러리가 런타임에는 하나도 없다.

계층선택메모
언어TypeScript (ESM, "type":"module").ts 80개. 코어는 런타임 무관하게 작성
런타임Node ≥ 18 + Cloudflare Workers같은 코어 코드가 서버·엣지 양쪽에서 동작
런타임 의존성gpt-tokenizer@^3.4.0 단 1개GPT/Codex 경로의 토큰 수 추정용
렌더러자체 제작 (무의존)비트맵 폰트 아틀라스 + 순수 JS PNG 인코더
폰트Spleen 5×8 + Unifont(다국어), 옵션 JetBrains Monoassets/에 원본+라이선스 동봉
빌드 의존성@napi-rs/canvas, esbuild 0.28, tsx, vite 8, vitest 4.1, wrangler 4.92@napi-rs/canvas는 빌드 타임에만
패키지 매니저pnpm@10.21.0
TERM
폰트 아틀라스 (font atlas)
글자 하나하나의 픽셀 모양을 미리 그려서 하나의 표(비트맵)로 구워둔 것. pxpipe는 빌드할 때 @napi-rs/canvas로 이 표를 만들어 src/core/atlas*.tsUint8Array 상수로 박아둔다. 그래서 실행할 때는 무거운 폰트 엔진 없이, 표에서 글자 모양을 복사(blit)만 하면 된다. 이 덕분에 브라우저 엔진이 없는 Cloudflare 엣지에서도 이미지를 그릴 수 있다.
비유로

글자를 그릴 때마다 붓과 물감(폰트 엔진)을 꺼내는 대신, 글자 도장 세트를 미리 만들어 두고 필요한 도장을 찍기만 하는 방식이다. 도장 세트는 공장(빌드)에서 미리 만들고, 현장(런타임)에서는 찍기만 한다.

4아키텍처 심화 분석

요청 하나가 프록시 안에서 어떻게 이미지로 변신하는가.

전체 파이프라인

Claude Code가 POST /v1/messages 요청을 보냄 │ ▼ ┌──────────────────────────────────────────────────────────┐ │ pxpipe 프록시 (127.0.0.1:47821) │ │ │ │ 1) 요청 바디 파싱 │ │ 2) system 텍스트를 3조각으로 분해: │ │ · billingLine (턴마다 랜덤 헤더) → 캐시 금지 │ │ · dynamicText (<env>/<context> 등) → 텍스트 유지 │ │ · staticText (시스템+툴+CLAUDE.md) → 이미지 대상 │ │ 3) 툴 문서 → 이미지 "Tool Reference"로 이동 │ │ (원본 tools[]엔 설명 벗긴 스키마만 남김) │ │ 4) staticText 덩어리 → PNG 페이지[] 로 렌더 │ │ 5) 큰 tool_result(조밀) → PNG (수익성 게이트 통과 시) │ │ 6) 오래된 히스토리 → PNG (최근 몇 턴은 텍스트로 남김) │ │ 7) 각 이미지 옆에 정확값 factsheet(ID/경로/SHA) 텍스트 첨부 │ │ 8) 이미지를 첫 user 메시지에 splice (앞부분 캐시 보존) │ │ 9) 원본 바디로 무료 count_tokens 병렬 발사(측정용) │ └──────────────────────────────────────────────────────────┘ │ │ ▼ ▼ api.anthropic.com ~/.pxpipe/events.jsonl (압축된 요청 전송) (압축 전/후를 같은 행에 기록)

지원하지 않는 경로·모델이거나 POST가 아니면, 바이트 하나 안 바꾸고 그대로 통과시킨다(fail-closed = 문제 상황에선 무조건 원본 유지). 모델 응답은 절대 건드리지 않는다.

코어 모듈 지도

파일줄수역할
core/transform.ts2,275변환 파이프라인 본체 — 요청을 이미지 섞인 형태로 재조립
core/render.ts1,254텍스트→PNG 렌더러 — 아틀라스 blit, reflow, 페이지네이션
core/proxy.ts842런타임 무관 fetch 핸들러 — 라우팅·SSE 스트림 파싱·usage 추출
core/history.ts666오래된 대화 턴만 골라 이미지로 접기(collapse)
core/factsheet.ts253이미지 옆에 붙일 정확값(ID/경로/SHA) 텍스트 추출
core/png.ts149순수 JS PNG 인코더 (네이티브 zlib 없이)
core/applicability.ts125모델 allowlist 게이트 — 기본 fable-5만 허용
core/measurement.ts / baseline.ts214 / 132counterfactual 토큰 측정 + 비용 수식
node.ts / worker.ts1,112 / 152Node http 서버 / Cloudflare Worker 진입점
dashboard.ts1,526절감량·text→image 비교·kill switch UI

이 설계를 지탱하는 3가지 핵심 패턴

패턴 ①
static / dynamic 분리 = 프롬프트 캐시를 깨지 않기

LLM API는 프롬프트 앞부분이 글자까지 똑같으면 캐시해서 싸게 재사용한다(prompt caching). 그런데 이미지로 바꾸면 이 캐시가 깨질 위험이 있다. 그래서 pxpipe는 system을 "매 턴 바뀌는 부분(billingLine·<env>)"과 "안 바뀌는 부분(정적 지침)"으로 쪼개, 안 바뀌는 부분만 이미지로 만들고 앞쪽 정적 prefix를 보존한다.

패턴 ②
수익성 게이트 (profitability gate)

조밀한 콘텐츠만 이미지화하고, 성긴 산문은 텍스트로 통과시킨다. transform.ts의 판정 수식은 대략 이렇다:

// 이미지로 바꿨을 때 총비용 < 텍스트로 뒀을 때 총비용 이면 압축
return imageTokensCost + burnImageSide
       < textTokensEquivalent + burnTextSide;

여기서 burn 항은 "모드를 바꾸면 따뜻하게 데워둔 캐시가 무효화되는 비용"을 양쪽에 대칭으로 더한 것. 이게 없으면 게이트가 매 턴 켰다 껐다 깜빡여(flapping) 오히려 손해다. 실제 프로덕션 391개 행으로 이 수식을 보정했다.

패턴 ③
counterfactual 측정 = 절감률을 정직하게

매 요청마다 압축 안 한 원본 바디로 무료 count_tokens 프로브를 동시에 쏴서, "안 했으면 얼마였을지"를 같은 행에 같이 기록한다. 턴 수나 실행 편차 같은 교란요인 없이 "이번 요청에서 실제로 아낀 양"을 바로 비교한다. 코드에는 이 정직성을 CI에서 검증하는 savings-honesty.test.ts까지 있다.

5디렉토리 구조 해부

어디에 무엇이 있나.

pxpipe/ ├── bin/cli.js # npx 진입 shim → dist/node.js 만 import ├── src/ │ ├── node.ts # Node http 서버 + CLI(--help/--version) │ ├── worker.ts # Cloudflare Worker 진입점 │ ├── dashboard.ts # 대시보드 UI/API │ ├── core/ # ★ 런타임 무관 코어 │ │ ├── transform.ts # 요청 변환 파이프라인(본체) │ │ ├── render.ts # 텍스트→PNG 렌더러 │ │ ├── proxy.ts # fetch 핸들러·라우팅·SSE │ │ ├── png.ts # 순수 JS PNG 인코더 │ │ ├── atlas*.ts # 미리 구운 비트맵 폰트 │ │ ├── factsheet.ts # 정확값 텍스트 추출 │ │ ├── history.ts # 오래된 턴 이미지화 │ │ ├── openai*.ts # GPT/Codex 경로 │ │ └── applicability.ts # 모델 allowlist 게이트 │ └── dashboard/ # 대시보드 조각·타입 ├── tests/ # 32개 vitest(*.test.ts), ~13,868줄 ├── eval/ # 모델 품질 재현 벤치(swe-bench, gsm8k, hex recall…) ├── bench/ # 마이크로 벤치 ├── docs/ # 설계 문서 8종(NOT-OCR.md 등) ├── scripts/ # build.mjs, gen-atlas.ts … ├── assets/ # 폰트 원본 + 라이선스 ├── wrangler.toml # Worker 배포 설정 └── README.md · CHANGELOG.md · FINDINGS.md · LICENSE

docs/NOT-OCR.md는 특히 읽어볼 가치가 있다 — "왜 이 방식의 오독이 OCR 오류와 달리 조용한 지어냄(silent confabulation)인가"를 설명한다. src(15,257줄)와 tests(13,868줄)가 거의 1:1이라는 점도, 이 프로젝트가 "요금 절감이 진짜인지"를 얼마나 자기검증에 집착하는지 보여준다.

6학습 포인트

이 레포에서 실제로 배울 수 있는 것.

1. 비전 토큰 이코노미 — LLM 요금의 숨은 규칙

"이미지는 픽셀로 과금되고 텍스트는 토큰으로 과금된다"는 비대칭을 실전에서 어떻게 돈으로 바꾸는지 배운다. render.ts 주석의 측정 방법(직접 count_tokens sweep을 돌려 경계를 찾음)은 API 요금을 리버스 엔지니어링하는 좋은 예시다.

2. 런타임 무관 코어 설계

코어를 Web 표준(Request/Response/fetch/crypto.subtle/CompressionStream)만으로 짜서 Node와 Cloudflare Workers 양쪽에서 같은 코드가 도는 구조. "플랫폼 API가 아니라 표준 API에 의존하라"는 이식성 설계의 교과서 사례다.

3. 프롬프트 캐시를 깨지 않는 프롬프트 분해

prompt caching이 어떻게 동작하는지, 그리고 "앞부분을 글자까지 고정해야 캐시가 산다"는 제약 아래에서 무엇을 이미지로 바꾸고 무엇을 텍스트로 남길지 결정하는 법. LLM 비용 최적화의 실전 감각을 준다.

4. 순수 JS로 PNG를 만드는 법

png.ts 149줄만 읽어도 PNG 파일 포맷(청크·필터·zlib deflate)의 뼈대를 이해할 수 있다. 네이티브 라이브러리 없이 이미지 바이트를 손으로 조립하는 경험은 흔치 않다.

실습 아이디어 씨앗

PXPIPE_DUMP_DIR 환경변수를 켜면 pxpipe가 실제로 모델에 보내는 PNG를 파일로 떨궈준다. 이걸 열어보면 "내 시스템 프롬프트가 이렇게 생긴 사진으로 바뀌어 나가는구나"를 눈으로 확인할 수 있다. §8에서 단계별로 다룬다.

7설치·시스템 요구사항

무엇이 있어야 돌아가나 — 30초면 켠다.

항목요구/기본값
런타임Node ≥ 18 (또는 Cloudflare Workers)
설치npx pxpipe-proxy — 전역 설치 불필요
포트/호스트기본 127.0.0.1:47821 (loopback 전용)
API 키기존 것 그대로 — 프록시는 키를 저장하지 않고 통과만
대상 모델기본 claude-fable-5만 압축 (나머지는 opt-in)

기본 사용 (Claude Code)

# 1) 프록시 기동
npx pxpipe-proxy

# 2) Claude Code를 프록시로 향하게
ANTHROPIC_BASE_URL=http://127.0.0.1:47821 claude

# 대시보드: 브라우저에서 http://127.0.0.1:47821/
보안 주의
대시보드는 인증이 없다 → loopback 밖으로 열지 말 것

기본 호스트가 127.0.0.1인 이유가 이것이다. HOST=0.0.0.0으로 바꿔 LAN에 노출하면 같은 네트워크의 누구나 대시보드(및 트래픽 기록)를 볼 수 있다. 꼭 필요할 때만 opt-in.

알아두면 좋은 환경변수

변수의미
PXPIPE_MODELS이미지화할 모델 CSV. 기본 claude-fable-5, off면 비활성
PXPIPE_DUMP_DIR렌더된 PNG를 이 폴더로 덤프(디버그·학습용)
PXPIPE_LOG이벤트 로그 경로 (기본 ~/.pxpipe/events.jsonl)
OPENAI_BASE_URLCodex 등 OpenAI 호환 클라이언트를 …:47821/v1
ANTHROPIC_MAX_HEIGHT_PX 등이미지 geometry(높이·열수·픽셀/토큰) 미세 조정

8직접 해볼 수 있는 실습 과제

눈으로 확인하는 것부터, 코드를 뜯는 것까지.

과제 1 · 난이도 ★☆☆☆☆

프록시 켜고 대시보드에서 절감량 보기

npx pxpipe-proxy로 띄우고 Claude Code를 붙인 뒤, 몇 턴 대화하고 127.0.0.1:47821 대시보드를 연다. "text vs image" 나란히 비교와 누적 절감률을 관찰한다. kill switch로 껐다 켜며 차이를 체감해 본다.

과제 2 · 난이도 ★★☆☆☆

내 프롬프트가 어떤 사진이 되는지 눈으로 확인

PXPIPE_DUMP_DIR=./dump를 켜고 한 세션 돌린 뒤, 떨어진 PNG를 연다. 312열 × 90행에 글자가 빽빽이 박힌 페이지를 직접 보고, "사람인 나는 이걸 얼마나 읽을 수 있나"를 모델의 성능과 비교해 본다.

과제 3 · 난이도 ★★★☆☆

라이브러리로 텍스트→이미지 직접 렌더

프록시 없이 코드에서 직접 호출:

import { renderTextToImages } from "pxpipe-proxy";
const { pages } = await renderTextToImages(longText);
// pages[i].png : Uint8Array  → 파일로 저장해 열어보기

긴 텍스트를 넣고 페이지가 몇 장 나오는지, 한 장에 몇 자가 들어가는지 세어 본다.

과제 4 · 난이도 ★★★★☆

수익성 게이트 수식 실험

transform.tsisCompressionProfitableANTHROPIC_PIXELS_PER_TOKEN·charsPerToken 값을 바꿔가며, 어떤 콘텐츠(코드 vs 산문)에서 게이트가 켜지고 꺼지는지 관찰한다. "언제 이미지가 손해인가"의 경계를 스스로 찾아본다.

과제 5 · 난이도 ★★★★★

verbatim recall 한계를 재현

eval/의 hex recall 하네스를 돌려, 12자리 hex를 이미지로 넣었을 때 Fable 5와 다른 모델의 정확 리콜 차이(13/15 vs 0/15)를 직접 재현한다. "왜 이건 OCR이 아니라 지어냄인가"를 docs/NOT-OCR.md와 대조해 이해한다.

9관련 기술 심화 학습 로드맵

이 레포를 제대로 씹으려면 무엇을 곁들일까 (주차별).

주차주제무엇을
1주차LLM 토큰·요금 기초토크나이저가 텍스트를 어떻게 쪼개나, 입력/출력/캐시 토큰 요금 구조
2주차비전 모델 입력이미지 patch embedding, 멀티모달 모델이 스크린샷을 읽는 원리
3주차프롬프트 캐싱cache breakpoint, prefix 고정 규칙, 캐시 hit/miss 요금 배수
4주차PNG·폰트 렌더링PNG 청크 구조, zlib deflate, 비트맵 폰트 아틀라스·blit
5주차프록시·엣지 런타임HTTP 프록시, SSE 스트리밍 파싱, Web 표준 API로 Node/Workers 양립
6주차측정·평가 방법론counterfactual 측정, A/B 벤치(SWE-bench 등), "정직한 절감률" 설계

10핵심 키워드 사전

이 문서에 나온 용어 빠른 정리.

비전 토큰 (vision token)
모델이 이미지를 잘라 만든 조각(patch) 하나가 차지하는 입력 단위. 개수는 픽셀 크기로 정해지므로, 같은 픽셀에 글자를 빽빽이 넣을수록 토큰당 정보량이 커진다.
패치 임베딩 (patch embedding)
이미지를 작은 사각 조각으로 나눠 각 조각을 벡터로 바꾸는 과정. 텍스트 토크나이저를 우회해 모델에 직접 들어간다.
프롬프트 캐싱 (prompt caching)
프롬프트 앞부분이 글자까지 동일하면 모델 쪽에서 계산을 재사용해 싸게 처리하는 것. pxpipe가 static/dynamic을 분리하는 이유.
수익성 게이트 (profitability gate)
"이미지로 바꾸는 게 정말 이득인가"를 매 조각마다 수식으로 판정해, 조밀한 것만 이미지화하고 성긴 산문은 텍스트로 통과시키는 장치.
reflow
텍스트를 페이지에 빈틈없이 채우도록 줄바꿈을 재배치하는 것. 하드 개행은 글자로 바뀌고 이를 모델에 알린다. 채움률을 29%→75~80%로 올린다.
factsheet
이미지 옆에 함께 싣는 "정확값 텍스트" — ID·파일 경로·SHA 해시·버전 같은 글자 하나도 틀리면 안 되는 값을 정규식으로 뽑아 텍스트로 보존한다.
confabulation (조용한 지어냄)
모델이 이미지 속 애매한 글자를 에러 없이 "그럴듯한 값"으로 채워 넣는 현상. OCR 오류와 달리 실패 신호가 없어서 위험하다.
counterfactual 측정
"압축 안 했으면 얼마였을지"를 원본 바디로 동시에 계산해 실제 절감을 정직하게 비교하는 방법.
fail-closed
문제·미지원 상황에서는 아무것도 바꾸지 않고 원본을 그대로 통과시키는 안전 기본값.
런타임 무관 (runtime-agnostic)
플랫폼 전용 API 대신 Web 표준만 써서, 같은 코어 코드가 Node·Cloudflare Workers 등 여러 환경에서 도는 설계.

11참고 링크

더 파고들 곳.