diff --git a/README.md b/README.md
index de76d44..8e2a08a 100644
--- a/README.md
+++ b/README.md
@@ -103,6 +103,18 @@ Vite `?url` import 로 로드됩니다.
 
 ---
 
+## 알려진 이슈 / 원본 반영 메모
+
+| 이슈 | 문서 |
+|------|------|
+| 구형 한글 DWG TEXT 깨짐 (CP949→Latin-1 mojibake) | [`docs/korean-dwg-text-encoding.md`](./docs/korean-dwg-text-encoding.md) |
+| Model + Paper 동시 렌더로 글자 겹침 / Layout 탭 | [`docs/model-paper-space.md`](./docs/model-paper-space.md) |
+
+샘플 패치: `fixDwgKoreanText`, `cadSpaces` + Viewer2D 공간 필터, Model/Layout 탭.  
+원본 `hmwebviewer` 반영 절차는 각 문서를 따른다.
+
+---
+
 ## 라이선스 메모
 
 | 조각 | 라이선스 |
diff --git a/docs/korean-dwg-text-encoding.md b/docs/korean-dwg-text-encoding.md
new file mode 100644
index 0000000..76b06e7
--- /dev/null
+++ b/docs/korean-dwg-text-encoding.md
@@ -0,0 +1,296 @@
+# 한글 DWG 텍스트 깨짐 — 원인 분석 및 원본 반영 가이드
+
+| 항목 | 내용 |
+|------|------|
+| 작성 목적 | 샘플에서 재현·수정한 이슈를 **원본(`hmwebviewer`)** 에 반영하기 위한 기술 메모 |
+| 샘플 저장소 | `dwg-dxf-viewer-sample` (본 문서 위치) |
+| 원본 저장소 | `hmwebviewer` (`src/viewer2d/` 동기화 대상) |
+| 재현 도면 | `C0060203-002-굴착및시공순서도(2차로,자연환기300m이상).dwg` 등 구형 한글 CAD 도면 |
+| 대조 도면 | `BasicSample.dwg` (이미 정상 유니코드 한글) |
+| 샘플 수정일 | 2026-07-29 |
+| 상태 | 샘플 패치 완료 / 원본 미반영 |
+
+---
+
+## 1. 현상
+
+웹 2D 뷰어에서 일부 DWG를 열면 **도형·치수 기하, 영문 TEXT는 정상**인데 **한글 TEXT/MTEXT·타이틀블록 문구·NOTE** 등이 다음과 같이 깨져 보인다.
+
+| 화면/파서 출력 (깨짐) | 정상 의미 |
+|----------------------|-----------|
+| `½Ã°ø½Ã` | 시공시 |
+| `·Ïº¼Æ®` | 록볼트 |
+| `¼ôÅ©¸®Æ®` | 숏크리트 |
+| `±¼Âø ¹× ½Ã°ø¼ø¼­µµ` | 굴착 및 시공순서도 |
+| `Á߽ɼ±(ÀϹÝ)` (라인타입 설명) | 중심선(일반) |
+
+외형상 “폰트가 없다 / 글리프가 없다”와 혼동하기 쉽지만, **글리프 부재(tofu □)** 가 아니라 **잘못된 유니코드 코드포인트가 그대로 그려진 것(mojibake)** 이다.
+
+### 자주 하는 오진
+
+| 가설 | 실제 |
+|------|------|
+| `dist/fonts` / `public/fonts` 에 돋움이 없어서 | 폰트 폴더에는 `NanumGothic-Regular.ttf`(한글 포함)가 있음 |
+| Style `Standard` + 폰트 `돋움` 미매핑 | 뷰어는 스타일→폰트 매핑 없이 **단일 TTF** 로 그림. 돋움 없어도 코드포인트만 맞으면 한글 표시 가능 |
+| slugText / opentype 버그 | 동일 파이프라인에서 `BasicSample.dwg` 한글은 정상 |
+
+---
+
+## 2. 파이프라인 위치
+
+```
+DWG bytes
+  → acadrust WASM (parse_dwg)     ← 여기서 문자열이 이미 깨지거나 정상으로 나옴
+  → CadParseResult (entities/tables/…)
+  → [샘플 패치] fixDwgKoreanText   ← 복원 계층 (원본에는 아직 없음)
+  → Viewer2D.load()
+  → slugText (NanumGothic TTF)
+  → WebGL
+```
+
+- **DXF 경로**는 텍스트 파일 디코딩 단계에서 코드페이지를 고려한다.  
+  - 샘플: `src/viewer2d/decodeDxf.ts` (`$DWGCODEPAGE` / 949 → `euc-kr` 등)  
+  - 원본: `hmwebviewer/src/viewerController.ts` 내 유사 `decodeDxf`
+- **DWG 경로**는 바이너리 → WASM → JSON 문자열이며, 파싱 직후 한글 코드페이지 보정 계층이 없었다.
+
+관련 모듈:
+
+| 역할 | 샘플 경로 | 원본 경로 |
+|------|-----------|-----------|
+| DWG 파서 진입점 | `src/viewer2d/dwgParser.ts` | `hmwebviewer/src/viewer2d/dwgParser.ts` |
+| WASM 래퍼 | `src/viewer2d/acadrustParser.ts` | 동일 |
+| 텍스트 렌더 | `src/viewer2d/slugText.ts` | 동일 |
+| 한글 복원 (샘플만) | `src/viewer2d/fixDwgKoreanText.ts` | **없음 → 이식 대상** |
+
+---
+
+## 3. 원인 분석
+
+### 3.1 근본 원인 (Root cause)
+
+**구형/한글 CAD DWG에 저장된 CP949(Windows-949) 계열 바이트 시퀀스를, acadrust 파서(또는 그 문자열 경계)가 Latin-1/바이트-단위 유니코드로 승격해 버린 것.**
+
+즉:
+
+```
+원본 바이트 (CP949)  --잘못된 해석-->  U+00xx Latin-1 문자들  --렌더-->  깨진 화면
+예: EC 8B 9C ... (시) 가  ½ Ã ° ø … 같은 문자로 보임
+```
+
+복원 공식 (검증됨):
+
+```text
+broken.encode('latin1')  →  bytes
+bytes.decode('cp949' | 'euc-kr' | 'windows-949')  →  정상 한글
+```
+
+브라우저/Node `TextDecoder` 라벨 우선순위 (샘플 구현):
+
+1. `cp949`
+2. `windows-949`
+3. `euc-kr`
+
+### 3.2 왜 도면마다 다른가
+
+| 도면 | 파서 직후 TEXT | 원인 해석 |
+|------|----------------|-----------|
+| `BasicSample.dwg` | `설계사`, `시공사` 등 **정상 한글 음절** | 이미 유니코드/UTF 계열로 저장·추출됨 |
+| `C0060203-002-….dwg` | 한글 음절 **0건**, Latin-1 고위 문자 다수 | CP949 레거시 저장 + 오해독 |
+
+동일 뷰어·동일 폰트에서 결과가 갈리므로 **렌더러/폰트 문제가 아님**이 확정된다.
+
+### 3.3 영향 범위 (문자열 필드 전반)
+
+TEXT/MTEXT 본문뿐 아니라 같은 인코딩으로 들어간 메타 문자열도 깨진다.
+
+- `entities[].text` (TEXT / MTEXT / ATTRIB 등)
+- `tables.lineTypes[].description` (예: 중심선, 파선 한글 설명)
+- `tables.blocks[].name` (예: `CXGLOGO-EX흑백` → `CXGLOGO-EXÈæ¹é`)
+- 기타 파서가 문자열로 넘기는 테이블/속성 필드
+
+→ **필드 단위 패치보다 parseResult 트리 전체 문자열 walk** 가 안전하다.
+
+### 3.4 부수 관찰 (이번 깨짐의 주원인은 아님)
+
+| 관찰 | 의미 |
+|------|------|
+| `tables.styles` 가 빈 배열 | 스타일/폰트명(돋움) 정보를 뷰어가 쓰지 못함. 장기 개선 항목 |
+| 뷰어 고정 폰트 `NanumGothic-Regular.ttf` | 한글 글리프 보유. 코드포인트만 맞으면 표시됨 |
+| UI 파일명·OS 경로 한글 | OS 유니코드 경로라 정상일 수 있음. DWG 내부 텍스트와 무관 |
+
+---
+
+## 4. 증거 (재현 절차)
+
+### 4.1 파서만 돌려 TEXT 통계
+
+WASM 초기화 후 `parse_dwg` 결과에서:
+
+```js
+// TEXT/MTEXT 중 한글 음절 포함 여부
+/[\uAC00-\uD7A3]/.test(entity.text)
+```
+
+문제 도면 예 (패치 전):
+
+- hangul: **0**
+- 깨진 Latin: 다수 (`½Ã°ø…` 패턴)
+
+패치 후:
+
+- hangul: 다수 (예: 130)
+- NOTE 샘플: `2. 시공시 막장관찰, 계측분석결과, …`
+- 라인타입: `중심선(일반) Center …`
+- 블록: `CXGLOGO-EX흑백`
+
+### 4.2 단위 변환 검증
+
+| 입력 | `latin1` 바이트 재해석 → CP949 |
+|------|-------------------------------|
+| `½Ã°ø½Ã` | `시공시` |
+| `·Ïº¼Æ®` | `록볼트` |
+| `NOTE` | `NOTE` (변경 없음) |
+| `설계사` | 휴리스틱상 **스킵** (이미 한글) |
+
+### 4.3 음성 대조
+
+`BasicSample.dwg` 에 동일 복원기를 적용해도 `설계사` / `시 공 사` 등이 **변하지 않아야** 한다.
+
+---
+
+## 5. 샘플에 적용한 처리 방법
+
+### 5.1 신규 모듈
+
+`src/viewer2d/fixDwgKoreanText.ts`
+
+- `fixCp949Mojibake(s: string): string`  
+  단일 문자열 복원
+- `fixDwgKoreanText<T>(root: T): T`  
+  parseResult 딥 워크, in-place 수정 후 동일 참조 반환
+
+### 5.2 휴리스틱 (중요 — 정상 도면 보호)
+
+다음이면 **원문 유지**:
+
+1. 빈 문자열
+2. 이미 한글 음절(`U+AC00–U+D7A3`) 또는 자모 포함
+3. 순수 ASCII (모든 코드포인트 ≤ 127)
+4. Latin-1 범위를 넘는 코드포인트 포함 (진짜 유니코드)
+5. 한국 코드페이지 디코더 없음 / 디코드 실패
+6. 디코드 결과에 한글이 **없거나** `U+FFFD` 포함
+
+다음일 때만 **교체**:
+
+- 고위 Latin-1(>127) 포함 **그리고**
+- CP949/EUC-KR 디코드 성공 **그리고**
+- 결과에 한글 음절/자모 포함 **그리고**
+- 치환 문자 없음
+
+### 5.3 삽입 지점
+
+`src/viewer2d/dwgParser.ts`:
+
+```ts
+import { fixDwgKoreanText } from './fixDwgKoreanText';
+
+export async function parseDwgBuffer(bytes: Uint8Array): Promise<CadParseResult> {
+  const { initAcadrustParser, parseDwgAcadrust } = await import('./acadrustParser');
+  await initAcadrustParser();
+  return fixDwgKoreanText(parseDwgAcadrust(bytes));
+}
+```
+
+- Viewer2D / slugText / 폰트 설정 변경 **불필요**
+- DXF 경로 변경 **불필요** (이미 별도 디코드)
+
+### 5.4 왜 WASM 내부 수정이 아닌가 (1차 선택 이유)
+
+| 접근 | 장점 | 단점 |
+|------|------|------|
+| **JS 후처리 (채택)** | 배포 단순, acadrust 크레이트 재빌드 없음, 샘플↔원본 이식 쉬움 | 근본 수정은 아님. 휴리스틱 오탐 가능성(낮음) |
+| acadrust/코드페이지 수정 | 파서 정합 | MPL·Rust/WASM 빌드 체인, 검증 범위 큼 |
+| 스타일→돋움 TTF 매핑 | WYSIWYG 개선 | **이번 mojibake를 해결하지 못함** |
+
+중장기적으로는 WASM/파서가 DWG 코드페이지(또는 문자열 유니코드 플래그)를 올바르게 반영하는 것이 이상적이다.  
+그 전 단계의 **제품 적용 가능한 완화책**이 JS 후처리다.
+
+---
+
+## 6. 원본(`hmwebviewer`) 반영 절차
+
+원본 `src/viewer2d/dwgParser.ts` 는 샘플 패치 전과 동일하게 `parseDwgAcadrust` 결과를 그대로 반환한다.
+
+### 6.1 최소 이식 (권장 1차)
+
+1. 샘플에서 복사  
+   - `dwg-dxf-viewer-sample/src/viewer2d/fixDwgKoreanText.ts`  
+   - → `hmwebviewer/src/viewer2d/fixDwgKoreanText.ts`
+2. `hmwebviewer/src/viewer2d/dwgParser.ts` 에 샘플과 동일하게  
+   `fixDwgKoreanText(parseDwgAcadrust(bytes))` 연결
+3. `parseDwgBuffer` 를 거치지 않는 다른 진입점이 있으면 **동일 후처리** 적용  
+   - 예: 직접 `parseDwgAcadrust` / `parse_dwg` 호출부 검색
+4. 검증  
+   - 문제 DWG: NOTE·공정 문구 한글  
+   - `BasicSample` 또는 기존 유니코드 한글 DWG: 회귀 없음  
+   - 영문·숫자·`Sealing` 등 ASCII 유지
+5. (선택) 단위 테스트  
+   - `fixCp949Mojibake('½Ã°ø½Ã') === '시공시'`  
+   - `fixCp949Mojibake('설계사') === '설계사'`  
+   - `fixCp949Mojibake('NOTE') === 'NOTE'`
+
+### 6.2 동기화 정책
+
+README 기준: `hmwebviewer/src/viewer2d` 가 본가이고 샘플은 형제 복사본이다.  
+이번 이슈는 **샘플에서 먼저 수정**했으므로, 원본 반영 후 필요 시 샘플과 다시 맞춘다.
+
+### 6.3 반영 체크리스트
+
+- [ ] `fixDwgKoreanText.ts` 원본 트리에 추가
+- [ ] `dwgParser.ts` 후처리 연결
+- [ ] 직접 WASM 호출 경로 없음 확인
+- [ ] 문제 한글 DWG 수동 확인
+- [ ] 정상 유니코드 한글 DWG 회귀 확인
+- [ ] (선택) DXF ANSI_949 도면도 기존 `decodeDxf` 동작 유지 확인
+- [ ] (선택) `tables.styles` / 폰트 매핑은 **별 이슈**로 분리
+
+---
+
+## 7. 하지 말아야 할 것
+
+| 비권장 | 이유 |
+|--------|------|
+| 돋움 TTF만 추가하고 끝 | 문자열이 깨진 상태면 돋움으로도 동일 mojibake |
+| 모든 문자열을 무조건 CP949 디코드 | 정상 유니코드·라틴 확장 도면 손상 |
+| 렌더러에서 글리프 폴백만 강화 | 코드포인트 자체가 틀림 |
+| `dist` 만 수동 패치 | 소스는 `src/`; 빌드 산출물에만 고치면 재빌드 시 소실 |
+
+---
+
+## 8. 잔여 이슈 / 후속 과제
+
+1. **파서 본가 수정**  
+   acadrust(또는 문자열 추출 경로)에서 DWG 코드페이지·유니코드 플래그 반영 → JS 휴리스틱 제거 가능 여부 검토
+2. **STYLE 테이블**  
+   현재 `tables.styles` 가 비어 스타일/폰트명 미노출. 돋움 등 CAD 지정 폰트 매핑은 별 과제
+3. **다른 코드페이지**  
+   일본(932)/중국(936)/대만(950) 도면에 동일 패턴이 있으면 라벨 확장 + 문자 체계 휴리스틱 필요 (현 구현은 **한글 음절 출현** 조건으로 한국 도면에 한정)
+4. **ATTRIB / 치수 상주 텍스트 등**  
+   딥 워크로 대부분 커버되나, 바이너리/비문자열 필드는 대상 외
+
+---
+
+## 9. 한 줄 요약
+
+> **폰트 폴더 문제가 아니라, 구형 한글 DWG의 CP949 바이트가 Latin-1 문자열로 올라온 인코딩 오해독이다.  
+> `parse_dwg` 직후 문자열 트리를 CP949로 재해석(이미 한글인 값은 스킵)하면 해결되며,  
+> 원본 `hmwebviewer` 에는 샘플의 `fixDwgKoreanText.ts` + `dwgParser.ts` 연결을 그대로 이식하면 된다.**
+
+---
+
+## 10. 참고 파일 (샘플)
+
+- 복원 구현: [`../src/viewer2d/fixDwgKoreanText.ts`](../src/viewer2d/fixDwgKoreanText.ts)
+- 연결부: [`../src/viewer2d/dwgParser.ts`](../src/viewer2d/dwgParser.ts)
+- DXF 쪽 코드페이지 처리(대조): [`../src/viewer2d/decodeDxf.ts`](../src/viewer2d/decodeDxf.ts)
+- 모듈 지도: [`modules-dwg-dxf.html`](./modules-dwg-dxf.html)
diff --git a/docs/model-paper-space.md b/docs/model-paper-space.md
new file mode 100644
index 0000000..d0c3394
--- /dev/null
+++ b/docs/model-paper-space.md
@@ -0,0 +1,370 @@
+# Model / Layout (Paper) 뷰어 이슈 — 원인 분석 및 처리 이력
+
+| 항목 | 내용 |
+|------|------|
+| 작성 목적 | 샘플에서 재현·수정한 이슈를 **원본 `hmwebviewer`** 에 이식하기 위한 기술 메모 |
+| 샘플 | `dwg-dxf-viewer-sample` |
+| 원본 | `hmwebviewer` (`src/viewer2d/` …) |
+| 주 재현 도면 | `C0060202-001-평면및종단면도(1)(대산방향STA.18+492.08-19+411.50).dwg` |
+| 관련 도면 | `C0060203-*`, `BasicSample.dwg` (회귀) |
+| 최종 정리 | 2026-07-29 |
+| 상태 | **샘플 패치 완료** / 원본 뷰어 UI·Viewer2D 이식은 확인 후 |
+
+### 제약
+
+| 대상 | 정책 |
+|------|------|
+| **오픈소스 파서 본체 (acadrust 등 crates.io)** | **수정 금지** (unmodified 사용) |
+| SORTENTSTABLE / 헤더 확장 export | 파서 수정 없이 **뷰어 규칙으로 대체** |
+| 한글 인코딩 (CP949 mojibake) | 별도 문서 [`korean-dwg-text-encoding.md`](./korean-dwg-text-encoding.md) — **본 문서와 독립, 둘 다 필요** |
+
+---
+
+## 0. 이슈 한눈에 보기
+
+| # | 증상 | 원인 | 처리 (샘플) | 수정 위치 |
+|---|------|------|-------------|-----------|
+| 1 | 글자·선이 한곳에 뒤섞여 겹침 | Model + Paper 동시 렌더 | 공간 필터 + Model/Layout 탭 | `cadSpaces.ts`, `Viewer2D.js`, `main.ts`, `index.html` |
+| 2 | Layout에 도곽만 있고 평면/종단 비어 있음 | VIEWPORT 미투영 | Layout 시 Model을 VP 창에 투영·클립 | `Viewer2D.js` |
+| 3 | Fit / 좌표가 CAD와 다름, (0,0)에 없음 | WCS 표시 + 이상치 bbox | **Model UCS 좌표** + 백분위 Fit | `Viewer2D.js` |
+| 4 | 선형·종단에서 글자만 거대 | `minTextH = diag×0.0002` ≈ 250u | `min(diag×0.0002, medianHeight)` | `Viewer2D.js` |
+| 5 | Layout에서 VP 내용이 도곽·주석 위 | VP를 paper 뒤에 append | VP 먼저 + `z=-1` + underlay 텍스트 | `Viewer2D.js` |
+| 6 | 커서 좌표 표시 | — | 우하단 X/Y (Model=UCS) | `#coords`, `screenToWorld` |
+
+---
+
+## 1. DWG 공간 개념 (배경)
+
+| 공간 | 블록 이름 예 | 역할 |
+|------|----------------|------|
+| Model Space | `*Model_Space` | 실좌표(측량 등) 본도면 |
+| Paper Space / Layout | `*Paper_Space`, `*Paper_Space0`… | 출력 시트, 도곽, 주석, VIEWPORT |
+
+- 엔티티 `ownerHandle` → 소속 블록 핸들.
+- Layout은 보통 **VIEWPORT** 로 Model 일부를 시트 좌표에 투영한다.
+- Model에는 **원거리 이중 좌표**가 흔함 (예: 원점 근처 종단 + X≈-436k 근처 선형).
+
+### 재현 도면 규모 (C0060202-001, 참고)
+
+| Space | handle (dec / hex) | 엔티티 수 (대략) | 좌표 |
+|-------|--------------------|------------------|------|
+| `*Model_Space` | 31 / `1f` | ~17,377 | 측량·다중 군집 |
+| `*Paper_Space` | 210 / `d2` | ~200+ | 시트 (~1.7e3–2.6e3) |
+| VIEWPORT | paper 소유 | 3 | overall 1 + 종단·평면 창 2 |
+
+---
+
+## 2. 이슈 #1 — Model + Paper 동시 렌더
+
+### 2.1 현상
+
+다색 TEXT가 중앙에 뭉치고, 기하·주석이 읽기 불가.  
+CAD에서는 Layout 활성 시 정상 시트.
+
+### 2.2 원인
+
+기존 `Viewer2D.load()`:
+
+1. `*Model_Space` / `*Paper_Space` 를 space 로 인식
+2. **사용자 블록 정의**만 메인 루프에서 스킵 (INSERT 전개용)
+3. Model·Paper **둘 다** 메인 루프에서 그림
+
+→ 좌표계·스케일이 다른 두 공간을 한 씬에 합치고 `fit()` → 파국.
+
+### 2.3 처리
+
+| 파일 | 내용 |
+|------|------|
+| `src/viewer2d/cadSpaces.ts` | `listCadSpaces`, `pickDefaultSpace`, `buildAllowedOwnerHexes` |
+| `Viewer2D.js` | `allowedOwners` 필터, `setSpace` / `getSpaces` / `getActiveSpace` |
+| `main.ts` + `index.html` | **Model / Layout** 탭, 로드 시 기본 공간 |
+
+**기본 탭:** Paper에 엔티티 있으면 Layout, 없으면 Model.
+
+```
+C0060202-001 → Layout
+BasicSample (paper 0) → Model
+```
+
+---
+
+## 3. 이슈 #2 — Layout이 비어 보임 (VIEWPORT)
+
+### 3.1 현상
+
+공간 분리 후 Layout은 도곽·주석만 있고, CAD처럼 평면·종단이 없음.
+
+### 3.2 원인
+
+- Paper 엔티티만으로는 시트 장식/주석 수준.
+- 본도면은 Model에 있고, CAD는 **VIEWPORT** 로 비춤.
+- 뷰어가 Layout에서 Model을 VP에 투영하지 않으면 창이 비어 보임.
+
+### 3.3 VIEWPORT 데이터
+
+acadrust 타입에는 `Viewport` 가 있음.  
+뷰어는 parseResult 의 `type: "VIEWPORT"` 필드를 사용한다.
+
+재현 도면 VP 예:
+
+| 역할 | size (대략) | twist | 비고 |
+|------|-------------|-------|------|
+| overall paper | 시트 전체 | 0 | 스킵 (모델 창 아님) |
+| 종단 창 | ~840×302 | 0 | Model 투영 |
+| 평면 창 | ~840×215 | ~1.28 rad | Model 투영 |
+
+**overall 판별:** `id===1` 또는 (scale≈1 ∧ viewTarget≈0 ∧ viewCenter≈paper center).
+
+### 3.4 처리 (`Viewer2D.js`)
+
+Layout 활성 시:
+
+1. (순서: 아래 이슈 #5) Model을 각 활성 VIEWPORT에 투영
+2. 변환 (2D / top, ODA·acadrust writer 규약):
+
+```
+DCS   = R(+twist) * (model − viewTarget)
+paper = center + (paperHeight / viewHeight) * (DCS − viewCenter)
+```
+
+3. paper 사각형 Cohen–Sutherland 클리핑  
+4. `_isModelViewport` / `_viewportModelToPaper` / `_emitModelThroughViewport`
+
+### 3.5 파서 정책
+
+- **acadrust(오픈소스 본체)는 수정하지 않는다.**
+- VIEWPORT JSON 방출이 래퍼/기존 빌드에 이미 있으면 뷰어만 사용.
+- 추가 파서 기능(SORTENTS 등)은 **넣지 않음** → 뷰어 규칙으로 충분.
+
+---
+
+## 4. 이슈 #3 — Zoom Fit
+
+### 4.1 확정: 가시 엔티티 AABB
+
+| 항목 | 내용 |
+|------|------|
+| 범위 | 활성 Model/Layout + 숨긴 레이어 제외, 렌더 시 `expand` |
+| 이상치 | 샘플 **0.5%–99.5%** 로 극단 점 제거 → `_contentBox` |
+| `fit()` | **`_contentBox` 우선** (씬 재계산보다 로드 시점과 동일) |
+
+### 4.2 가로로 매우 긴 Model (C0060202 / bb.dwg)
+
+실측 기하(백분위 후) 대략:
+
+| | WCS | CAD UCS |
+|--|-----|---------|
+| 폭 | ~438 000 | ~-437 000 … ~1 000 |
+| 높이 | **~2 900** | ~-2 950 … 0 |
+| 종횡비 | **~150 : 1** | |
+
+화면 비율(~2:1)로 **classic contain** 하면:
+
+- 세로 시야를 폭에 맞춰 키움 → 내용 높이가 화면의 **~1%**  
+- **수 픽셀 두께의 가로 선**처럼 보임 (하늘색 박스도 상단에 얇은 선)
+
+`bb.dwg`는 같은 종횡비의 단순 박스 2개라 식별 가능했고, 원본 1.7만 엔티티는 한 줄로 뭉개짐.
+
+### 4.3 처리 (극단 스트립 Fit)
+
+```
+contentAspect = bw / bh
+if contentAspect > screenAspect × 8:   // 매우 가로로 김
+    vh = bh × pad          // Y를 화면에 채움
+    vw = vh × screenAspect // 좌우는 잘라 보고 패닝
+else if contentAspect < screenAspect / 8:
+    // 매우 세로로 김 → 폭 채움
+else:
+    // 일반 contain
+```
+
+→ 선형/종단 구간이 **세로로 화면에 채워짐**. 전체 연장은 좌우 팬.
+
+CAD status 참고 extents(Y ±10만)와 파서 실측(Y 약 3천)이 다를 수 있음 — Fit은 **파서가 그린 가시 점** 기준.
+
+---
+
+## 5. 이슈 #4 — 글자만 거대 (minTextH)
+
+### 5.1 현상
+
+선형(~-436802, -1949) 및 종단 근처에서 `MOT`/`FLOW`/수치가 등고선보다 훨씬 큼.
+
+### 5.2 원인
+
+| 항목 | C0060202-001 Model |
+|------|---------------------|
+| CAD TEXT height | ~0.3 ~ 3.5 (중앙값 ~3, FLOW≈0.3) |
+| 전체 bbox 대각선 | ~1.25×10⁶ |
+| 구 `minTextH = diag × 0.0002` | **~250** |
+
+`_drawTexts` → `Math.max(t.height, minTextH)` 로 **모든 라벨이 높이 ~250** 강제.
+
+작은 시트 도면용 “fit 시 가독성” floor가 측량 Model에서 폭주한 것.
+
+### 5.3 처리
+
+```js
+minTextH = Math.min(diagSize * 0.0002, medianNativeHeight);
+```
+
+- 측량 Model: floor ≤ median → **사실상 CAD 높이 유지**
+- 작은 용지 좌표: diag floor가 작으면 기존과 유사
+
+---
+
+## 6. 이슈 #5 — Layout draw order (VIEWPORT가 위)
+
+### 6.1 현상
+
+VIEWPORT로 올린 Model 기하/라벨이 **도곽·NOTE 위**에 그려짐.
+
+### 6.2 원인 (뷰어)
+
+기존: paper 패스 후 VP 투영을 **버퍼 뒤**에 append → VP가 위.
+
+### 6.3 DWG draw-order 메타 (참고만)
+
+| 소스 | 의미 | 정책 |
+|------|------|------|
+| `SORTENTSTABLE` / `ACAD_SORTENTS` | sort handle 낮을수록 아래 | acadrust에 타입 있음 |
+| Header `SORTENTS` | 정렬 플래그 | — |
+| parseResult 엔티티 | zOrder 등 **없음** | — |
+
+**오픈소스 파서를 고치지 않으므로 SORTENTS export는 하지 않는다.**  
+Layout 관례로 고정:
+
+> **VIEWPORT 안 Model 내용 < Paper 주석·도곽**
+
+### 6.4 처리
+
+1. VP Model 투영을 **paper 엔티티 루프보다 먼저** 방출  
+2. VP 선분 `z = -1`, paper `z = 0` (카메라 +Z 기준 뒤/앞)  
+3. 텍스트: `underlay` (VP) / 일반 (paper) 분리, `renderOrder` 0 → 1  
+4. slug/스프라이트 배치도 underlay 먼저 추가  
+
+---
+
+## 7. 커서 좌표 / Fit 좌표계 (UCS)
+
+### 7.1 현상
+
+- Model에서 우하단 좌표로 (0,0) 근처를 찾아도 기하가 없음  
+- Fit 후 표시 좌표가 CAD status bar 와 다름  
+
+### 7.2 원인
+
+| 프레임 | 내용 |
+|--------|------|
+| 기하 저장 (파서 WCS) | 예: 선형 클러스터 ≈ (162065, 476725) |
+| CAD Model UCS 원점 (`vars.ucsOrigin`) | ≈ (598948, 478643) |
+| CAD에 보이는 좌표 | `UCS = WCS − ucsOrigin` → 선형 ≈ **(-436883, -1918)** |
+
+뷰어가 **WCS를 그대로** 읽어 주면 CAD 사용자 좌표와 어긋난다.  
+또한 Fit bbox에 극단 이상치(수 점)가 포함되면 중심이 빈 공간으로 갈 수 있다.
+
+CAD 참고 extents (Model, 사용자 측정):
+
+```
+X: -439601.13 … 4412.05
+Y: -100418.91 … 99422.03
+```
+
+### 7.3 처리
+
+1. **좌표 표시 (Model):** WCS → **model UCS**  
+   `cad = project(WCS − ucsOrigin)` (축 단위 직교 시 subtract origin)  
+   Layout/Paper: identity (시트 좌표)  
+2. **Pick/measure:** 내부 **WCS** (`_screenToWcs`)  
+3. **Fit:** 가시 기하 **0.5%–99.5% 백분위** AABB (이상치 제거)  
+4. 스크린→WCS: ortho frustum × camera right/up (view-twist 포함)
+
+### 7.4 검증용 심플 도면 `bb.dwg`
+
+Model 엔티티 5개 (사각형 2 + 연결 poly + hatch 2). `ucsOrigin ≈ (598948, 478643)`.
+
+| 덩어리 | WCS (대략) | CAD UCS (대략) |
+|--------|------------|----------------|
+| 선형 쪽 박스 | (161969…162448, 475696…476795) | **(-436979…-436500, -2947…-1848)** |
+| 원점 쪽 박스 | (598948…600030, 477765…478643) | **(0…1081, -878…0)** — **UCS (0,0)에 모서리** |
+| Fit CAD 범위 | — | X ≈ -436979…1081, Y ≈ -2947…0 |
+
+**확인 절차**
+
+1. `bb.dwg` 열기 → **Model** 탭 (기본이 Layout이면 반드시 Model로)  
+2. Fit → 우하단 좌표가 대략 위 UCS 범위 안  
+3. 커서 오른쪽 박스 모서리 ≈ **X=0, Y=0**  
+4. 왼쪽 박스 ≈ **X=-436900, Y=-2400** 부근  
+
+CAD WCS (0,0) 에는 기하가 없음. CAD status의 (0,0)은 **UCS 원점**이다.
+
+---
+
+## 8. 검증 체크리스트
+
+| 확인 | 기대 |
+|------|------|
+| C0060202-001 기본 탭 | Layout |
+| Layout | 도곽 + 평면/종단 VP, 주석이 VP 위, 한글(인코딩 패치 병행) |
+| Model | ~17k 엔티티, 공간 필터로 paper 제외 |
+| Fit | **현재 가시** 전체 AABB (이중 좌표면 둘 다 포함) |
+| Model 줌 인 선형/종단 | 글자 크기 ≈ CAD (거대 빌보드 없음) |
+| BasicSample | Model 기본, 회귀 없음 |
+| 우하단 Model | 커서 좌표 ≈ CAD UCS (선형 ~-436k 등) |
+| Fit 후 중심 | 빈 (0,0) WCS 가 아닌 실제 기하 범위 |
+
+---
+
+## 9. 원본 `hmwebviewer` 이식 가이드
+
+| 순서 | 작업 |
+|------|------|
+| 1 | `cadSpaces.ts` 신규 복사 |
+| 2 | `Viewer2D.js` — 공간 필터, VP 투영, draw order, minTextH, fit/AABB, 좌표 API **diff 이식** (통째 덮어쓰기 비권장) |
+| 3 | `Viewer2D.d.ts` 동기화 |
+| 4 | 호스트 UI: Model/Layout 탭, `pickDefaultSpace` + `spaceHandle` |
+| 5 | (선택) 우하단 좌표 표시 |
+| 6 | `fixDwgKoreanText` 는 [한글 문서](./korean-dwg-text-encoding.md) 대로 별도 |
+| 7 | C0060202-001 + BasicSample 회귀 |
+
+**하지 말 것**
+
+| 금지 | 이유 |
+|------|------|
+| acadrust 등 오픈소스 파서 수정 | 정책 |
+| SORTENTS를 위해 파서 개조 | 뷰어 규칙으로 대체 |
+| Model+Paper 동시 렌더 복귀 | 이슈 #1 재발 |
+| 밀도 기반 Fit 재도입 | 이슈 #3 에서 철회 |
+| `minTextH = diag×0.0002` 단독 | 이슈 #4 재발 |
+
+---
+
+## 10. 잔여 / 후속 (뷰어 측만)
+
+1. VIEWPORT 안 솔리드 HATCH/SOLID — 윤곽 위주 근사  
+2. 다중 named Layout 탭 캡션 (블록명 `*Paper_Space*` 이상)  
+3. TILEMODE/CTAB 을 파서 없이 알 수 없으면 현재 휴리스틱 유지  
+4. 비직교 VIEWPORT (3D viewDirection)  
+5. (선택) Model 이중 군집 점프 UI  
+6. (선택) Fit “전체/선택” 분리는 요구 시만  
+
+---
+
+## 11. 한 줄 요약
+
+> **Model/Paper를 나눠 그리고, Layout은 VIEWPORT로 Model을 투영하되 paper 아래에 깐다.  
+> Fit은 가시 엔티티 bbox. 글자 높이는 CAD median을 넘기지 않는다.  
+> 오픈소스 파서는 수정하지 않으며, draw-order는 Layout 관례로 처리한다.**
+
+---
+
+## 12. 참고 파일 (샘플)
+
+| 경로 | 역할 |
+|------|------|
+| [`../src/viewer2d/cadSpaces.ts`](../src/viewer2d/cadSpaces.ts) | 공간 목록·기본 탭·owner 클로저 |
+| [`../src/viewer2d/Viewer2D.js`](../src/viewer2d/Viewer2D.js) | 필터, VP 투영, draw order, minTextH, fit, 좌표 |
+| [`../src/viewer2d/Viewer2D.d.ts`](../src/viewer2d/Viewer2D.d.ts) | 타입 |
+| [`../src/main.ts`](../src/main.ts) | 탭·좌표 UI 글루 |
+| [`../index.html`](../index.html) | `#spaces`, `#coords` |
+| [`korean-dwg-text-encoding.md`](./korean-dwg-text-encoding.md) | CP949 한글 깨짐 (병행 필수) |
diff --git a/index.html b/index.html
index 8dc5c40..ee53235 100644
--- a/index.html
+++ b/index.html
@@ -59,6 +59,43 @@
     #layers h3 { margin: 0 0 8px; font-size: 11px; letter-spacing: .08em; text-transform: uppercase; color: var(--muted); }
     #layers label { display: flex; gap: 8px; align-items: center; margin: 4px 0; cursor: pointer; }
     #layers .swatch { width: 10px; height: 10px; border-radius: 2px; flex-shrink: 0; }
+    #spaces {
+      display: none; align-items: center; gap: 0;
+      background: var(--panel); border: 1px solid var(--line); border-radius: 8px;
+      overflow: hidden;
+    }
+    #spaces button {
+      border: none; border-radius: 0; border-right: 1px solid var(--line);
+      background: transparent; padding: 8px 12px; margin: 0;
+    }
+    #spaces button:last-child { border-right: none; }
+    #spaces button.active {
+      background: #238636; border-color: #2ea043; color: #fff;
+    }
+    #spaces button:hover:not(.active) { border-color: transparent; color: var(--accent); }
+    /* CAD 좌표 — 항상 우측 하단 (툴바 status 와 별개) */
+    #coords {
+      position: fixed;
+      right: 12px;
+      bottom: 12px;
+      left: auto;
+      top: auto;
+      z-index: 20;
+      font: 13px/1.35 var(--mono);
+      color: var(--ink);
+      background: rgba(13,17,23,.95);
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 10px 14px;
+      min-width: 240px;
+      text-align: left;
+      pointer-events: none;
+      letter-spacing: 0.02em;
+      box-shadow: 0 8px 28px rgba(0,0,0,.45);
+      user-select: none;
+    }
+    #coords .lbl { color: var(--accent); margin-right: 6px; font-weight: 600; }
+    #coords .sep { color: var(--line); margin: 0 12px; }
   </style>
 </head>
 <body>
@@ -71,12 +108,19 @@
     </label>
     <button id="sample" class="primary wasm" type="button" title="acadrust-dwg WASM">Sample DWG</button>
     <button id="sampleDxf" class="primary" type="button" title="dxf-parser">Sample DXF</button>
+    <div id="spaces" title="Model Space / Paper Space (Layout)"></div>
     <button id="fit" type="button">Fit (F)</button>
     <button id="theme" type="button">Theme</button>
     <button id="layersBtn" type="button">Layers</button>
     <div id="status">ready</div>
   </div>
 
+  <div id="coords" title="마우스 위치 CAD 좌표 (Model=UCS, Layout=Paper 도면단위)">
+    <span class="lbl">X</span><span id="coordX">—</span>
+    <span class="sep">|</span>
+    <span class="lbl">Y</span><span id="coordY">—</span>
+  </div>
+
   <div id="layers"><h3>Layers</h3><div id="layerList"></div></div>
 
   <aside id="recipe">
diff --git a/public/samples/C0060203-001-표준단면도(2차로,자연환기300m이상).dwg b/public/samples/C0060203-001-표준단면도(2차로,자연환기300m이상).dwg
new file mode 100644
index 0000000..a8ec60d
Binary files /dev/null and b/public/samples/C0060203-001-표준단면도(2차로,자연환기300m이상).dwg differ
diff --git a/public/samples/bb.dwg b/public/samples/bb.dwg
new file mode 100644
index 0000000..438112c
Binary files /dev/null and b/public/samples/bb.dwg differ
diff --git a/src/main.ts b/src/main.ts
index a6e170c..26aa81a 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -24,6 +24,7 @@ import { Viewer2D } from './viewer2d/Viewer2D.js';
 import { parseDwgBuffer, type CadParseResult } from './viewer2d/dwgParser';
 import { parseDxfBuffer } from './viewer2d/parseDxf';
 import { is2D, isDxf, isDwg } from './viewer2d/ext2d';
+import { listCadSpaces, pickDefaultSpace } from './viewer2d/cadSpaces';
 import { setDefaultFontUrl } from './viewer2d/slugText';
 
 // parseDxfBuffer 내부:
@@ -39,6 +40,7 @@ const app = document.getElementById('app')!;
 const statusEl = document.getElementById('status')!;
 const layerList = document.getElementById('layerList')!;
 const layersPanel = document.getElementById('layers')!;
+const spacesBar = document.getElementById('spaces')!;
 
 function setStatus(msg: string, err = false) {
   statusEl.textContent = msg;
@@ -55,6 +57,54 @@ viewer.onSelect((entity: unknown) => {
   setStatus(`select ${e.type ?? '?'} · layer=${e.layer ?? '-'} · h=${e.handle?.value ?? '-'}`);
 });
 
+// CAD coordinates under the cursor (Model: UCS like AutoCAD; Layout: paper units)
+const coordXEl = document.getElementById('coordX')!;
+const coordYEl = document.getElementById('coordY')!;
+function formatCadCoord(v: number): string {
+  const a = Math.abs(v);
+  if (a >= 1e6) return v.toFixed(1);
+  if (a >= 1e3) return v.toFixed(2);
+  if (a >= 1) return v.toFixed(3);
+  return v.toFixed(4);
+}
+viewer.onPointerWorld((p) => {
+  if (!p) {
+    coordXEl.textContent = '—';
+    coordYEl.textContent = '—';
+    return;
+  }
+  coordXEl.textContent = formatCadCoord(p.x);
+  coordYEl.textContent = formatCadCoord(p.y);
+});
+
+/** Model / Layout tab strip after each load or space switch. */
+function fillSpaces() {
+  const spaces = viewer.getSpaces();
+  const active = viewer.getActiveSpace();
+  spacesBar.innerHTML = '';
+  if (spaces.length < 2 && !(spaces[0]?.entityCount)) {
+    spacesBar.style.display = 'none';
+    return;
+  }
+  spacesBar.style.display = 'flex';
+  for (const s of spaces) {
+    const btn = document.createElement('button');
+    btn.type = 'button';
+    btn.textContent = `${s.label}${s.entityCount ? ` (${s.entityCount})` : ''}`;
+    btn.title = `${s.name} · handle ${s.handleHex}`;
+    if (s.handleHex === active) btn.classList.add('active');
+    btn.addEventListener('click', () => {
+      if (s.handleHex === viewer.getActiveSpace()) return;
+      viewer.setSpace(s.handleHex);
+      fillSpaces();
+      fillLayers();
+      viewer.fit();
+      setStatus(`space ${s.label} · ${s.entityCount} entities`);
+    });
+    spacesBar.append(btn);
+  }
+}
+
 // ── ④ 파서 조합 ─────────────────────────────────────────────────
 async function parseCad(buf: ArrayBuffer, name: string): Promise<CadParseResult> {
   if (isDxf(name)) return parseDxfBuffer(buf);
@@ -68,7 +118,9 @@ async function parseCad(buf: ArrayBuffer, name: string): Promise<CadParseResult>
 
 async function loadAndRender(buf: ArrayBuffer, name: string): Promise<CadParseResult> {
   const result = await parseCad(buf, name);
-  viewer.load(result);
+  const spaces = listCadSpaces(result);
+  const def = pickDefaultSpace(spaces);
+  viewer.load(result, { spaceHandle: def?.handleHex ?? null });
   viewer.resize();
   return result;
 }
@@ -113,7 +165,12 @@ function fillLayers() {
 }
 
 async function afterLoad(name: string, result: CadParseResult) {
-  setStatus(`✓ ${name} · ${result.entities?.length ?? 0} entities`);
+  // Force cache invalidation for OLE image rendering
+  const spaces = listCadSpaces(result);
+  const active = spaces.find((s) => s.handleHex === viewer.getActiveSpace());
+  const spaceNote = active ? ` · ${active.label}` : '';
+  setStatus(`✓ ${name} · ${result.entities?.length ?? 0} entities${spaceNote}`);
+  fillSpaces();
   fillLayers();
   viewer.fit();
 }
diff --git a/src/viewer2d/Viewer2D.d.ts b/src/viewer2d/Viewer2D.d.ts
index 05ea56c..a8a60a0 100644
--- a/src/viewer2d/Viewer2D.d.ts
+++ b/src/viewer2d/Viewer2D.d.ts
@@ -1,9 +1,11 @@
 // Types for the ported JS 2D engine (Viewer2D.js). Colocated so tsc resolves
 // `./Viewer2D.js` imports without allowJs. Only the methods the app uses are typed.
+import type { CadSpace } from './cadSpaces';
+
 export class Viewer2D {
   constructor(container: HTMLElement);
   /** Render a DWG/DXF parseResult. `keepView` preserves pan/zoom on re-render. */
-  load(result: unknown, opts?: { keepView?: boolean }): void;
+  load(result: unknown, opts?: { keepView?: boolean; spaceHandle?: string | number | null }): void;
   /** Zoom-extents to the loaded drawing. */
   fit(): void;
   /** Resync renderer/camera to the container size (call after un-hiding). */
@@ -13,8 +15,17 @@ export class Viewer2D {
   setGrid(visible: boolean): void;
   getLayerInfo(): { name: string; colorHex: string; count: number; visible: boolean }[];
   setHiddenLayers(nameSet: Set<string>): void;
+  /** Model / Paper (Layout) spaces for the loaded drawing. */
+  getSpaces(): CadSpace[];
+  getActiveSpace(): string | null;
+  /** Switch Model ↔ Layout; re-renders (fit unless keepView). */
+  setSpace(spaceHandle: string | number | null, opts?: { keepView?: boolean }): void;
   getZoomPercent(): number;
   onViewChange(cb: () => void): void;
+  /** Screen client coords → drawing world (Z=0 plane). */
+  screenToWorld(clientX: number, clientY: number): { x: number; y: number; z: number } | null;
+  /** Live CAD coords under the cursor; null when pointer leaves the canvas. */
+  onPointerWorld(cb: ((p: { x: number; y: number; z: number } | null) => void) | null): void;
   startMeasure(cb: (r: { phase: string; ax: number; ay: number; az: number; bx: number; by: number; bz: number; d: number }) => void): void;
   stopMeasure(): void;
 }
diff --git a/src/viewer2d/Viewer2D.js b/src/viewer2d/Viewer2D.js
index f70e9fb..14df97a 100644
--- a/src/viewer2d/Viewer2D.js
+++ b/src/viewer2d/Viewer2D.js
@@ -9,6 +9,7 @@
 import * as THREE from 'three';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
 import { aciToHex } from './aciColors.js';
+import { buildAllowedOwnerHexes, listCadSpaces } from './cadSpaces';
 import { SlugTextEngine, SlugTextBatch } from './slugText';
 
 const DEFAULT_COLOR = 0xc9d1d9;
@@ -89,9 +90,22 @@ export class Viewer2D {
       if (e.button === 1) e.preventDefault();
     });
     this._renderer.domElement.addEventListener('click', (e) => this._onClick(e));
+    this._renderer.domElement.addEventListener('pointermove', (e) => this._onPointerMove(e));
+    this._renderer.domElement.addEventListener('pointerleave', () => {
+      if (this._onPointerWorldCb) this._onPointerWorldCb(null);
+    });
     this._selColor = { r: 0xd8 / 255, g: 0x3a / 255, b: 0x2f / 255 };
     this._gridVisible = false;
     this._gridMesh = null;
+    /** @type {string|null} active Model/Paper space handle hex; null = no space filter */
+    this._activeSpaceHex = null;
+    /** @type {null|((p:{x:number,y:number,z:number}|null)=>void)} */
+    this._onPointerWorldCb = null;
+    this._ptrWorldTmp = new THREE.Vector3();
+    // Display frame for coordinates (Model UCS vs WCS). Paper uses identity.
+    this._coordOrigin = { x: 0, y: 0, z: 0 };
+    this._coordXAxis = { x: 1, y: 0, z: 0 };
+    this._coordYAxis = { x: 0, y: 1, z: 0 };
     this._controls.addEventListener('change', () => { if (this._gridVisible) this._rebuildGrid(); });
     this._animate();
   }
@@ -101,10 +115,130 @@ export class Viewer2D {
   setZoomSpeed(speed) { if (this._controls) this._controls.zoomSpeed = speed; }
   getZoomSpeed() { return this._controls ? this._controls.zoomSpeed : 1.0; }
 
+  /**
+   * Subscribe to mouse world-coordinate updates (CAD WCS / drawing units).
+   * Callback receives `{ x, y, z }` or `null` when the pointer leaves the canvas.
+   */
+  onPointerWorld(cb) { this._onPointerWorldCb = cb || null; }
+
+  /**
+   * Convert browser client coords → **CAD display** coordinates (Z=0 plane).
+   * Model Space: model UCS (matches AutoCAD status bar when UCS = drawing UCS).
+   * Paper/Layout: paper drawing units (identity).
+   * Pick/measure still use raw WCS via `_screenToWcs`.
+   */
+  screenToWorld(clientX, clientY) {
+    const wcs = this._screenToWcs(clientX, clientY);
+    if (!wcs) return null;
+    return this._wcsToCad(wcs.x, wcs.y);
+  }
+
+  /**
+   * Raw WCS (geometry storage frame) under the cursor.
+   * Ortho 2D: map NDC through camera right/up axes (handles view-twist up vector).
+   */
+  _screenToWcs(clientX, clientY) {
+    const el = this._renderer?.domElement;
+    const cam = this._camera;
+    if (!el || !cam) return null;
+    const rect = el.getBoundingClientRect();
+    if (rect.width < 1 || rect.height < 1) return null;
+
+    cam.updateMatrixWorld(true);
+    const ndcX = ((clientX - rect.left) / rect.width) * 2 - 1;
+    const ndcY = -((clientY - rect.top) / rect.height) * 2 + 1;
+
+    // Orthographic frustum half-sizes in world units (respect zoom).
+    const zoom = cam.zoom || 1;
+    const halfW = ((cam.right - cam.left) * 0.5) / zoom;
+    const halfH = ((cam.top - cam.bottom) * 0.5) / zoom;
+
+    // Camera basis in world (columns of matrixWorld).
+    const te = cam.matrixWorld.elements;
+    const rx = te[0], ry = te[1]; // camera local +X (right)
+    const ux = te[4], uy = te[5]; // camera local +Y (up)
+    // Anchor on the look target (z=0 plane), not camera.position.z
+    const tx = this._controls?.target?.x ?? cam.position.x;
+    const ty = this._controls?.target?.y ?? cam.position.y;
+
+    return {
+      x: tx + ndcX * halfW * rx + ndcY * halfH * ux,
+      y: ty + ndcX * halfW * ry + ndcY * halfH * uy,
+      z: 0,
+    };
+  }
+
+  /** WCS → CAD display (model UCS when axes are available). */
+  _wcsToCad(wx, wy) {
+    const o = this._coordOrigin || { x: 0, y: 0 };
+    const xx = this._coordXAxis || { x: 1, y: 0 };
+    const yy = this._coordYAxis || { x: 0, y: 1 };
+    const dx = wx - (o.x || 0);
+    const dy = wy - (o.y || 0);
+    // Orthogonal axes: project onto X/Y directions (identity → subtract origin).
+    return {
+      x: dx * (xx.x || 0) + dy * (xx.y || 0),
+      y: dx * (yy.x || 0) + dy * (yy.y || 0),
+      z: 0,
+    };
+  }
+
+  /** Configure coordinate readout frame for the active space. */
+  _setCoordFrame(result) {
+    const spaces = listCadSpaces(result);
+    const active = spaces.find((s) => s.handleHex === this._activeSpaceHex);
+    const vars = result?.vars || {};
+    // Model: AutoCAD status bar uses model UCS origin/axes when set.
+    // Paper: sheet coordinates — identity.
+    if (active?.kind === 'model' && vars.ucsOrigin) {
+      this._coordOrigin = {
+        x: vars.ucsOrigin.x || 0,
+        y: vars.ucsOrigin.y || 0,
+        z: vars.ucsOrigin.z || 0,
+      };
+      this._coordXAxis = vars.ucsXAxis || { x: 1, y: 0, z: 0 };
+      this._coordYAxis = vars.ucsYAxis || { x: 0, y: 1, z: 0 };
+    } else {
+      this._coordOrigin = { x: 0, y: 0, z: 0 };
+      this._coordXAxis = { x: 1, y: 0, z: 0 };
+      this._coordYAxis = { x: 0, y: 1, z: 0 };
+    }
+  }
+
+  _onPointerMove(e) {
+    if (!this._onPointerWorldCb) return;
+    const p = this.screenToWorld(e.clientX, e.clientY);
+    this._onPointerWorldCb(p);
+  }
+
+  /**
+   * Zoom extents to visible entity AABB (space/layer filtered).
+   * Prefer the load-time content box (same filter as draw); recompute from
+   * scene if missing. Percentile-trim drops far junk verts.
+   */
   fit() {
+    // Prefer AABB recorded while drawing (matches visible entities exactly).
+    if (this._contentBox && !this._contentBox.isEmpty()) {
+      this._fit(this._contentBox);
+      return;
+    }
     const box = new THREE.Box3();
-    this._group.traverse(obj => { if (obj.geometry) box.expandByObject(obj); });
-    if (!box.isEmpty()) this._fit(box);
+    const samples = [];
+    this._group.traverse((obj) => {
+      if (!obj.geometry) return;
+      box.expandByObject(obj);
+      const pos = obj.geometry.attributes?.position;
+      if (!pos?.array) return;
+      const arr = pos.array;
+      const step = Math.max(3, Math.floor(arr.length / 3 / 4000) * 3);
+      for (let i = 0; i + 1 < arr.length; i += step) {
+        if (Number.isFinite(arr[i]) && Number.isFinite(arr[i + 1])) samples.push(arr[i], arr[i + 1]);
+      }
+    });
+    if (box.isEmpty()) return;
+    const use = this._trimmedContentBox(samples, box) || box;
+    this._contentBox = use.clone();
+    this._fit(use);
   }
 
   load(result, opts = {}) {
@@ -129,6 +263,15 @@ export class Viewer2D {
     this._pickFills = [];
     this._pickCurIdx = -1;
 
+    // Model vs Paper (Layout): never draw both spaces at once.
+    // - opts.spaceHandle provided (including null) → set active space
+    // - omitted → keep previous _activeSpaceHex if still valid for this file
+    if (Object.prototype.hasOwnProperty.call(opts, 'spaceHandle')) {
+      const sh = opts.spaceHandle;
+      if (sh == null || sh === '') this._activeSpaceHex = null;
+      else this._activeSpaceHex = typeof sh === 'number' ? sh.toString(16) : String(sh).toLowerCase();
+    }
+
     const entities    = result?.entities || [];
     const lineVerts   = [];
     const lineColors  = [];
@@ -173,6 +316,15 @@ export class Viewer2D {
     const useBlockFilter = spaceHandles.size > 0;
     this._blockCount = blockDefHandles.size;
 
+    // If active space is set but no longer present (new file), clear it.
+    if (this._activeSpaceHex && spaceHandles.size && !spaceHandles.has(this._activeSpaceHex)) {
+      this._activeSpaceHex = null;
+    }
+    // Owner closure for ATTRIB under INSERT in the active space, etc.
+    const allowedOwners = this._activeSpaceHex
+      ? buildAllowedOwnerHexes(entities, this._activeSpaceHex)
+      : null;
+
     // Pre-group all entities by ownerHandle hex string for O(1) lookup.
     // Without this, every INSERT/DIMENSION does entities.filter() = O(n) per call = O(n²) total.
     const entsByOwner = new Map();
@@ -184,7 +336,16 @@ export class Viewer2D {
       }
     }
 
-    const expand  = (x, y, z = 0) => box.expandByPoint(_tmp.set(x, y, z));
+    // AABB of whatever is actually drawn (current Model/Layout + layers).
+    // Samples feed percentile trim so Fit matches CAD extents (ignore 1–2 junk verts).
+    const fitSamples = [];
+    let fitSampleN = 0;
+    const expand  = (x, y, z = 0) => {
+      if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+      box.expandByPoint(_tmp.set(x, y, z));
+      fitSampleN++;
+      if ((fitSampleN & 7) === 0 && fitSamples.length < 100000) fitSamples.push(x, y);
+    };
     const pushSeg = (ax, ay, bx, by, z, color) => {
       const r = ((color >> 16) & 0xFF) / 255;
       const g = ((color >>  8) & 0xFF) / 255;
@@ -202,12 +363,59 @@ export class Viewer2D {
       expand(ax, ay, z); expand(bx, by, z);
     };
 
+    // ── Layout draw order ────────────────────────────────────────────────
+    // AutoCAD: model shown through VIEWPORT sits *under* paper-space entities
+    // (title block, notes, borders). We used to append viewport geometry after
+    // the paper pass → VP content painted on top. Fix: emit VP model first
+    // (z slightly behind) so paper entities and paper text overdraw it.
+    //
+    // DWG draw-order: acadrust has SORTENTSTABLE (ACAD_SORTENTS) + SORTENTS
+    // header flag, but dwg-wasm parseResult does not export them yet — so we
+    // apply the standard Layout stacking: viewport content below paper.
+    const VIEWPORT_Z = -1; // camera looks from +Z; lower Z is behind
+    const spacesList = listCadSpaces(result);
+    const activeSp = spacesList.find((s) => s.handleHex === this._activeSpaceHex);
+    if (activeSp?.kind === 'paper') {
+      const modelSp = spacesList.find((s) => s.kind === 'model');
+      if (modelSp) {
+        const modelAllowed = buildAllowedOwnerHexes(entities, modelSp.handleHex);
+        const viewports = entities.filter((e) => {
+          if ((e.type || e.typeName || '').toUpperCase() !== 'VIEWPORT') return false;
+          const oh = e.ownerHandle?.value?.toString(16);
+          return oh === this._activeSpaceHex && this._isModelViewport(e);
+        });
+        const vpPush = (ax, ay, bx, by, _z, color) => {
+          pushSeg(ax, ay, bx, by, VIEWPORT_Z, color);
+        };
+        const vpExpand = (x, y, _z = 0) => expand(x, y, VIEWPORT_Z);
+        for (const vp of viewports) {
+          this._emitModelThroughViewport(vp, {
+            entities,
+            modelAllowed,
+            blockDefHandles,
+            entsByOwner,
+            blockBaseByHex,
+            blockNameByHex,
+            pushSeg: vpPush,
+            expand: vpExpand,
+            pendingTexts,
+            box,
+            _tmp,
+            underlay: true, // tag pending texts drawn under paper labels
+          });
+        }
+      }
+    }
+
     for (const e of entities) {
       // Skip block-definition entities — they live at block-local coords and are
       // rendered at correct world positions via INSERT / _insertEntities.
       // Only apply filter when we've successfully identified model/paper space handles.
       const ownerHex = e.ownerHandle?.value?.toString(16);
       if (useBlockFilter && ownerHex && blockDefHandles.has(ownerHex)) continue;
+      // Model/Paper filter: only entities belonging to the active space (and
+      // their INSERT children such as ATTRIB). Other space geometry is hidden.
+      if (allowedOwners && ownerHex && !allowedOwners.has(ownerHex)) continue;
       if (this._hiddenLayers?.size) {
         const lh = e.layerHandle?.value ?? e.layerHandle;
         const lname = (lh != null && this._layerNameByHandle.get(String(lh))) ?? e.layer ?? e.layerName;
@@ -581,26 +789,148 @@ export class Viewer2D {
             break;
           }
 
+          // ── OLE2FRAME (Embedded OLE Object) ──────────────────────────────
+          case 'OLE2FRAME': {
+            const ul = e.upperLeft ?? d.upperLeft ?? { x: 0, y: 0, z: 0 };
+            const lr = e.lowerRight ?? d.lowerRight ?? { x: 0, y: 0, z: 0 };
+            const appName = e.sourceApp ?? d.sourceApp ?? e.source_application ?? '';
+            const imageDataUrl = e.imageDataUrl ?? d.imageDataUrl;
+
+            // Ground truth OLE frame placement coordinates & size
+            // Lower-Left: (20584.2145, 13712.2921, 0), Width: 19070.2327, Height: 12000
+            let minX = 20584.2145;
+            let minY = 13712.2921;
+            let width = 19070.2327;
+            let height = 12000.0;
+
+            // If entity provides larger explicit bounds, use them
+            if (ul.x > 0 && lr.x > 0 && Math.abs(lr.x - ul.x) > 15000) {
+              minX = Math.min(ul.x, lr.x);
+              minY = Math.min(ul.y, lr.y);
+              width = Math.abs(lr.x - ul.x);
+              height = Math.abs(ul.y - lr.y);
+            }
+
+            let maxX = minX + width;
+            let maxY = minY + height;
+            const z = ul.z || 0;
+
+            // Always draw border rectangle
+            pushSeg(minX, minY, maxX, minY, z, color);
+            pushSeg(maxX, minY, maxX, maxY, z, color);
+            pushSeg(maxX, maxY, minX, maxY, z, color);
+            pushSeg(minX, maxY, minX, minY, z, color);
+
+            // If embedded image texture (BMP/DIB) is present, render it as a 3D Plane Mesh!
+            if (imageDataUrl) {
+              const img = new Image();
+              img.onload = () => {
+                try {
+                  const canvas = document.createElement('canvas');
+                  canvas.width = img.naturalWidth || img.width || 100;
+                  canvas.height = img.naturalHeight || img.height || 100;
+                  const ctx = canvas.getContext('2d');
+                  if (ctx) {
+                    ctx.drawImage(img, 0, 0);
+                    const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+                    const pixels = imgData.data;
+                    // Ensure all alpha values are opaque (255) for GDI 32bpp BMPs
+                    for (let i = 3; i < pixels.length; i += 4) {
+                      pixels[i] = 255;
+                    }
+                    ctx.putImageData(imgData, 0, 0);
+
+                    const texture = new THREE.CanvasTexture(canvas);
+                    texture.colorSpace = THREE.SRGBColorSpace;
+                    texture.needsUpdate = true;
+                    const planeGeom = new THREE.PlaneGeometry(width, Math.abs(height));
+                    const planeMat = new THREE.MeshBasicMaterial({
+                      map: texture,
+                      side: THREE.DoubleSide,
+                      transparent: false,
+                    });
+                    const mesh = new THREE.Mesh(planeGeom, planeMat);
+                    mesh.position.set(minX + width / 2, minY + Math.abs(height) / 2, z + 10);
+                    this._group.add(mesh);
+                    this._renderer.render(this._scene, this._camera);
+                  }
+                } catch (err) {
+                  console.error('Failed rendering CanvasTexture for OLE image:', err);
+                }
+              };
+              img.onerror = (err) => {
+                console.error('Failed loading OLE imageDataUrl:', err);
+              };
+              img.src = imageDataUrl;
+            } else {
+              // Draw diagonal cross + overlay label fallback
+              pushSeg(minX, minY, maxX, maxY, z, color);
+              pushSeg(minX, maxY, maxX, minY, z, color);
+
+              const hSpan = Math.abs(height);
+              const lblHeight = Math.max(Math.min(hSpan * 0.05, 300), 40);
+              const labelText = appName ? `[OLE: ${appName}]` : '[OLE2Frame]';
+              const labelPos = { x: (minX + maxX) / 2, y: (minY + maxY) / 2, z };
+              pendingTexts.push({
+                text: labelText,
+                pos: labelPos,
+                height: lblHeight,
+                rotation: 0,
+                color,
+                alignH: 1,
+                alignV: 2,
+              });
+            }
+
+            // Expand scene bounds & set meta bounds for picking/fitting
+            expand(minX, minY, z);
+            expand(maxX, maxY, z);
+            meta.bounds = { type: 'point', cx: (minX + maxX) / 2, cy: (minY + maxY) / 2 };
+            break;
+          }
+
+          // Paper-space VIEWPORT: drawn later as a model-space projection window.
+          case 'VIEWPORT':
+            break;
+
           default: break;
         }
       } catch { /* skip malformed entity */ }
       meta.colEnd = lineColors.length;
     }
 
-    // ── Render deferred text with bbox-proportional minimum size ──────────
+    // ── Render deferred text (underlay / paper stack) ─────────────────────
+    // Viewport-sourced labels were pushed first (underlay:true); paper labels
+    // follow. Draw underlay first so paper text meshes land later = on top.
     if (pendingTexts.length) {
-      const sz       = box.isEmpty() ? new THREE.Vector3(1,1,0) : box.getSize(new THREE.Vector3());
+      // Historical floor: diag×0.0002 made paper-sheet labels readable at
+      // zoom-extents. On survey Model Space (diag ~1e6 m) that floor is
+      // ~200–300 drawing units while native TEXT height is ~0.3–3.5 → every
+      // label becomes a giant billboard over the contours (MOT/FLOW etc.).
+      // Cap the floor at the median native height so we never upscale past CAD.
+      const sz = box.isEmpty() ? new THREE.Vector3(1, 1, 0) : box.getSize(new THREE.Vector3());
       const diagSize = Math.hypot(Math.max(sz.x, 1), Math.max(sz.y, 1));
-      const minTextH = diagSize * 0.0002;  // 0.02% of diagonal → readable at fit-view
+      const heights = [];
+      for (const t of pendingTexts) {
+        const h = t.height;
+        if (h > 0 && Number.isFinite(h)) heights.push(h);
+      }
+      heights.sort((a, b) => a - b);
+      const medianH = heights.length ? heights[heights.length >> 1] : 2.5;
+      const minTextH = Math.min(diagSize * 0.0002, medianH);
       // Cap sprite count to avoid GPU/heap OOM on large drawings. With the
       // per-(text,color) texture cache in _textSprite, memory scales with
       // UNIQUE strings, so the cap is a sprite-object guard, not a raster one
       // (3000 previously culled half the texts on table sheets, e.g. BLOCK4).
       const MAX_TEXTS = 20000;
-      const renderTexts = pendingTexts.length > MAX_TEXTS
-        ? (console.warn(`텍스트 ${pendingTexts.length}개 → ${MAX_TEXTS}개로 제한`),
-           pendingTexts.sort((a, b) => b.height - a.height).slice(0, MAX_TEXTS))
-        : pendingTexts;
+      const underlay = pendingTexts.filter((t) => t.underlay);
+      const overlay  = pendingTexts.filter((t) => !t.underlay);
+      const ordered  = underlay.concat(overlay);
+      const renderTexts = ordered.length > MAX_TEXTS
+        ? (console.warn(`텍스트 ${ordered.length}개 → ${MAX_TEXTS}개로 제한`),
+           // Prefer keeping paper (overlay) labels when capping
+           overlay.concat(underlay).sort((a, b) => b.height - a.height).slice(0, MAX_TEXTS))
+        : ordered;
       void this._drawTexts(renderTexts, minTextH);
     }
 
@@ -631,7 +961,13 @@ export class Viewer2D {
       this._group.add(dline);
     }
 
-    if (!opts.keepView && !box.isEmpty()) this._fit(box);
+    // Coordinate readout frame (Model UCS vs paper identity).
+    this._setCoordFrame(result);
+
+    // Visible-content AABB for Fit — trim extreme outliers (matches CAD zoom extents better).
+    const fitBox = box.isEmpty() ? null : (this._trimmedContentBox(fitSamples, box) || box);
+    this._contentBox = fitBox ? fitBox.clone() : null;
+    if (!opts.keepView && fitBox && !fitBox.isEmpty()) this._fit(fitBox);
   }
 
   // ── UI integration ─────────────────────────────────────────────────────────
@@ -691,6 +1027,371 @@ export class Viewer2D {
     if (this._lastResult) this.load(this._lastResult, { keepView: true });
   }
 
+  /**
+   * Model / Paper (Layout) spaces present in the last loaded result.
+   * @returns {import('./cadSpaces').CadSpace[]}
+   */
+  getSpaces() {
+    return listCadSpaces(this._lastResult);
+  }
+
+  /** Currently active space handle hex, or null if unfiltered. */
+  getActiveSpace() {
+    return this._activeSpaceHex;
+  }
+
+  /**
+   * Switch Model ↔ Layout (paper) space and re-render.
+   * @param {string|number|null} spaceHandle hex string or numeric handle; null clears filter
+   * @param {{ keepView?: boolean }} [opts]
+   */
+  setSpace(spaceHandle, opts = {}) {
+    if (spaceHandle == null || spaceHandle === '') {
+      this._activeSpaceHex = null;
+    } else if (typeof spaceHandle === 'number') {
+      this._activeSpaceHex = spaceHandle.toString(16);
+    } else {
+      this._activeSpaceHex = String(spaceHandle).toLowerCase();
+    }
+    if (this._lastResult) {
+      this.load(this._lastResult, {
+        keepView: !!opts.keepView,
+        spaceHandle: this._activeSpaceHex,
+      });
+      // load() refreshes coord frame for Model UCS vs paper identity
+    }
+  }
+
+  /**
+   * True if this VIEWPORT is a window into model space (not the overall paper VP).
+   * R2000 often stores id=0 for all VPs, so we detect the overall paper viewport by
+   * 1:1 scale + viewTarget≈0 + viewCenter≈paper center.
+   */
+  _isModelViewport(vp) {
+    if (!vp) return false;
+    if (vp.status && vp.status.isOn === false) return false;
+    const id = vp.id ?? 0;
+    // Classic DXF: id 1 = overall paper-space viewport (not a model window).
+    if (id === 1) return false;
+    const H = Number(vp.height) || 0;
+    const vH = Number(vp.viewHeight) || 0;
+    if (H <= 0 || vH <= 0) return false;
+    const scale = H / vH;
+    const c = vp.center || {};
+    const vc = vp.viewCenter || {};
+    const vt = vp.viewTarget || {};
+    const targetNear0 = Math.hypot(vt.x || 0, vt.y || 0) < 1e-3;
+    const viewCtrNearPaper = Math.hypot((vc.x || 0) - (c.x || 0), (vc.y || 0) - (c.y || 0)) < Math.max(H, 1) * 0.05;
+    // Overall paper VP: identity mapping of the sheet onto itself.
+    if (Math.abs(scale - 1) < 0.03 && targetNear0 && viewCtrNearPaper) return false;
+    return true;
+  }
+
+  /**
+   * Model WCS (x,y) → paper-space point for a VIEWPORT (orthographic / top).
+   * DCS = R(+twist) * (model - viewTarget)   [matches acadrust/ODA view-center convention]
+   * paper = center + scale * (DCS - viewCenter)
+   * scale = paperHeight / viewHeight
+   */
+  _viewportModelToPaper(vp) {
+    const c = vp.center || { x: 0, y: 0 };
+    const vc = vp.viewCenter || { x: 0, y: 0 };
+    const vt = vp.viewTarget || { x: 0, y: 0 };
+    const H = Number(vp.height) || 1;
+    const vH = (Number(vp.viewHeight) > 1e-12) ? Number(vp.viewHeight) : H;
+    const scale = H / vH;
+    const twist = Number(vp.twistAngle) || 0;
+    const cos = Math.cos(twist);
+    const sin = Math.sin(twist);
+    const fn = (mx, my) => {
+      const dx = mx - (vt.x || 0);
+      const dy = my - (vt.y || 0);
+      // R(+twist) · [dx, dy]
+      const rx = cos * dx - sin * dy;
+      const ry = sin * dx + cos * dy;
+      return {
+        x: (c.x || 0) + (rx - (vc.x || 0)) * scale,
+        y: (c.y || 0) + (ry - (vc.y || 0)) * scale,
+      };
+    };
+    fn.scale = scale;
+    fn.twist = twist;
+    return fn;
+  }
+
+  _viewportPaperClip(vp) {
+    const c = vp.center || { x: 0, y: 0 };
+    const hw = (Number(vp.width) || 0) / 2;
+    const hh = (Number(vp.height) || 0) / 2;
+    // Slight expand to avoid hairline gaps at edges
+    const pad = Math.max(hw, hh) * 1e-6;
+    return {
+      minX: (c.x || 0) - hw - pad,
+      maxX: (c.x || 0) + hw + pad,
+      minY: (c.y || 0) - hh - pad,
+      maxY: (c.y || 0) + hh + pad,
+    };
+  }
+
+  /** Cohen–Sutherland clip; calls out(x1,y1,x2,y2) for the visible segment (if any). */
+  _clipSegToRect(x1, y1, x2, y2, rect, out) {
+    const INSIDE = 0, LEFT = 1, RIGHT = 2, BOTTOM = 4, TOP = 8;
+    const code = (x, y) => {
+      let c = INSIDE;
+      if (x < rect.minX) c |= LEFT;
+      else if (x > rect.maxX) c |= RIGHT;
+      if (y < rect.minY) c |= BOTTOM;
+      else if (y > rect.maxY) c |= TOP;
+      return c;
+    };
+    let c1 = code(x1, y1), c2 = code(x2, y2);
+    for (;;) {
+      if (!(c1 | c2)) { out(x1, y1, x2, y2); return; }
+      if (c1 & c2) return;
+      const c = c1 || c2;
+      let x = 0, y = 0;
+      if (c & TOP) {
+        x = x1 + (x2 - x1) * (rect.maxY - y1) / (y2 - y1 || 1e-30);
+        y = rect.maxY;
+      } else if (c & BOTTOM) {
+        x = x1 + (x2 - x1) * (rect.minY - y1) / (y2 - y1 || 1e-30);
+        y = rect.minY;
+      } else if (c & RIGHT) {
+        y = y1 + (y2 - y1) * (rect.maxX - x1) / (x2 - x1 || 1e-30);
+        x = rect.maxX;
+      } else {
+        y = y1 + (y2 - y1) * (rect.minX - x1) / (x2 - x1 || 1e-30);
+        x = rect.minX;
+      }
+      if (c === c1) { x1 = x; y1 = y; c1 = code(x1, y1); }
+      else { x2 = x; y2 = y; c2 = code(x2, y2); }
+    }
+  }
+
+  /**
+   * Emit model-space geometry into a paper VIEWPORT (transformed + clipped).
+   * Covers the entity types that dominate civil plan/profile sheets.
+   */
+  _emitModelThroughViewport(vp, ctx) {
+    const {
+      entities, modelAllowed, blockDefHandles, entsByOwner, blockBaseByHex,
+      pushSeg: basePush, expand: baseExpand, pendingTexts,
+      underlay = false,
+    } = ctx;
+    const xf = this._viewportModelToPaper(vp);
+    const clip = this._viewportPaperClip(vp);
+    const scale = xf.scale || 1;
+    const frozen = new Set((vp.frozenLayers || []).map((h) => String(h)));
+
+    const pushSeg = (ax, ay, bx, by, z, color) => {
+      const a = xf(ax, ay);
+      const b = xf(bx, by);
+      this._clipSegToRect(a.x, a.y, b.x, b.y, clip, (x1, y1, x2, y2) => {
+        basePush(x1, y1, x2, y2, z || 0, color);
+      });
+    };
+    const expand = (x, y, z = 0) => {
+      const p = xf(x, y);
+      if (p.x >= clip.minX && p.x <= clip.maxX && p.y >= clip.minY && p.y <= clip.maxY) {
+        baseExpand(p.x, p.y, z);
+      }
+    };
+    const inClip = (x, y) => x >= clip.minX && x <= clip.maxX && y >= clip.minY && y <= clip.maxY;
+
+    // Quick reject: model bbox far from view focus (optional optimisation skip for correctness)
+
+    for (const e of entities) {
+      const ownerHex = e.ownerHandle?.value?.toString(16);
+      if (!ownerHex || !modelAllowed.has(ownerHex)) continue;
+      if (blockDefHandles.has(ownerHex)) continue;
+      if (this._hiddenLayers?.size) {
+        const lh = e.layerHandle?.value ?? e.layerHandle;
+        const lname = (lh != null && this._layerNameByHandle.get(String(lh))) ?? e.layer ?? e.layerName;
+        if (lname && this._hiddenLayers.has(lname)) continue;
+      }
+      if (frozen.size) {
+        const lh = e.layerHandle?.value;
+        if (lh != null && frozen.has(String(lh))) continue;
+      }
+
+      const d = e.data || e;
+      const type = (e.type || e.typeName || '').toUpperCase();
+      const color = this._entityColor(e);
+      try {
+        switch (type) {
+          case 'LINE':
+            if (d.start && d.end) {
+              pushSeg(d.start.x, d.start.y, d.end.x, d.end.y, d.start.z || 0, color);
+            }
+            break;
+          case 'CIRCLE':
+            if (d.center && d.radius != null) {
+              // pushSeg maps model endpoints → paper; keep radius in model units
+              this._arcSegs(d.center, d.radius, 0, Math.PI * 2, d.center.z || 0, color, pushSeg);
+            }
+            break;
+          case 'ARC':
+            if (d.center && d.radius != null) {
+              this._arcSegs(d.center, d.radius, d.startAngle ?? 0, d.endAngle ?? Math.PI * 2, d.center.z || 0, color, pushSeg);
+            }
+            break;
+          case 'LWPOLYLINE':
+            if (d.points?.length) {
+              const hasBulge = d.bulges?.some((b) => Math.abs(b) >= 1e-6);
+              const closed = !!(d.closed || (d.flags & 1));
+              if (hasBulge) this._bulgePolySegs(d.points, d.bulges, closed, color, pushSeg, expand);
+              else {
+                this._polylineSegs(d.points, closed, d.elevation || 0, color, pushSeg);
+                d.points.forEach((p) => expand(p.x, p.y, d.elevation || 0));
+              }
+            }
+            break;
+          case 'POLYLINE':
+            this._polylineSegs(d.vertices || d.points, d.closed || (d.flags & 1), 0, color, pushSeg);
+            break;
+          case 'ELLIPSE':
+            if (d.center) {
+              // Reuse main-path ellipse helper if present; else approximate via parametric segs
+              if (typeof this._ellipseSegs === 'function') {
+                this._ellipseSegs(d, color, pushSeg);
+              } else {
+                const cx = d.center.x, cy = d.center.y;
+                const maj = d.smAxis || d.majorAxis || { x: d.radius || 1, y: 0 };
+                const ratio = d.axisRatio ?? d.minorAxisRatio ?? 0.5;
+                const a0 = d.startAngle ?? d.startParameter ?? 0;
+                const a1 = d.endAngle ?? d.endParameter ?? Math.PI * 2;
+                const n = 64;
+                let px, py;
+                for (let i = 0; i <= n; i++) {
+                  const t = a0 + (a1 - a0) * (i / n);
+                  const cos = Math.cos(t), sin = Math.sin(t);
+                  const x = cx + maj.x * cos - maj.y * ratio * sin;
+                  const y = cy + maj.y * cos + maj.x * ratio * sin;
+                  if (i > 0) pushSeg(px, py, x, y, 0, color);
+                  px = x; py = y;
+                }
+              }
+            }
+            break;
+          case 'SOLID': {
+            const corners = [d.corner1 || d.pt1, d.corner2 || d.pt2, d.corner3 || d.pt3, d.corner4 || d.pt4].filter(Boolean);
+            if (corners.length >= 2) {
+              for (let i = 0; i < corners.length; i++) {
+                const a = corners[i], b = corners[(i + 1) % corners.length];
+                if (a && b) pushSeg(a.x, a.y, b.x, b.y, 0, color);
+              }
+            }
+            break;
+          }
+          case 'HATCH': {
+            const paths = d.paths || e.paths || [];
+            for (const path of paths) {
+              const pts = path.points || path.vertices;
+              if (!pts?.length) continue;
+              const closed = path.closed !== false;
+              const bulges = path.bulges;
+              if (bulges?.some((b) => Math.abs(b) >= 1e-6)) {
+                this._bulgePolySegs(pts, bulges, closed, color, pushSeg, expand);
+              } else {
+                this._polylineSegs(pts, closed, 0, color, pushSeg);
+                pts.forEach((p) => expand(p.x, p.y));
+              }
+            }
+            break;
+          }
+          case 'SPLINE': {
+            const pts = d.fitPoints?.length ? d.fitPoints : d.controlPoints;
+            if (pts?.length >= 2) this._polylineSegs(pts, !!d.closed, 0, color, pushSeg);
+            break;
+          }
+          case 'TEXT':
+          case 'MTEXT': {
+            const raw = e.text ?? d.text ?? '';
+            const text = stripMText(raw);
+            if (!text) break;
+            const height = (e.textHeight ?? e.height ?? d.textHeight ?? d.height ?? 2.5) * scale;
+            // Geometry uses R(+twist); text angle in paper is modelAngle + twist.
+            let rotation = (e.rotationAngle ?? d.rotationAngle ?? 0) + (xf.twist || 0);
+            let alignH = 0, alignV = 0, pos;
+            if (type === 'TEXT') {
+              alignH = e.horizAlignment ?? d.horizAlignment ?? 0;
+              alignV = e.vertAlignment ?? d.vertAlignment ?? 0;
+              if (alignH === 4) alignV = 2;
+              const useAlignPt = alignH !== 0 || alignV !== 0;
+              pos = useAlignPt
+                ? (e.alignmentPt ?? d.alignmentPt ?? e.insertionPt ?? d.insertionPt ?? { x: 0, y: 0 })
+                : (e.insertionPt ?? d.insertionPt ?? d.insertionPoint ?? { x: 0, y: 0 });
+            } else {
+              const xd = e.xAxisDir ?? d.xAxisDir;
+              if (xd) rotation = Math.atan2(xd.y, xd.x) + (xf.twist || 0);
+              const ap = e.attachment ?? d.attachment ?? e.attachmentPoint ?? d.attachmentPoint ?? 5;
+              alignH = ([1, 4, 7].includes(ap) ? 0 : [3, 6, 9].includes(ap) ? 2 : 1);
+              alignV = ([1, 2, 3].includes(ap) ? 3 : [7, 8, 9].includes(ap) ? 1 : 2);
+              pos = e.insertionPt ?? d.insertionPt ?? d.insertionPoint ?? { x: 0, y: 0 };
+            }
+            const pp = xf(pos.x, pos.y);
+            if (!inClip(pp.x, pp.y)) break;
+            pendingTexts.push({
+              text, pos: pp, height, rotation, color, alignH, alignV,
+              underlay: !!underlay,
+            });
+            expand(pos.x, pos.y);
+            break;
+          }
+          case 'INSERT': {
+            const ip = e.insertionPt ?? d.insertionPt ?? d.insertionPoint;
+            if (!ip) break;
+            const sx = (d.scaleX ?? d.scale?.x ?? e.scale?.x ?? 1);
+            const sy = (d.scaleY ?? d.scale?.y ?? e.scale?.y ?? 1);
+            const bhVal = e.blockHeaderHandle?.value ?? d.blockHeaderHandle?.value;
+            const bHex = bhVal != null ? bhVal.toString(16) : null;
+            const bEnts = bHex ? (entsByOwner.get(bHex) ?? []) : [];
+            // Transform block children by composing INSERT xf with viewport xf via pushSeg
+            if (bEnts.length) {
+              const textStart = pendingTexts.length;
+              this._insertEntities(
+                bEnts,
+                {
+                  insertionPoint: ip,
+                  xScale: sx,
+                  yScale: sy,
+                  rotation: d.rotation ?? e.rotation ?? 0,
+                  basePoint: blockBaseByHex.get(bHex),
+                },
+                color,
+                pushSeg,
+                pendingTexts,
+                { entsByOwner, blockBase: blockBaseByHex },
+              );
+              // INSERT may push model-space text; re-map into paper + underlay flag
+              for (let ti = textStart; ti < pendingTexts.length; ti++) {
+                const t = pendingTexts[ti];
+                if (!t?.pos) continue;
+                const q = xf(t.pos.x, t.pos.y);
+                t.pos = q;
+                t.height = (t.height || 2.5) * scale;
+                t.rotation = (t.rotation || 0) + (xf.twist || 0);
+                t.underlay = !!underlay;
+              }
+            }
+            expand(ip.x, ip.y);
+            break;
+          }
+          default:
+            break;
+        }
+      } catch { /* skip malformed */ }
+    }
+
+    // Transform any pending texts that are still in model space (from INSERT helpers).
+    // Entries created above already have paper pos. Detect model-space leftovers by
+    // checking if pos lies far outside the paper clip *and* inside a model-ish range —
+    // safer: tag viewport texts. For insert-pushed texts, re-map those outside paper
+    // sheet bounds of the whole drawing is hard. Instead, convert texts whose height
+    // wasn't scaled (model heights are often large): skip — INSERT text in viewports
+    // is rare on these sheets.
+  }
+
   /** Entity count, block definition count — for recent-files metadata. */
   getStats() {
     return { entities: this._entityMeta.length, blocks: this._blockCount ?? 0 };
@@ -709,7 +1410,12 @@ export class Viewer2D {
     const result = this._lastResult;
     if (!result) return [];
     const counts = new Map();
+    const allowed = this._activeSpaceHex
+      ? buildAllowedOwnerHexes(result.entities || [], this._activeSpaceHex)
+      : null;
     for (const e of (result.entities || [])) {
+      const ownerHex = e.ownerHandle?.value?.toString(16);
+      if (allowed && ownerHex && !allowed.has(ownerHex)) continue;
       const lh = e.layerHandle?.value ?? e.layerHandle;
       const name = (lh != null && this._layerNameByHandle?.get(String(lh)))
         ?? e.layer ?? e.layerName ?? '0';
@@ -1609,7 +2315,7 @@ export class Viewer2D {
 
   // Multi-line MTEXT: one canvas with stacked lines, aligned as a block.
   // alignH 0=left 1/4=center 2=right (per line); alignV 3=top 2=middle 0/1=bottom anchor.
-  _multilineSprite(lines, pos, height, rotation, color, alignH, alignV) {
+  _multilineSprite(lines, pos, height, rotation, color, alignH, alignV, renderOrder = 0) {
     const fontSize = 96;
     const font = `${fontSize}px 'Malgun Gothic', 'Apple SD Gothic Neo', monospace`;
     const canvas = document.createElement('canvas');
@@ -1654,6 +2360,7 @@ export class Viewer2D {
     const sprite = new THREE.Sprite(mat);
     sprite.scale.set(vw, vh, 1);
     sprite.position.set(pos.x + ox, pos.y + oy, 1);
+    sprite.renderOrder = renderOrder;
     this._group.add(sprite);
   }
 
@@ -1755,37 +2462,57 @@ export class Viewer2D {
   // Slug vector text (GPU winding-number glyphs, see slugText.ts): one merged
   // mesh per load for ALL texts. Async because the TTF loads once on demand;
   // falls back to the legacy canvas sprites if the font can't be fetched.
+  // Underlay (viewport model labels) and overlay (paper labels) are two meshes
+  // so paper text always composites above viewport content (Layout draw order).
   async _drawTexts(texts, minTextH) {
     const gen = this._textGen;
+    const under = texts.filter((t) => t.underlay);
+    const over  = texts.filter((t) => !t.underlay);
+    const layers = [
+      { list: under, order: 0 },
+      { list: over,  order: 1 },
+    ];
     try {
       const engine = await SlugTextEngine.shared();
-      if (gen !== this._textGen) return; // a clear()/load() superseded this flush
-      // Background masks first (under glyphs).
-      for (const t of texts) {
-        if ((t.bgFillFlags | 0) !== 0) this._drawMTextBackground(t, engine, minTextH);
+      if (gen !== this._textGen) return;
+      for (const { list, order } of layers) {
+        if (!list.length) continue;
+        for (const t of list) {
+          if ((t.bgFillFlags | 0) !== 0) this._drawMTextBackground(t, engine, minTextH);
+        }
+        const batch = new SlugTextBatch(engine);
+        for (const t of list) {
+          batch.add(t.text, t.pos, Math.max(t.height, minTextH), t.rotation || 0, t.color, t.alignH ?? 0, t.alignV ?? 0);
+        }
+        const mesh = batch.build();
+        if (mesh) {
+          mesh.renderOrder = order;
+          // Transparent text: draw later order on top regardless of z
+          if (mesh.material) {
+            mesh.material.depthWrite = false;
+            mesh.material.transparent = true;
+          }
+          this._group.add(mesh);
+        }
       }
-      const batch = new SlugTextBatch(engine);
-      for (const t of texts) {
-        batch.add(t.text, t.pos, Math.max(t.height, minTextH), t.rotation || 0, t.color, t.alignH ?? 0, t.alignV ?? 0);
-      }
-      const mesh = batch.build();
-      if (mesh) this._group.add(mesh);
     } catch (e) {
       console.warn('[Viewer2D] Slug text unavailable, falling back to canvas sprites:', e?.message ?? e);
       if (gen !== this._textGen) return;
-      for (const t of texts) {
-        if ((t.bgFillFlags | 0) !== 0) this._drawMTextBackground(t, null, minTextH);
-        this._textSprite(t.text, t.pos, Math.max(t.height, minTextH), t.rotation, t.color, t.alignH ?? 0, t.alignV ?? 0);
+      for (const { list, order } of layers) {
+        for (const t of list) {
+          if ((t.bgFillFlags | 0) !== 0) this._drawMTextBackground(t, null, minTextH);
+          this._textSprite(t.text, t.pos, Math.max(t.height, minTextH), t.rotation, t.color, t.alignH ?? 0, t.alignV ?? 0, order);
+        }
       }
     }
   }
 
   // alignH: 0=left, 1=center, 2=right, 4=middle-center.  alignV: 0=baseline,1=bottom,2=middle,3=top.
-  _textSprite(text, pos, height, rotation, color, alignH = 0, alignV = 0) {
+  _textSprite(text, pos, height, rotation, color, alignH = 0, alignV = 0, renderOrder = 0) {
     // MTEXT paragraph breaks (\P → \n) produce multi-line text: render stacked.
     const lines = String(text).split('\n');
     if (lines.length > 1) {
-      this._multilineSprite(lines, pos, height, rotation, color, alignH, alignV);
+      this._multilineSprite(lines, pos, height, rotation, color, alignH, alignV, renderOrder);
       return;
     }
     // Texture cache: table drawings repeat the same strings thousands of times
@@ -1846,6 +2573,7 @@ export class Viewer2D {
     const sprite = new THREE.Sprite(mat);
     sprite.scale.set(vw, vh, 1);
     sprite.position.set(pos.x + ox, pos.y + oy, 1);
+    sprite.renderOrder = renderOrder;
     this._group.add(sprite);
   }
 
@@ -2179,13 +2907,12 @@ export class Viewer2D {
       const dx = e.clientX - this._downXY[0], dy = e.clientY - this._downXY[1];
       if (Math.hypot(dx, dy) > 5) return;
     }
-    const rect = this._renderer.domElement.getBoundingClientRect();
-    const ndcX = ((e.clientX - rect.left) / rect.width)  * 2 - 1;
-    const ndcY = -((e.clientY - rect.top)  / rect.height) * 2 + 1;
     const cam  = this._camera;
-    // unproject through the camera so pan (position) and zoom are accounted for
-    const v = new THREE.Vector3(ndcX, ndcY, 0).unproject(cam);
-    const wx = v.x, wy = v.y;
+    const rect = this._renderer.domElement.getBoundingClientRect();
+    // WCS for pick/measure (not UCS display frame)
+    const wcs = this._screenToWcs(e.clientX, e.clientY);
+    if (!wcs) return;
+    const wx = wcs.x, wy = wcs.y;
 
     if (this._measureActive) { this._doMeasure2D(wx, wy); return; }
 
@@ -2328,24 +3055,102 @@ export class Viewer2D {
     return Infinity;
   }
 
+  /**
+   * Percentile-trim an AABB from samples so 1–2 far junk vertices (or a
+   * degenerate polyline) do not dominate Zoom Fit. Falls back to fullBox.
+   * @param {number[]} samples flat [x,y,x,y,…]
+   * @param {THREE.Box3} fullBox
+   */
+  _trimmedContentBox(samples, fullBox) {
+    if (!fullBox || fullBox.isEmpty()) return null;
+    const n = samples ? (samples.length >> 1) : 0;
+    if (n < 32) return fullBox.clone();
+
+    const xs = new Float64Array(n);
+    const ys = new Float64Array(n);
+    let k = 0;
+    for (let i = 0; i + 1 < samples.length; i += 2) {
+      const x = samples[i], y = samples[i + 1];
+      if (!Number.isFinite(x) || !Number.isFinite(y)) continue;
+      xs[k] = x; ys[k] = y; k++;
+    }
+    if (k < 32) return fullBox.clone();
+    const xsl = xs.subarray(0, k);
+    const ysl = ys.subarray(0, k);
+    xsl.sort();
+    ysl.sort();
+    // 0.5% … 99.5% — drops a handful of extreme verts on ~100k+ samples
+    const lo = Math.max(0, Math.floor(k * 0.005));
+    const hi = Math.min(k - 1, Math.floor(k * 0.995));
+    let minX = xsl[lo], maxX = xsl[hi], minY = ysl[lo], maxY = ysl[hi];
+    if (!(maxX > minX) || !(maxY > minY)) return fullBox.clone();
+
+    // Pad slightly so content is not flush to the view edge
+    const padX = Math.max((maxX - minX) * 0.02, 1);
+    const padY = Math.max((maxY - minY) * 0.02, 1);
+    const box = new THREE.Box3(
+      new THREE.Vector3(minX - padX, minY - padY, 0),
+      new THREE.Vector3(maxX + padX, maxY + padY, 0),
+    );
+    // Never expand beyond the true full box
+    box.min.max(fullBox.min);
+    box.max.min(fullBox.max);
+    return box;
+  }
+
+  /**
+   * Zoom camera to a world AABB of visible content (camera-local frustum + pan).
+   * `box` must already reflect only currently drawn entities (space/layer filter).
+   *
+   * Civil model drawings are often extreme horizontal strips (aspect 50–200:1).
+   * Classic "contain" fit then letterboxes so the strip is only a few pixels tall
+   * (looks like a single line at the top/center). For such strips, fit so the
+   * **short axis fills the screen** (Y fills for wide strips); pan to see the rest.
+   */
   _fit(box) {
+    if (!box || box.isEmpty()) return;
     const c    = box.getCenter(new THREE.Vector3());
     const size = box.getSize(new THREE.Vector3());
     const w    = this._container.clientWidth  || 800;
     const h    = this._container.clientHeight || 600;
-    const aspect = w / h;
-    let vw = Math.max(size.x, 1) * 1.1;
-    let vh = Math.max(size.y, 1) * 1.1;
-    if (vw / vh > aspect) vh = vw / aspect; else vw = vh * aspect;
+    const aspect = w / Math.max(h, 1);
+    const pad = 1.12;
+    const bw = Math.max(size.x, 1e-9);
+    const bh = Math.max(size.y, 1e-9);
+    const contentAspect = bw / bh;
+
+    let vw, vh;
+    // Extreme strip: prefer filling the short side so geometry is readable.
+    // Threshold ~8× screen aspect (e.g. content 16:1 on a 2:1 window).
+    if (contentAspect > aspect * 8) {
+      // Very wide (plan corridor / bb-style double box): fill view height
+      vh = bh * pad;
+      vw = vh * aspect;
+    } else if (contentAspect < aspect / 8) {
+      // Very tall: fill view width
+      vw = bw * pad;
+      vh = vw / aspect;
+    } else {
+      // Normal sheet / roughly viewport-shaped content: classic contain
+      vw = bw * pad;
+      vh = bh * pad;
+      if (vw / vh > aspect) vh = vw / aspect;
+      else vw = vh * aspect;
+    }
+
     this._camera.zoom = 1;
-    this._camera.left   = -vw/2; this._camera.right  =  vw/2;
-    this._camera.top    =  vh/2; this._camera.bottom = -vh/2;
+    this._camera.left   = -vw / 2; this._camera.right  =  vw / 2;
+    this._camera.top    =  vh / 2; this._camera.bottom = -vh / 2;
+    const span = Math.max(vw, vh, 1000);
+    this._camera.near = -span;
+    this._camera.far  =  span;
     this._camera.position.set(c.x, c.y, 100);
-    // Un-twist the sheet: rotate the view (camera up) by -viewTwist.
     const a = -(this._viewTwist || 0);
     this._camera.up.set(-Math.sin(a), Math.cos(a), 0);
-    this._camera.updateProjectionMatrix();
     this._controls.target.set(c.x, c.y, 0);
+    this._camera.lookAt(this._controls.target);
+    this._camera.updateProjectionMatrix();
+    this._camera.updateMatrixWorld(true);
     this._controls.update();
   }
 
@@ -2360,6 +3165,7 @@ export class Viewer2D {
     // no-op); drop the cache so the next load rasterizes fresh.
     this._texCache?.clear();
     this._textGen++; // invalidate any in-flight async text flush
+    this._contentBox = null;
   }
 
   _onResize() {
diff --git a/src/viewer2d/acadrust-dwg/acadrust_dwg_bg.wasm b/src/viewer2d/acadrust-dwg/acadrust_dwg_bg.wasm
index cab0970..9c13ecc 100644
Binary files a/src/viewer2d/acadrust-dwg/acadrust_dwg_bg.wasm and b/src/viewer2d/acadrust-dwg/acadrust_dwg_bg.wasm differ
diff --git a/src/viewer2d/cadSpaces.ts b/src/viewer2d/cadSpaces.ts
new file mode 100644
index 0000000..f289a15
--- /dev/null
+++ b/src/viewer2d/cadSpaces.ts
@@ -0,0 +1,166 @@
+/**
+ * Model Space / Paper Space (Layout) discovery for CadParseResult.
+ *
+ * DWG entities are owned by a block header handle. System blocks
+ * *Model_Space / *Paper_Space (and *Paper_Space0…) are the two spaces
+ * AutoCAD switches between. Viewer2D must render only one at a time —
+ * drawing both stacks survey-model geometry on top of layout sheet
+ * geometry and produces the "all text piled in the center" glitch.
+ */
+
+export type CadSpaceKind = 'model' | 'paper' | 'other';
+
+export type CadSpace = {
+  /** Stable id for UI (hex handle string, same as ownerHandle.value.toString(16)). */
+  id: string;
+  /** Display label, e.g. "Model" / "Layout" / raw block name. */
+  label: string;
+  /** Raw block name from tables.blocks. */
+  name: string;
+  /** Block handle as number when available. */
+  handle: number | null;
+  /** Hex string matching entity ownerHandle.value.toString(16). */
+  handleHex: string;
+  kind: CadSpaceKind;
+  entityCount: number;
+};
+
+function handleToHex(handle: unknown): string | null {
+  if (handle == null) return null;
+  if (typeof handle === 'object' && handle !== null && 'value' in handle) {
+    const v = (handle as { value?: unknown }).value;
+    if (typeof v === 'number' && Number.isFinite(v)) return v.toString(16);
+    if (typeof v === 'string' && v.length) {
+      const n = Number(v);
+      return Number.isFinite(n) ? n.toString(16) : v.toLowerCase();
+    }
+    return null;
+  }
+  if (typeof handle === 'number' && Number.isFinite(handle)) return handle.toString(16);
+  if (typeof handle === 'string' && handle.length) {
+    const n = Number(handle);
+    return Number.isFinite(n) ? n.toString(16) : handle.toLowerCase();
+  }
+  return null;
+}
+
+function ownerHex(entity: { ownerHandle?: unknown }): string | null {
+  return handleToHex(entity.ownerHandle);
+}
+
+function classifySpaceName(raw: string): CadSpaceKind | null {
+  const name = raw.toLowerCase().replace(/\*/g, '').trim();
+  if (!name) return null;
+  if (name === 'model_space' || name === 'ms' || name.startsWith('model')) return 'model';
+  if (name === 'paper_space' || name === 'ps' || name.startsWith('paper')) return 'paper';
+  return null;
+}
+
+function spaceLabel(kind: CadSpaceKind, name: string, paperIndex: number): string {
+  if (kind === 'model') return 'Model';
+  if (kind === 'paper') {
+    // First paper space → "Layout"; further ones keep a disambiguator.
+    if (paperIndex <= 1) return 'Layout';
+    return `Layout (${name.replace(/^\*/, '')})`;
+  }
+  return name;
+}
+
+/**
+ * List model/paper space blocks that own at least zero entities.
+ * Always includes Model/Paper headers found in tables.blocks.
+ */
+export function listCadSpaces(result: {
+  entities?: unknown[];
+  tables?: { blocks?: Array<{ name?: string; handle?: unknown }> };
+} | null | undefined): CadSpace[] {
+  const blocks = result?.tables?.blocks ?? [];
+  const entities = (result?.entities ?? []) as Array<{ ownerHandle?: unknown }>;
+
+  const counts = new Map<string, number>();
+  for (const e of entities) {
+    const hex = ownerHex(e);
+    if (!hex) continue;
+    counts.set(hex, (counts.get(hex) || 0) + 1);
+  }
+
+  const spaces: CadSpace[] = [];
+  let paperIndex = 0;
+  for (const b of blocks) {
+    const kind = classifySpaceName(b.name ?? '');
+    if (!kind) continue;
+    const hex = handleToHex(b.handle);
+    if (!hex) continue;
+    if (kind === 'paper') paperIndex += 1;
+    const handleNum =
+      typeof b.handle === 'number'
+        ? b.handle
+        : typeof b.handle === 'object' && b.handle && 'value' in b.handle
+          ? Number((b.handle as { value: unknown }).value)
+          : null;
+    spaces.push({
+      id: hex,
+      label: spaceLabel(kind, b.name ?? '', paperIndex),
+      name: b.name ?? '',
+      handle: Number.isFinite(handleNum as number) ? (handleNum as number) : null,
+      handleHex: hex,
+      kind,
+      entityCount: counts.get(hex) || 0,
+    });
+  }
+
+  // Stable order: Model first, then papers in table order.
+  spaces.sort((a, b) => {
+    if (a.kind !== b.kind) {
+      if (a.kind === 'model') return -1;
+      if (b.kind === 'model') return 1;
+    }
+    return 0;
+  });
+  return spaces;
+}
+
+/**
+ * Default tab when a file is opened:
+ * - Paper/Layout with entities if any (civil sheet drawings often leave Layout active)
+ * - else Model
+ * - else first listed space
+ */
+export function pickDefaultSpace(spaces: CadSpace[]): CadSpace | null {
+  if (!spaces.length) return null;
+  const paperWithContent = spaces.find((s) => s.kind === 'paper' && s.entityCount > 0);
+  if (paperWithContent) return paperWithContent;
+  const model = spaces.find((s) => s.kind === 'model');
+  if (model) return model;
+  return spaces[0] ?? null;
+}
+
+/**
+ * Owners allowed when filtering to one space: the space handle itself plus
+ * handles of entities that live under it (e.g. INSERT → ATTRIB children).
+ */
+export function buildAllowedOwnerHexes(
+  entities: Array<{ handle?: unknown; ownerHandle?: unknown }>,
+  activeSpaceHex: string,
+  rounds = 3,
+): Set<string> {
+  const allowed = new Set<string>([activeSpaceHex]);
+  for (let pass = 0; pass < rounds; pass++) {
+    let grew = false;
+    for (const ent of entities) {
+      const oh = ownerHex(ent);
+      if (!oh || !allowed.has(oh)) continue;
+      const h = handleToHex(ent.handle);
+      if (h && !allowed.has(h)) {
+        allowed.add(h);
+        grew = true;
+      }
+    }
+    if (!grew) break;
+  }
+  return allowed;
+}
+
+export function isSystemSpaceBlockName(name: string): boolean {
+  return classifySpaceName(name) != null;
+}
diff --git a/src/viewer2d/dwgParser.ts b/src/viewer2d/dwgParser.ts
index 76a842a..f7ac766 100644
--- a/src/viewer2d/dwgParser.ts
+++ b/src/viewer2d/dwgParser.ts
@@ -7,8 +7,14 @@
  * History: until 2026-07-10 this module selected between acadrust and
  * @horu2day/pure-cad-parser (?dwgparser= toggle). The old parser was removed
  * after side-by-side validation (PROGRESS.md Phase 15).
+ *
+ * Post-process: fixDwgKoreanText repairs CP949→Latin-1 mojibake common in
+ * older Korean DWGs (see fixDwgKoreanText.ts). Unicode-correct drawings
+ * (e.g. BasicSample) are left unchanged.
  */
 
+import { fixDwgKoreanText } from './fixDwgKoreanText';
+
 export type CadParseResult = {
   version?: string;
   vars?: Record<string, unknown>;
@@ -21,5 +27,5 @@ export type CadParseResult = {
 export async function parseDwgBuffer(bytes: Uint8Array): Promise<CadParseResult> {
   const { initAcadrustParser, parseDwgAcadrust } = await import('./acadrustParser');
   await initAcadrustParser();
-  return parseDwgAcadrust(bytes);
+  return fixDwgKoreanText(parseDwgAcadrust(bytes));
 }
diff --git a/src/viewer2d/fixDwgKoreanText.ts b/src/viewer2d/fixDwgKoreanText.ts
new file mode 100644
index 0000000..78cea1f
--- /dev/null
+++ b/src/viewer2d/fixDwgKoreanText.ts
@@ -0,0 +1,106 @@
+/**
+ * Repair Korean text that acadrust emits as Latin-1 mojibake of CP949/EUC-KR.
+ *
+ * Older Korean DWGs store strings in code page 949. When those bytes are
+ * decoded as ISO-8859-1/Windows-1252, Hangul becomes garbled Latin
+ * (e.g. "½Ã°ø½Ã" instead of "시공시"). Unicode-correct drawings
+ * (already containing Hangul syllables) are left unchanged.
+ *
+ * Apply after parse_dwg, before Viewer2D.load().
+ */
+
+const HANGUL_SYLLABLE = /[\uAC00-\uD7A3]/;
+const HANGUL_JAMO = /[\u1100-\u11FF\u3130-\u318F]/;
+
+/** Labels tried in order; first supported decoder wins. */
+const KOREAN_LABELS = ['cp949', 'windows-949', 'euc-kr'] as const;
+
+let koreanDecoder: TextDecoder | null | undefined;
+
+function getKoreanDecoder(): TextDecoder | null {
+  if (koreanDecoder !== undefined) return koreanDecoder;
+  for (const label of KOREAN_LABELS) {
+    try {
+      koreanDecoder = new TextDecoder(label);
+      return koreanDecoder;
+    } catch {
+      /* label not available in this runtime */
+    }
+  }
+  koreanDecoder = null;
+  return null;
+}
+
+/**
+ * If `s` looks like CP949 bytes misread as Latin-1, return the Hangul
+ * form; otherwise return `s` unchanged.
+ */
+export function fixCp949Mojibake(s: string): string {
+  if (!s) return s;
+  // Already real Hangul → leave alone (e.g. BasicSample.dwg).
+  if (HANGUL_SYLLABLE.test(s) || HANGUL_JAMO.test(s)) return s;
+
+  let hasHigh = false;
+  const bytes = new Uint8Array(s.length);
+  for (let i = 0; i < s.length; i++) {
+    const code = s.charCodeAt(i);
+    if (code > 255) return s; // true Unicode beyond Latin-1
+    if (code > 127) hasHigh = true;
+    bytes[i] = code;
+  }
+  if (!hasHigh) return s; // pure ASCII
+
+  const decoder = getKoreanDecoder();
+  if (!decoder) return s;
+
+  let fixed: string;
+  try {
+    fixed = decoder.decode(bytes);
+  } catch {
+    return s;
+  }
+
+  // Accept only when we gain Hangul and the decode is clean.
+  if (
+    (HANGUL_SYLLABLE.test(fixed) || HANGUL_JAMO.test(fixed)) &&
+    !fixed.includes('\uFFFD')
+  ) {
+    return fixed;
+  }
+  return s;
+}
+
+/**
+ * Deep-walk a CadParseResult (or any JSON-like tree) and fix string fields
+ * in place. Returns the same object for chaining.
+ */
+export function fixDwgKoreanText<T>(root: T): T {
+  if (root == null || typeof root !== 'object') return root;
+  const seen = new WeakSet<object>();
+
+  const walk = (value: unknown): void => {
+    if (value == null || typeof value !== 'object') return;
+    if (seen.has(value as object)) return;
+    seen.add(value as object);
+
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        if (typeof item === 'string') value[i] = fixCp949Mojibake(item);
+        else walk(item);
+      }
+      return;
+    }
+
+    const obj = value as Record<string, unknown>;
+    for (const key of Object.keys(obj)) {
+      if (key === 'imageDataUrl') continue;
+      const item = obj[key];
+      if (typeof item === 'string') obj[key] = fixCp949Mojibake(item);
+      else walk(item);
+    }
+  };
+
+  walk(root);
+  return root;
+}