feat: 서버 STT 재전사 — 오디오 원본에서 확정 전사문을 뽑는다

#18이 오디오를 남기게 했다면, 이 PR은 그 오디오를 실제로 쓴다.
Web Speech 포착률 7~10%를 끌어올리는 유일한 방법은 인식 엔진 교체다.

## 두 경로가 하나로 만난다

    실시간 녹음 ─┐
                 ├→ recordingId → /api/transcribe → 확정 전사문
    파일 업로드 ─┘

`/api/upload`는 파일을 디스크에 떨궈만 두고 "실시간 녹음 탭에서 하세요"라고
안내하던 막다른 길이었다. 이제 녹음 저장소에 넣고 recordingId를 돌려주므로
브라우저 녹음과 완전히 같은 파이프라인을 탄다.

## 실제 타임스탬프

Whisper `verbose_json`이 구간별 실제 오디오 시각을 준다. Web Speech 경로가 쓰던
`결과 이벤트 시각 − 2초` 추정값과 달리 구간 재생·화자 분리에 그대로 쓸 수 있다.
이 값이 있어야 PR #17의 diarization 화자 배정이 비로소 의미를 갖는다.

verbose_json을 지원하지 않는 모델(gpt-4o-transcribe 등)은 400을 주므로 `json`
으로 한 번 더 시도해 텍스트만이라도 받는다.

## 프로바이더별 지원

| 프로바이더 | webm 녹음 | 업로드 파일 | 기본 모델 |
|---|:---:|:---:|---|
| OpenAI · OrcaRouter · 로컬 whisper | O | O | whisper-1 |
| Gemini | X | O | gemini-3.6-flash |

Gemini가 문서로 밝힌 오디오 형식에 webm이 없다. 조용히 실패시키지 않고
"OpenAI 호환 프로바이더를 쓰라"고 명시적으로 안내하며, 설정 화면에도 경고를 띄운다.

## 비트레이트 128k → 32k

이 오디오는 감상용이 아니라 STT 입력이다. 128kbps면 46분 회의가 44MB가 되어
Whisper 상한(25MB)도 Gemini inline 상한도 넘긴다. 32kbps mono Opus는 음성
인식 정확도에 영향이 없으면서 46분을 11MB로 줄인다.

## 참석자·용어 힌트

홈 화면에 입력란을 두고 전사 요청의 어휘 힌트로 보낸다. 실측 transcript에서
"계명대동산병원 → 저희 키스해 주셔서", "양식대로 → 양복점" 같은 고유명사
붕괴가 심했던 부분이다.

## 검증

가짜 Whisper 서버를 세워 종단간 확인:
- 업로드 → recordingId → 전사 → `[00:00]/[00:03]/[00:12]` 전사문
- multipart 필드 검증: model · response_format=verbose_json · language=ko ·
  prompt(어휘 힌트) · Bearer 인증 · 파일 바이트 정확히 일치
- webm 녹음도 Whisper로 정상 전사 (5000 bytes 그대로 전달)
- Gemini+webm 거부 / 미설정 400 / 경로조작 400 / 없는 녹음 404

테스트 206 → 229 통과, 신규 타입 에러 0, 린트 baseline과 동일, 빌드 성공.

### 검증하지 못한 것

실제 Whisper·Gemini API를 호출하지 못했다(키 없음). 모든 프로바이더 코드는
목 fetch와 가짜 서버로만 검증했다. 요청 형식은 문서를 따랐으나 실제 응답에
대한 확인이 필요하다.

포착률이 실제로 얼마나 오르는지도 아직 모른다. 다음 회의에서 같은 오디오로
Web Speech와 STT를 나란히 놓고 재야 한다.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01WzAH7GPWSYTe2AoBV6CZDP

.env.example

@@ -51,3 +51,20 @@ GEMINI_API_KEY=
 # LLM_BASE_URL=
 # LLM_MODEL=
 # LLM_API_KEY=
+
+# ─────────────────────────────────────────────────────────────
+# 회의 오디오 녹음 저장 위치 (선택)
+# ─────────────────────────────────────────────────────────────
+# 기본값은 <프로젝트>/uploads/recordings 입니다.
+# Docker Compose에서는 uploads 볼륨에 저장되어 컨테이너를 재시작해도 남습니다.
+#
+# ⚠️ 녹음 파일에는 회의 원음이 그대로 들어 있습니다. 디스크 암호화된 위치에
+#    두고, 필요 없어진 녹음은 직접 삭제하세요. SECURITY.md 참고.
+# RECORDINGS_DIR=
+
+# 음성 전사(STT) 모델 (선택)
+# 비우면 프로바이더 기본값: OpenAI 호환 → whisper-1, Gemini → gemini-3.6-flash
+#
+# ⚠️ 전사는 회의 원음을 프로바이더 서버로 보냅니다. 텍스트보다 훨씬 민감합니다.
+#    외부로 내보내고 싶지 않다면 로컬 whisper 서버를 LLM_BASE_URL로 지정하세요.
+# LLM_STT_MODEL=

.gitignore

@@ -49,6 +49,3 @@ next-env.d.ts
 .env
 !.env.example
 
-
-# 화자 분리 모델 (npm run setup:diarization 으로 내려받음)
-models/

README.md

@@ -24,7 +24,6 @@ docker compose up -d
 
 - [✨ 주요 기능](#-주요-기능)
   - [🎤 실시간 녹음 & 전사](#-실시간-녹음--전사)
-  - [🗣️ 화자 분리](#️-화자-분리)
   - [🤖 AI 회의록 (6 템플릿 × 3 강도)](#-ai-회의록-6-템플릿--3-강도)
   - [⚡ 실시간 롤링 요약](#-실시간-롤링-요약)
   - [💾 회의록 저장/조회/검색](#-회의록-저장조회검색)
@@ -52,10 +51,67 @@ docker compose up -d
 
 **특징**
 - 즉시 시작 — 별도 STT 서버나 키 없이 작동
+- **오디오 원본 동시 녹음** — 전사와 무관하게 회의 원음을 파일로 보관
 - **자동 재연결** — 네트워크 끊김 시 최대 8회 재시도, 누적 transcript 보존
 - 확정 전 텍스트는 회색 이탤릭 + 깜빡이는 커서로 시각화
 - 녹음 중 `🔴 N단어 · M개 구간` 실시간 카운터
 
+> ⚠️ **Web Speech API는 발화를 상당량 놓칩니다.** 원거리·다인 대면 회의에서
+> 실측 포착률이 10% 안팎이었습니다(46분 회의 / 489어절). 회의 전사용으로
+> 설계된 엔진이 아니라 근접 음성 명령용입니다. 그래서 **오디오 원본을 반드시
+> 함께 남깁니다** — 놓친 발화는 나중에 서버 STT로 다시 살릴 수 있습니다.
+
+### 🎧 오디오 원본 보관
+
+녹음을 시작하면 전사와 **별개로** 마이크 입력을 오디오 파일로 저장합니다.
+
+- 15초마다 조각을 서버에 이어 붙여 **탭이나 서버가 죽어도 그때까지의 오디오는 남습니다**
+- 서버 저장이 실패해도 녹음은 중단되지 않고, 브라우저 사본을 **⬇️ 내려받기**로 회수할 수 있습니다
+- 한 조각도 못 받았으면 "보관됨"이라고 하지 않고 오류를 띄웁니다
+- 저장 위치: `uploads/recordings/` (Docker에서는 `uploads` 볼륨 → 재시작해도 유지)
+
+**캡처 설정** — 브라우저 기본값은 전화 통화용 튜닝이라 멀리 앉은 화자를
+노이즈로 지워버립니다. 그래서 노이즈 억제·에코 제거를 끄고 AGC만 남깁니다
+(`src/lib/recording.ts`의 `RECORDING_AUDIO_CONSTRAINTS`).
+
+**비트레이트** — 32kbps mono Opus. 감상용이 아니라 STT 입력이므로 인식 정확도를
+해치지 않는 선에서 최대한 작게 잡았습니다. 46분 회의가 약 11MB로, 전사 API에
+통째로 넣을 수 있습니다.
+
+---
+
+### 🔤 서버 STT 재전사 (정확도의 본선)
+
+보관된 오디오를 Whisper / Gemini로 다시 전사합니다. **Web Speech가 놓친 발화를
+되살리는 경로이며, 이 앱의 전사 정확도는 사실상 여기서 결정됩니다.**
+
+**쓰는 법**
+- 실시간 녹음 → 종료 → **🔤 원본 오디오로 다시 전사**
+- 또는 파일 업로드 탭 → 파일 선택 → **🔤 전사 시작**
+
+두 경로 모두 같은 파이프라인(`/api/transcribe`)을 씁니다.
+
+**실제 타임스탬프** — Whisper의 `verbose_json`은 구간별 실제 오디오 시각을 줍니다.
+Web Speech 경로가 쓰던 *"결과 이벤트 시각 − 2초"* 추정값과 달리, 구간 재생이나
+화자 분리에 그대로 쓸 수 있는 진짜 타임라인입니다.
+
+**참석자 · 용어 힌트** — 홈 화면의 입력란에 이름·제품명·사내 용어를 적어두면
+전사 요청의 어휘 힌트로 전달되어 고유명사 오인식이 크게 줍니다.
+
+**프로바이더별 지원**
+
+| 프로바이더 | 브라우저 녹음(webm) | 업로드 파일 | 기본 모델 |
+|---|:---:|:---:|---|
+| OpenAI / OrcaRouter / 로컬 whisper | ✅ | ✅ | `whisper-1` |
+| Google Gemini | ❌ | ✅ (mp3·wav·flac·m4a·ogg) | `gemini-3.6-flash` |
+
+Gemini는 webm 오디오를 받지 않습니다. **실시간 녹음을 전사하려면 OpenAI 호환
+프로바이더를 선택해야 합니다.** 설정 화면에서 이 경고를 함께 안내합니다.
+
+> 🔴 **전사는 회의 원음을 프로바이더 서버로 보냅니다.** 텍스트보다 훨씬 민감한
+> 데이터입니다. 외부 전송이 곤란하면 로컬 whisper 서버를 `base URL`로 지정하세요.
+> 자세한 내용은 [SECURITY.md](SECURITY.md)를 참고하세요.
+
 **사용**
 1. 홈에서 **🎤 녹음 시작** 클릭
 2. 마이크 권한 허용
@@ -102,38 +158,6 @@ docker compose up -d
 
 ---
 
-### 🗣️ 화자 분리
-
-누가 무슨 말을 했는지 구분해 기록합니다. 회의 환경에 따라 두 가지 방식을 씁니다.
-
-| 모드 | 방식 | 정확도 | 준비물 |
-|---|---|---|---|
-| **원격 회의** | 내 마이크와 시스템(탭) 오디오를 **별도 트랙**으로 받아 트랙별로 전사 | **100%** — 추론 없음 | 없음 |
-| **대면 회의** | 마이크 한 트랙을 **내 PC에서** 분석해 화자를 나눔 | DER 12~15% | 모델 1회 설치 |
-
-**원격 회의**는 트랙이 곧 화자라 틀릴 수가 없습니다. 시작할 때 화면 공유 대화상자에서
-**"탭 오디오 공유"를 반드시 켜야** 합니다. 켜지 않으면 마이크 단독 녹음으로 넘어가고
-화자 라벨이 붙지 않습니다 (틀린 라벨을 붙이지 않습니다).
-
-**대면 회의**는 `pyannote-segmentation-3.0` + `3D-Speaker CAM++` ONNX 모델을 로컬
-Next.js 프로세스에서 실행합니다. **오디오가 외부로 나가지 않습니다.** GPU도 파이썬
-런타임도 필요 없고, 노트북 CPU에서 실시간의 수십 배 속도로 처리됩니다.
-
-```bash
-# 최초 1회 — 모델 약 34MB 내려받기
-npm run setup:diarization
-```
-
-> 💡 **참석자 수를 정확히 입력하세요.** 자동 추정은 화자 수를 잘못 세는 것이 주 실패
-> 모드입니다. 실측에서 4인 오디오가 자동 모드로는 5명, 참석자 수를 알려주면 4명으로
-> 정확히 나왔습니다.
-
-대면 모드는 녹음이 끝난 뒤 **전체 오디오에 한 번** 분석을 돌립니다. 구간을 잘라
-반복 실행하면 실행마다 화자 번호가 달라져 이어 붙일 수 없기 때문입니다. 따라서
-녹음 중 실시간 화자 표시는 없고, 종료 시 원문 전체에 화자가 붙습니다.
-
----
-
 ### ⚡ 실시간 롤링 요약
 
 녹음 중 **30초마다** Gemini가 그동안의 발화를 분석해 중간 회의록을 자동 갱신합니다.
@@ -368,8 +392,7 @@ npm run test:coverage     # 커버리지 리포트
 | DB | PostgreSQL 16 + Prisma 7 (driver adapter `@prisma/adapter-pg`) |
 | Markdown | `marked` + `isomorphic-dompurify` |
 | 스타일 | Tailwind CSS v4 |
-| 화자 분리 | pyannote-segmentation-3.0 + CAM++ (ONNX Runtime, CPU) |
+| 테스트 | Vitest 4 (jsdom, 141 tests) |
-| 테스트 | Vitest 4 (jsdom, 184 tests) |
 | 배포 | Docker Compose + standalone Next.js 빌드 |
 
 ---
@@ -517,8 +540,11 @@ prisma/
 
 | 제약 | 설명 | 대응 |
 |---|---|---|
-| **Chrome 전용** | Web Speech API는 비표준 — Safari / Firefox는 제한적 | Phase 4에서 서버 사이드 전사 검토 |
+| **Chrome 전용** | Web Speech API는 비표준 — Safari / Firefox는 제한적 | 서버 사이드 STT 전환 예정 |
-| **화자 구분 없음** | 의도적 비지원 (Non-goal) | — |
+| **Web Speech 포착률 낮음** | 원거리·다인 대면 회의 실측 10% 안팎 | 종료 후 **서버 STT 재전사**로 해결 |
+| **Gemini는 webm 전사 불가** | Gemini가 받는 오디오 형식에 webm이 없음 | 녹음 전사는 OpenAI 호환 프로바이더 사용 |
+| **긴 회의 전사 상한** | Whisper 25MB(≈1시간 40분) / Gemini inline 14MB(≈1시간) | 초과 시 오류 안내. 분할 전사는 후속 |
+| **화자 구분 없음** | 미구현 (PR #16 / #17 검토 중) | — |
 | **Gemini 무료 등급 한도** | 15 RPM / 1000 RPD | 한도 초과 시 자동 쿨다운, 단순 변환 폴백 |
 | **단일 사용자** | 인증 없음, 데이터 격리 없음 | 1인 1인스턴스로 운용 |
 | **마크다운 검색** | PostgreSQL `ILIKE` (수천 건 이상에서 느려질 수 있음) | 필요 시 `tsvector` 인덱스 추가 |

SECURITY.md

@@ -52,7 +52,6 @@
 | 액션 아이템 | PostgreSQL (`action_items`) | 외부 송출 없음 |
 | API 키 | 브라우저 LocalStorage 또는 `.env` | 요청 시 선택한 프로바이더에만 전송 |
 | 음성 데이터 | 메모리 (실시간), `/app/uploads` (파일 업로드) | **Chrome Web Speech API → Google 서버** ⚠️ |
-| 화자 분리용 PCM | 서버 프로세스 메모리 (녹음 중에만) | **외부 송출 없음** — 로컬에서 분석하고 분석 후 즉시 폐기 |
 
 ### ⚠️ 주의: Web Speech API의 음성 외부 전송
 
@@ -64,6 +63,27 @@ Chrome의 `SpeechRecognition` API는 **음성 데이터를 Google 서버로 전
 
 이 경우 **파일 업로드 탭**도 같은 한계가 있으므로(현재 업로드 후 전사는 미구현, Phase 4에서 자체 STT 검토 예정), 이 도구의 사용을 보류하는 것을 권장합니다.
 
+### 🔴 주의: 서버 전사(STT)는 회의 **원음**을 외부로 보냅니다
+
+"원본 오디오로 다시 전사" 또는 파일 업로드 전사를 실행하면, 회의 오디오 파일이
+**통째로** 선택한 프로바이더 서버로 전송됩니다.
+
+이것은 이 앱에서 가장 민감도가 높은 데이터 흐름입니다. 전사 텍스트는 Web Speech가
+대부분 놓치지만, **오디오에는 회의에서 오간 모든 말과 목소리가 그대로 담겨 있습니다.**
+
+| 프로바이더 | 오디오가 가는 곳 |
+|---|---|
+| Gemini | Google 서버 |
+| OpenAI | OpenAI 서버 |
+| OrcaRouter 등 중계 | 중계사 → 실제 모델 제공사 (2단계) |
+| **로컬 whisper** | **나가지 않음** (whisper.cpp / faster-whisper 등을 `LLM_BASE_URL`로 지정) |
+
+**외부 전송이 곤란한 회의라면 로컬 whisper 서버를 쓰세요.** 설정 → 프로바이더에서
+"로컬 모델"을 고르고 base URL을 로컬 whisper 엔드포인트로 지정하면 오디오가
+머신 밖으로 나가지 않습니다.
+
+전사는 사용자가 버튼을 눌러야만 실행됩니다. 녹음만으로는 오디오가 전송되지 않습니다.
+
 ### ⚠️ 주의: AI 프로바이더 선택에 따른 전송 경로
 
 `/settings`에서 고른 프로바이더에 따라 **회의 전문이 지나가는 회사가 달라집니다.**
@@ -78,21 +98,6 @@ Chrome의 `SpeechRecognition` API는 **음성 데이터를 Google 서버로 전
 - 중계 라우터는 요청을 대신 전달하는 구조상 **평문 프롬프트를 볼 수 있는 주체가 한 곳 늘어납니다.** 로깅·보관 정책은 각 서비스 약관을 직접 확인하세요.
 - 사내 컴플라이언스가 외부 전송을 제한한다면 **로컬 모델** 프리셋을 사용하세요.
 
-### 화자 분리 오디오는 로컬에만 머뭅니다
-
-대면 회의 화자 분리는 `pyannote-segmentation-3.0` + `CAM++` ONNX 모델을 로컬
-Next.js 프로세스에서 실행합니다. 외부 API를 호출하지 않으므로 **오디오가 네트워크로
-나가지 않습니다.**
-
-- 녹음 중 PCM 조각이 서버 프로세스 **메모리**에 쌓입니다 (디스크에 쓰지 않음)
-- 분석이 끝나면 즉시 폐기하며, 6시간 지난 세션은 자동 정리됩니다
-- 세션 최대 길이는 3시간으로 제한됩니다
-- 단일 사용자 로컬 실행 전제입니다. 여러 사용자가 붙는 환경이라면 세션 ID를
-  추측해 다른 사람의 오디오에 접근할 수 있으므로, 노출 배포 시 인증이 선행되어야 합니다
-
-전사 텍스트는 여전히 Web Speech API를 거치므로 Google로 갑니다. 화자 분리만
-로컬이라는 점에 유의하세요.
-
 ### base URL은 서버가 대신 호출합니다 (SSRF 주의)
 
 OpenAI 호환 프리셋의 base URL은 브라우저가 아니라 **Next.js Route Handler(서버)** 가 fetch 합니다.
@@ -148,6 +153,26 @@ OpenAI 호환 프리셋의 base URL은 브라우저가 아니라 **Next.js Route
 - 추가 보호가 필요하면 reverse proxy(nginx, Caddy)에 Basic Auth 추가
 - 회사 환경에서는 SSO 통합이 필요하지만 현재 비목표
 
+### MEDIUM — 회의 원음이 디스크에 평문으로 남습니다
+
+**현황**: 실시간 녹음을 시작하면 회의 오디오 원본이 `uploads/recordings/`에 저장됩니다
+(Docker에서는 `uploads` 볼륨). 암호화하지 않은 평문 오디오이며, 회의에서 오간
+말이 그대로 들어 있습니다. **전사 텍스트보다 민감도가 높습니다** — 텍스트는
+Web Speech가 대부분 놓치지만 오디오에는 전부 남습니다.
+
+이 저장은 의도된 설계입니다. Web Speech의 포착률이 낮아(실측 10% 안팎) 원음을
+남기지 않으면 놓친 발화를 복구할 방법이 없습니다.
+
+**완화**:
+- 디스크 암호화(FileVault / BitLocker)가 켜진 머신에서 운용
+- 불필요해진 녹음은 `uploads/recordings/`에서 직접 삭제
+- `RECORDINGS_DIR` 환경변수로 저장 위치를 별도 암호화 볼륨으로 지정 가능
+- 녹음 파일 자동 만료/삭제는 **미구현** — 수동 관리가 필요합니다
+
+**세션 ID 추측**: 녹음 조회·추가 API는 128비트 난수 ID만으로 접근을 가릅니다.
+인증이 없으므로, 같은 머신에서 앱에 접근 가능한 주체는 ID를 알면 오디오를
+내려받을 수 있습니다. 단일 사용자 로컬 실행 전제입니다.
+
 ### MEDIUM — 파일 업로드 매직 바이트 미검증
 **현황**: `audio-validation.ts`는 `file.type`(클라이언트 제공)과 파일명 확장자만 검사. 매직 바이트 검증 없음.
 

docs/ROADMAP.md

@@ -155,6 +155,70 @@
 
 ---
 
+## 🔴 실사용 진단 (2026-09-08 대면 회의)
+
+46분 대면 회의를 실제로 녹음해 본 결과다. 로드맵의 우선순위를 바꾼 근거.
+
+| 지표 | 값 |
+|---|---|
+| 회의 길이 | 46분 6초 |
+| 총 청크 | 122개 |
+| 총 어절 | **489** |
+| 분당 어절 | **10.6** (한국어 대화 통상 100~150) |
+| 추정 포착률 | **7~10%** |
+| 30초 이상 공백 | 26곳 / 합계 26분 29초 (회의의 57%) |
+| 빈 텍스트 청크 | 19개 (16%) |
+
+**빈 청크 19개가 결정적 증거다.** Chrome이 `isFinal: true`에 `transcript: ""`를
+준 경우로, "소리는 감지했으나 인식 실패"를 뜻한다. 마이크 입력 문제가 아니라
+Web Speech가 원거리·다인 한국어를 못 알아듣고 버린 것이다.
+
+**결론: Web Speech API는 회의 전사에 쓸 수 없다.** 재시작 갭을 메우고 interim을
+flush해서 7%를 20~30%로는 올려도 90%로는 못 간다. 구현 결함이 아니라 엔진의 한계다.
+
+---
+
+## 🎯 P0 — 유실을 멈춘다
+
+- [x] **오디오 원본 녹음** — `MediaRecorder`로 회의 원음을 파일로 보관
+  - [x] 15초 조각 단위로 서버에 append → 탭/서버가 죽어도 그때까지는 남음
+  - [x] 서버 실패해도 녹음 계속 + 브라우저 사본 내려받기
+  - [x] 0바이트일 때 "보관됨"이라고 하지 않음
+  - [x] 캡처 제약에서 노이즈 억제·에코 제거 해제 (원거리 화자 보존)
+  - [x] 회의록 저장 시 `audioFileName`/`audioMimeType`/`audioDuration` 연결
+- [x] **서버 STT 파이프라인** — 녹음 파일 → Whisper / Gemini audio → transcript
+  - [x] `/api/upload`를 막다른 길에서 본선 경로로 승격 (업로드 → recordingId → 전사)
+  - [x] 프로바이더 레이어에 `/v1/audio/transcriptions` 추가 (#12 구조 확장)
+  - [x] Gemini 오디오 inline 입력 (webm 미지원은 명시적으로 안내)
+  - [x] `verbose_json`으로 실제 오디오 타임스탬프 확보
+  - [x] 참석자·용어 힌트를 전사 프롬프트로 전달
+  - [x] 녹음 비트레이트 32kbps로 하향 — 46분 회의가 11MB로 API 상한 안에 들어옴
+  - [ ] 같은 오디오로 Web Speech vs STT 포착률 실측 비교 ← **다음 회의에서**
+  - [ ] 상한 초과 회의 분할 전사 (Whisper 25MB / Gemini inline 14MB)
+  - [ ] Gemini Files API 경로 (큰 파일 + webm 우회)
+  - [ ] Web Speech를 "실시간 미리보기"로 명시적 강등 (현재는 둘 다 노출)
+- [ ] **빈 청크 필터링** — 빈 발화 19개가 요약 프롬프트를 오염시키고 있음
+- [ ] **타임스탬프 실측화** — `useSpeechRecognition.ts`의 `startTime: now - 2` 하드코딩 제거
+- [ ] **10만 자 하드 실패 → 분할 요약** — 긴 회의가 마지막에 통째로 실패함
+
+## 🎯 P1 — 입력단 개선
+
+- [ ] 대면 회의용 USB 전방향 마이크 도입 (코드로 못 푸는 물리적 한계)
+- [ ] 원격 회의용 `echoCancellation` 재활성 경로 분리
+
+## 🎯 P2 — 화자 분리 재설계
+
+- [ ] **PR #17은 현재 형태로 머지 보류** — 실사용에서 46분 회의를 화자 1명으로
+      판정했고, 5개 청크는 배정조차 실패했다. `assignSpeakers()`가 쓰는 시간축이
+      가짜(`now - 2`)라 diarization의 실제 타임라인과 맞지 않는다
+- [ ] 서버 STT 도입 후 재설계 — Whisper의 단어 단위 실제 타임스탬프 위에서
+      diarization을 돌리면 그때 비로소 겹침 기반 배정이 의미를 갖는다
+- [ ] #17의 sherpa-onnx 래퍼·모델 셋업 스크립트는 그때 재활용
+- [ ] 참석자 수 힌트는 유지 (#17 실측에서 효과 확인됨)
+- [ ] PR #16(dual-stream)은 원격 회의 전용으로 분리 검증
+
+---
+
 ## 🎯 Phase 3 — 참석자 + 태그 (3~5일)
 
 ### Issues
@@ -199,7 +263,6 @@
 
 다음 기능은 개인 사용 목적에 부합하지 않아 **의도적으로 범위 밖**:
 
-- **화자 구분 (Speaker Diarization)** — 유료 API 비용/복잡도 대비 개인용에 과함
 - **실시간 공동 편집 (CRDT)** — Yjs/Liveblocks 도입 복잡도 대비 이득 없음
 - **권한 관리 / 워크스페이스** — 단일 사용자 가정
 - **모바일 네이티브 앱** — 웹 PWA로 충분

next.config.ts

@@ -12,8 +12,6 @@ const securityHeaders = [
 
 const nextConfig: NextConfig = {
   output: "standalone",
-  // sherpa-onnx-node는 네이티브 애드온이라 번들링하면 안 된다.
-  serverExternalPackages: ["sherpa-onnx-node"],
   async headers() {
     return [
       {

package-lock.json

@@ -16,8 +16,7 @@
         "pg": "^8.13.1",
         "prisma": "^7.7.0",
         "react": "19.2.4",
-        "react-dom": "19.2.4",
+        "react-dom": "19.2.4"
-        "sherpa-onnx-node": "^1.13.7"
       },
       "devDependencies": {
         "@tailwindcss/postcss": "^4",
@@ -8423,98 +8422,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/sherpa-onnx-darwin-arm64": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-darwin-arm64/-/sherpa-onnx-darwin-arm64-1.13.7.tgz",
-      "integrity": "sha512-5NCE50hAvr3n2pdett0SgfPBJXaFZE0bqHwbHyiq+IKZ8Ids0l4M0VrG+ImGYIafCwie+oC3uAJ+pKj9xg/k+w==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/sherpa-onnx-darwin-x64": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-darwin-x64/-/sherpa-onnx-darwin-x64-1.13.7.tgz",
-      "integrity": "sha512-N3o+T+wn9WaQmsKV5DD8bTHdo+WN2+sXwmZcGJZiDjtOMR2zFz7uVCZnYCmEAMgvChC+oHcF5RvEEKcRCAu6Pw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "darwin"
-      ]
-    },
-    "node_modules/sherpa-onnx-linux-arm64": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-linux-arm64/-/sherpa-onnx-linux-arm64-1.13.7.tgz",
-      "integrity": "sha512-TFCVpXyTh69buhOtTS8KIfkRXOVKY4Y1qjAktSItrKS4A0chnnrlXO5bKWoNAPeI6fMxTF/uvMYbYgcvjEMfNg==",
-      "cpu": [
-        "arm64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/sherpa-onnx-linux-x64": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-linux-x64/-/sherpa-onnx-linux-x64-1.13.7.tgz",
-      "integrity": "sha512-npmxn5WwmAmlthgBhmbZ33t3i2j4mJwQt46dMEb3j7d41y1/uJrjrVAfa/DkvV+vn49ZWfcQ2UEWDipaZBVhuw==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "linux"
-      ]
-    },
-    "node_modules/sherpa-onnx-node": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-node/-/sherpa-onnx-node-1.13.7.tgz",
-      "integrity": "sha512-0XGV7arGngBCnol0m8OLyqlnaUm19Q1KmetVj1DDBdymXa1upmAHZDwNdN47gjsEhqE5hXUEyc1vRQoXrNhNVg==",
-      "license": "Apache-2.0",
-      "optionalDependencies": {
-        "sherpa-onnx-darwin-arm64": "^1.13.7",
-        "sherpa-onnx-darwin-x64": "^1.13.7",
-        "sherpa-onnx-linux-arm64": "^1.13.7",
-        "sherpa-onnx-linux-x64": "^1.13.7",
-        "sherpa-onnx-win-ia32": "^1.13.7",
-        "sherpa-onnx-win-x64": "^1.13.7"
-      }
-    },
-    "node_modules/sherpa-onnx-win-ia32": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-win-ia32/-/sherpa-onnx-win-ia32-1.13.7.tgz",
-      "integrity": "sha512-sTwtpxPQ76XLn0giAbvknIDEDKD3XXi2mo2AVROEucf1pIK1DjQl+LjLkalTeFoQqbC4J3xGx/g+xgcHQD1dsw==",
-      "cpu": [
-        "ia32"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
-    "node_modules/sherpa-onnx-win-x64": {
-      "version": "1.13.7",
-      "resolved": "https://registry.npmjs.org/sherpa-onnx-win-x64/-/sherpa-onnx-win-x64-1.13.7.tgz",
-      "integrity": "sha512-wBV1o+/zgsMrOjfCFIgGrH6S28xq6CqRCLSavCOjTZ6cqr80yGc07DUHxqsHFPZvfoJU+2JF5L2l3gyWFWoWdQ==",
-      "cpu": [
-        "x64"
-      ],
-      "license": "Apache-2.0",
-      "optional": true,
-      "os": [
-        "win32"
-      ]
-    },
     "node_modules/side-channel": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",

package.json

@@ -9,8 +9,7 @@
     "lint": "eslint",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage"
-    "setup:diarization": "node scripts/setup-diarization.mjs"
   },
   "dependencies": {
     "@prisma/adapter-pg": "^7.7.0",
@@ -21,8 +20,7 @@
     "pg": "^8.13.1",
     "prisma": "^7.7.0",
     "react": "19.2.4",
-    "react-dom": "19.2.4",
+    "react-dom": "19.2.4"
-    "sherpa-onnx-node": "^1.13.7"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",

public/pcm-worklet.js

@@ -1,38 +0,0 @@
-/**
- * 마이크 오디오를 Int16 PCM 조각으로 잘라 메인 스레드로 넘긴다.
- *
- * AudioContext를 16kHz로 열면 브라우저가 리샘플링해주므로 여기서는
- * float32 → int16 변환과 버퍼링만 한다. 화자 분리 모델이 16kHz 모노를 받는다.
- */
-const CHUNK_SAMPLES = 16000 * 4 // 4초
-
-class PcmCollector extends AudioWorkletProcessor {
-  constructor() {
-    super()
-    this.buffer = new Int16Array(CHUNK_SAMPLES)
-    this.offset = 0
-  }
-
-  flush() {
-    if (this.offset === 0) return
-    const out = this.buffer.slice(0, this.offset)
-    this.port.postMessage(out, [out.buffer])
-    this.buffer = new Int16Array(CHUNK_SAMPLES)
-    this.offset = 0
-  }
-
-  process(inputs) {
-    const channel = inputs[0] && inputs[0][0]
-    if (!channel) return true
-
-    for (let i = 0; i < channel.length; i++) {
-      const clamped = Math.max(-1, Math.min(1, channel[i]))
-      this.buffer[this.offset++] = clamped * 32767
-      if (this.offset === CHUNK_SAMPLES) this.flush()
-    }
-
-    return true
-  }
-}
-
-registerProcessor('pcm-collector', PcmCollector)

scripts/setup-diarization.mjs

@@ -1,98 +0,0 @@
-#!/usr/bin/env node
-/**
- * 화자 분리 모델 내려받기.
- *
- * 두 모델 모두 CPU에서 도는 ONNX 파일이며 GPU나 파이썬 런타임이 필요 없다.
- * 라이선스 문제로 저장소에 포함하지 않고 최초 1회 내려받는다.
- *
- *   npm run setup:diarization
- */
-import { createWriteStream } from 'node:fs'
-import { mkdir, rename, rm, stat } from 'node:fs/promises'
-import { pipeline } from 'node:stream/promises'
-import path from 'node:path'
-import { spawn } from 'node:child_process'
-
-const DEST = path.join(process.cwd(), 'models', 'diarization')
-
-const MODELS = [
-  {
-    name: 'segmentation.onnx',
-    // pyannote/segmentation-3.0 (MIT) — 발화 구간 분할
-    url: 'https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-segmentation-models/sherpa-onnx-pyannote-segmentation-3-0.tar.bz2',
-    archiveEntry: 'sherpa-onnx-pyannote-segmentation-3-0/model.onnx',
-    approxMB: 6,
-  },
-  {
-    name: 'embedding.onnx',
-    // 3D-Speaker CAM++ — 화자 임베딩
-    url: 'https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/3dspeaker_speech_campplus_sv_zh-cn_16k-common.onnx',
-    approxMB: 28,
-  },
-]
-
-async function exists(p) {
-  try {
-    await stat(p)
-    return true
-  } catch {
-    return false
-  }
-}
-
-async function download(url, dest) {
-  const res = await fetch(url, { redirect: 'follow' })
-  if (!res.ok) throw new Error(`${res.status} ${res.statusText} — ${url}`)
-  await pipeline(res.body, createWriteStream(dest))
-}
-
-function run(cmd, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(cmd, args, { cwd, stdio: 'inherit' })
-    child.on('error', reject)
-    child.on('exit', (code) =>
-      code === 0 ? resolve() : reject(new Error(`${cmd} 실패 (exit ${code})`)),
-    )
-  })
-}
-
-async function main() {
-  await mkdir(DEST, { recursive: true })
-
-  for (const model of MODELS) {
-    const target = path.join(DEST, model.name)
-
-    if (await exists(target)) {
-      console.log(`✓ ${model.name} — 이미 있음`)
-      continue
-    }
-
-    console.log(`↓ ${model.name} (약 ${model.approxMB}MB) 내려받는 중...`)
-
-    if (!model.archiveEntry) {
-      await download(model.url, target)
-      console.log(`✓ ${model.name}`)
-      continue
-    }
-
-    const archive = path.join(DEST, 'tmp.tar.bz2')
-    await download(model.url, archive)
-    await run('tar', ['xjf', archive], DEST)
-    await rename(path.join(DEST, model.archiveEntry), target)
-    await rm(archive)
-    await rm(path.join(DEST, path.dirname(model.archiveEntry)), {
-      recursive: true,
-      force: true,
-    })
-    console.log(`✓ ${model.name}`)
-  }
-
-  console.log(`\n완료. 모델 위치: ${DEST}`)
-  console.log('이제 녹음 화면에서 "대면 회의 화자 분리"를 쓸 수 있습니다.')
-}
-
-main().catch((err) => {
-  console.error(`\n✗ 실패: ${err.message}`)
-  console.error('네트워크를 확인하고 다시 실행해주세요.')
-  process.exit(1)
-})

src/__tests__/api-key-storage.test.ts

@@ -71,6 +71,8 @@ describe('프로바이더 설정 저장', () => {
       apiKey: 'sk-test',
       baseUrl: 'https://api.orcarouter.ai/v1',
       model: 'google/gemini-2.5-flash-lite',
+      // 예전에 저장된 설정에는 sttModel이 없다. 빈 값으로 채워 마이그레이션 없이 읽힌다.
+      sttModel: '',
     })
   })
 
@@ -105,6 +107,7 @@ describe('getProviderRequestPayload', () => {
       apiKey: 'AIza-legacy',
       baseUrl: '',
       model: '',
+      sttModel: '',
     })
   })
 
@@ -114,6 +117,7 @@ describe('getProviderRequestPayload', () => {
       apiKey: '',
       baseUrl: '',
       model: '',
+      sttModel: '',
     })
   })
 
@@ -130,6 +134,7 @@ describe('getProviderRequestPayload', () => {
       apiKey: '',
       baseUrl: 'http://localhost:11434/v1',
       model: 'llama3.1',
+      sttModel: '',
     })
   })
 

src/__tests__/recording-store.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { mkdtemp, rm, readFile } from 'fs/promises'
+import { tmpdir } from 'os'
+import path from 'path'
+
+type Store = typeof import('@/lib/recording-store')
+
+let dir: string
+let store: Store
+
+beforeEach(async () => {
+  dir = await mkdtemp(path.join(tmpdir(), 'recordings-'))
+  process.env.RECORDINGS_DIR = dir
+  vi.resetModules()
+  store = await import('@/lib/recording-store')
+})
+
+afterEach(async () => {
+  delete process.env.RECORDINGS_DIR
+  await rm(dir, { recursive: true, force: true })
+})
+
+describe('createRecording', () => {
+  it('세션 메타를 만들고 확장자를 붙인다', async () => {
+    const meta = await store.createRecording('audio/webm;codecs=opus')
+
+    expect(meta.id).toMatch(/^[0-9a-f]{32}$/)
+    expect(meta.fileName).toBe(`${meta.id}.webm`)
+    expect(meta.finalizedAt).toBeNull()
+    expect(meta.durationMs).toBeNull()
+  })
+
+  it('매번 다른 id를 준다', async () => {
+    const a = await store.createRecording('audio/webm')
+    const b = await store.createRecording('audio/webm')
+    expect(a.id).not.toBe(b.id)
+  })
+})
+
+describe('appendChunk', () => {
+  it('조각을 받은 순서대로 이어 붙인다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+
+    await store.appendChunk(id, Buffer.from('AAA'))
+    await store.appendChunk(id, Buffer.from('BBB'))
+    const last = await store.appendChunk(id, Buffer.from('CC'))
+
+    expect(last).toEqual({ ok: true, bytes: 8 })
+
+    const meta = await store.getRecording(id)
+    const written = await readFile(path.join(dir, meta!.fileName), 'utf-8')
+    expect(written).toBe('AAABBBCC')
+  })
+
+  it('동시에 들어와도 순서가 섞이지 않는다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+
+    // 클라이언트가 직렬로 보내도 서버에서 겹칠 수 있다. 겹쳐도 파일이
+    // 깨지지 않아야 한다 — 순서가 어긋나면 컨테이너를 못 읽는다.
+    await Promise.all([
+      store.appendChunk(id, Buffer.from('1')),
+      store.appendChunk(id, Buffer.from('2')),
+      store.appendChunk(id, Buffer.from('3')),
+      store.appendChunk(id, Buffer.from('4')),
+    ])
+
+    const meta = await store.getRecording(id)
+    const written = await readFile(path.join(dir, meta!.fileName), 'utf-8')
+    expect(written).toHaveLength(4)
+    expect(written.split('').sort().join('')).toBe('1234')
+  })
+
+  it('없는 세션은 404로 거절한다', async () => {
+    const result = await store.appendChunk('f'.repeat(32), Buffer.from('x'))
+    expect(result).toEqual({
+      ok: false,
+      error: '녹음 세션을 찾을 수 없습니다.',
+      status: 404,
+    })
+  })
+
+  it('누적 크기를 정확히 보고한다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('keep'))
+
+    const result = await store.appendChunk(id, Buffer.alloc(1024))
+    expect(result).toEqual({ ok: true, bytes: 4 + 1024 })
+  })
+})
+
+describe('finalizeRecording', () => {
+  it('길이를 확정하고 최종 크기를 돌려준다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('0123456789'))
+
+    const status = await store.finalizeRecording(id, 46_000)
+
+    expect(status?.bytes).toBe(10)
+    expect(status?.durationMs).toBe(46_000)
+    expect(status?.finalizedAt).not.toBeNull()
+  })
+
+  it('확정 정보가 디스크에도 남는다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.finalizeRecording(id, 1_234)
+
+    const reloaded = await store.getRecording(id)
+    expect(reloaded?.durationMs).toBe(1_234)
+  })
+
+  it('길이가 숫자가 아니면 null로 둔다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    const status = await store.finalizeRecording(id, null)
+    expect(status?.durationMs).toBeNull()
+  })
+
+  it('없는 세션은 null', async () => {
+    expect(await store.finalizeRecording('e'.repeat(32), 1)).toBeNull()
+  })
+})
+
+describe('getRecording', () => {
+  it('잘못된 id는 파일을 찾아보지도 않는다', async () => {
+    expect(await store.getRecording('../../etc/passwd')).toBeNull()
+    expect(await store.getRecording('..')).toBeNull()
+  })
+})
+
+describe('openRecording', () => {
+  it('조각이 하나도 없으면 null', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    expect(await store.openRecording(id)).toBeNull()
+  })
+
+  it('저장된 바이트를 그대로 읽어준다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('hello'))
+
+    const opened = await store.openRecording(id)
+    expect(opened?.bytes).toBe(5)
+    expect(opened?.meta.mimeType).toBe('audio/webm')
+
+    const chunks: Buffer[] = []
+    for await (const chunk of opened!.stream) {
+      chunks.push(Buffer.from(chunk as Buffer))
+    }
+    expect(Buffer.concat(chunks).toString()).toBe('hello')
+  })
+})
+
+describe('크래시 내성', () => {
+  it('종료 처리 없이 중단돼도 그때까지의 오디오는 남는다', async () => {
+    const { id } = await store.createRecording('audio/webm')
+    await store.appendChunk(id, Buffer.from('part1'))
+    await store.appendChunk(id, Buffer.from('part2'))
+    // finalize 없이 프로세스가 죽었다고 치고 모듈을 새로 읽는다.
+    vi.resetModules()
+    const reloaded: Store = await import('@/lib/recording-store')
+
+    const status = await reloaded.getRecordingStatus(id)
+    expect(status?.bytes).toBe(10)
+    expect(status?.finalizedAt).toBeNull()
+  })
+})

src/__tests__/recording.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest'
+import {
+  PREFERRED_MIME_TYPES,
+  RECORDING_AUDIO_CONSTRAINTS,
+  extensionForMimeType,
+  formatBytes,
+  formatDuration,
+  isValidRecordingId,
+  pickRecorderMimeType,
+  recordingDownloadName,
+} from '@/lib/recording'
+
+describe('pickRecorderMimeType', () => {
+  it('가장 앞선 후보를 고른다', () => {
+    const picked = pickRecorderMimeType(() => true)
+    expect(picked).toBe(PREFERRED_MIME_TYPES[0])
+  })
+
+  it('지원하지 않는 후보는 건너뛴다', () => {
+    const picked = pickRecorderMimeType((type) => type === 'audio/mp4')
+    expect(picked).toBe('audio/mp4')
+  })
+
+  it('아무것도 지원하지 않으면 null', () => {
+    expect(pickRecorderMimeType(() => false)).toBeNull()
+  })
+})
+
+describe('extensionForMimeType', () => {
+  it('코덱 파라미터를 떼고 판단한다', () => {
+    expect(extensionForMimeType('audio/webm;codecs=opus')).toBe('webm')
+    expect(extensionForMimeType('audio/ogg; codecs=opus')).toBe('ogg')
+  })
+
+  it('주요 컨테이너를 매핑한다', () => {
+    expect(extensionForMimeType('audio/webm')).toBe('webm')
+    expect(extensionForMimeType('audio/mp4')).toBe('m4a')
+    expect(extensionForMimeType('audio/mpeg')).toBe('mp3')
+    expect(extensionForMimeType('audio/wav')).toBe('wav')
+  })
+
+  it('대소문자를 가리지 않는다', () => {
+    expect(extensionForMimeType('AUDIO/WEBM')).toBe('webm')
+  })
+
+  it('모르는 형식은 bin으로 떨어진다', () => {
+    expect(extensionForMimeType('application/octet-stream')).toBe('bin')
+  })
+})
+
+describe('isValidRecordingId', () => {
+  const valid = 'a'.repeat(32)
+
+  it('32자 hex만 통과시킨다', () => {
+    expect(isValidRecordingId(valid)).toBe(true)
+    expect(isValidRecordingId('0123456789abcdef0123456789abcdef')).toBe(true)
+  })
+
+  it('경로 조작 시도를 막는다', () => {
+    expect(isValidRecordingId('../../etc/passwd')).toBe(false)
+    expect(isValidRecordingId(`${valid}/../x`)).toBe(false)
+    expect(isValidRecordingId('..')).toBe(false)
+    expect(isValidRecordingId(`../${valid}`)).toBe(false)
+  })
+
+  it('길이나 문자셋이 어긋나면 거부한다', () => {
+    expect(isValidRecordingId('a'.repeat(31))).toBe(false)
+    expect(isValidRecordingId('a'.repeat(33))).toBe(false)
+    expect(isValidRecordingId('A'.repeat(32))).toBe(false)
+    expect(isValidRecordingId('g'.repeat(32))).toBe(false)
+    expect(isValidRecordingId('')).toBe(false)
+  })
+
+  it('문자열이 아니면 거부한다', () => {
+    expect(isValidRecordingId(null)).toBe(false)
+    expect(isValidRecordingId(undefined)).toBe(false)
+    expect(isValidRecordingId(123)).toBe(false)
+  })
+})
+
+describe('recordingDownloadName', () => {
+  const at = new Date(2026, 8, 8, 14, 5)
+
+  it('날짜와 제목을 붙인다', () => {
+    expect(recordingDownloadName('주간 회의', at, 'audio/webm')).toBe(
+      '20260908-1405_주간_회의.webm',
+    )
+  })
+
+  it('제목이 없으면 날짜만 쓴다', () => {
+    expect(recordingDownloadName('   ', at, 'audio/webm')).toBe(
+      '20260908-1405.webm',
+    )
+  })
+
+  it('파일명에 못 쓰는 문자를 지운다', () => {
+    const name = recordingDownloadName('a/b\\c:d*e?f"g<h>i|j', at, 'audio/webm')
+    expect(name).toBe('20260908-1405_abcdefghij.webm')
+    expect(name).not.toMatch(/[\\/:*?"<>|]/)
+  })
+
+  it('아주 긴 제목을 자른다', () => {
+    const name = recordingDownloadName('가'.repeat(200), at, 'audio/webm')
+    expect(name.length).toBeLessThan(90)
+  })
+})
+
+describe('formatBytes', () => {
+  it('단위를 바꿔가며 표기한다', () => {
+    expect(formatBytes(512)).toBe('512B')
+    expect(formatBytes(2048)).toBe('2KB')
+    expect(formatBytes(5 * 1024 * 1024)).toBe('5.0MB')
+  })
+
+  it('비정상 값은 0으로 떨어진다', () => {
+    expect(formatBytes(-1)).toBe('0B')
+    expect(formatBytes(NaN)).toBe('0B')
+  })
+})
+
+describe('formatDuration', () => {
+  it('한 시간 미만은 분:초', () => {
+    expect(formatDuration(0)).toBe('00:00')
+    expect(formatDuration(65_000)).toBe('01:05')
+    expect(formatDuration(46 * 60_000 + 6_000)).toBe('46:06')
+  })
+
+  it('한 시간 이상은 시:분:초', () => {
+    expect(formatDuration(3_600_000)).toBe('1:00:00')
+    expect(formatDuration(3_725_000)).toBe('1:02:05')
+  })
+
+  it('음수는 0으로 본다', () => {
+    expect(formatDuration(-5_000)).toBe('00:00')
+  })
+})
+
+describe('RECORDING_AUDIO_CONSTRAINTS', () => {
+  it('원거리 화자를 지우는 전처리를 끈다', () => {
+    // 46분 대면 회의에서 포착률이 10% 안팎에 그친 원인 중 하나.
+    // 이 값이 다시 true로 돌아가면 회귀다.
+    expect(RECORDING_AUDIO_CONSTRAINTS.noiseSuppression).toBe(false)
+    expect(RECORDING_AUDIO_CONSTRAINTS.echoCancellation).toBe(false)
+  })
+
+  it('조용한 화자를 끌어올리는 AGC는 남긴다', () => {
+    expect(RECORDING_AUDIO_CONSTRAINTS.autoGainControl).toBe(true)
+  })
+})

src/__tests__/speakers.test.ts

@@ -1,62 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  LOCAL_SPEAKER,
-  REMOTE_SPEAKER,
-  diarizedSpeakerId,
-  listAttendees,
-  resolveSpeakerName,
-} from '@/lib/speakers'
-
-describe('resolveSpeakerName', () => {
-  it('기본 화자에 한국어 표기를 붙인다', () => {
-    expect(resolveSpeakerName(LOCAL_SPEAKER)).toBe('나')
-    expect(resolveSpeakerName(REMOTE_SPEAKER)).toBe('상대')
-  })
-
-  it('사용자가 지정한 이름이 우선한다', () => {
-    const names = { [REMOTE_SPEAKER]: '김지훈' }
-    expect(resolveSpeakerName(REMOTE_SPEAKER, names)).toBe('김지훈')
-    expect(resolveSpeakerName(LOCAL_SPEAKER, names)).toBe('나')
-  })
-
-  it('공백뿐인 이름은 무시한다', () => {
-    expect(resolveSpeakerName(LOCAL_SPEAKER, { [LOCAL_SPEAKER]: '   ' })).toBe('나')
-  })
-
-  it('diarization 화자 번호를 한국어 표기로 바꾼다', () => {
-    expect(resolveSpeakerName('spk_1')).toBe('화자 1')
-    expect(resolveSpeakerName('spk_3')).toBe('화자 3')
-  })
-
-  it('diarization 화자에도 지정 이름이 우선한다', () => {
-    expect(resolveSpeakerName('spk_2', { spk_2: '박지연' })).toBe('박지연')
-  })
-
-  it('그 밖의 식별자는 그대로 돌려준다', () => {
-    expect(resolveSpeakerName('unknown')).toBe('unknown')
-  })
-})
-
-describe('listAttendees', () => {
-  it('중복을 제거하고 순서를 유지한다', () => {
-    expect(
-      listAttendees([REMOTE_SPEAKER, LOCAL_SPEAKER, REMOTE_SPEAKER]),
-    ).toEqual(['상대', '나'])
-  })
-
-  it('지정된 이름을 반영한다', () => {
-    expect(
-      listAttendees([LOCAL_SPEAKER, REMOTE_SPEAKER], {
-        [LOCAL_SPEAKER]: '배철승',
-        [REMOTE_SPEAKER]: '김지훈',
-      }),
-    ).toEqual(['배철승', '김지훈'])
-  })
-})
-
-describe('diarizedSpeakerId', () => {
-  it('0-based 번호를 1-based 식별자로 바꾼다', () => {
-    expect(diarizedSpeakerId(0)).toBe('spk_1')
-    expect(diarizedSpeakerId(3)).toBe('spk_4')
-  })
-})

src/__tests__/transcript-formatter.test.ts

@@ -2,8 +2,6 @@ import { describe, it, expect } from 'vitest'
 import {
   formatTranscriptChunks,
   mergeAdjacentChunks,
-  mergeSpeakerChunks,
-  assignSpeakers,
   type TranscriptChunk,
 } from '@/lib/transcript-formatter'
 
@@ -57,141 +55,3 @@ describe('mergeAdjacentChunks', () => {
     expect(result).toEqual([])
   })
 })
-
-describe('화자 표기', () => {
-  it('speaker가 있으면 이름을 붙여 출력한다', () => {
-    const out = formatTranscriptChunks([
-      { text: '안녕하세요', startTime: 0, endTime: 2, isFinal: true, speaker: 'local' },
-      { text: '네 반갑습니다', startTime: 3, endTime: 5, isFinal: true, speaker: 'remote' },
-    ])
-    expect(out).toBe('[00:00] 나: 안녕하세요\n[00:03] 상대: 네 반갑습니다')
-  })
-
-  it('지정된 화자 이름을 사용한다', () => {
-    const out = formatTranscriptChunks(
-      [{ text: '안녕하세요', startTime: 0, endTime: 2, isFinal: true, speaker: 'remote' }],
-      { remote: '김지훈' },
-    )
-    expect(out).toBe('[00:00] 김지훈: 안녕하세요')
-  })
-
-  it('speaker가 없으면 기존 형식을 유지한다', () => {
-    const out = formatTranscriptChunks([
-      { text: '안녕하세요', startTime: 0, endTime: 2, isFinal: true },
-    ])
-    expect(out).toBe('[00:00] 안녕하세요')
-  })
-})
-
-describe('mergeSpeakerChunks', () => {
-  const local = [
-    { text: '먼저 말함', startTime: 1, endTime: 2, isFinal: true, speaker: 'local' },
-    { text: '나중에 말함', startTime: 9, endTime: 10, isFinal: true, speaker: 'local' },
-  ]
-  const remote = [
-    { text: '중간에 답함', startTime: 4, endTime: 6, isFinal: true, speaker: 'remote' },
-  ]
-
-  it('여러 트랙을 시간순으로 합친다', () => {
-    expect(mergeSpeakerChunks(local, remote).map((c) => c.text)).toEqual([
-      '먼저 말함',
-      '중간에 답함',
-      '나중에 말함',
-    ])
-  })
-
-  it('같은 시각이면 넘긴 순서를 유지한다', () => {
-    const a = [{ text: 'A', startTime: 5, endTime: 6, isFinal: true, speaker: 'local' }]
-    const b = [{ text: 'B', startTime: 5, endTime: 6, isFinal: true, speaker: 'remote' }]
-    expect(mergeSpeakerChunks(a, b).map((c) => c.text)).toEqual(['A', 'B'])
-  })
-
-  it('빈 트랙을 섞어도 동작한다', () => {
-    expect(mergeSpeakerChunks([], remote, [])).toEqual(remote)
-    expect(mergeSpeakerChunks()).toEqual([])
-  })
-})
-
-describe('mergeAdjacentChunks — 화자 경계', () => {
-  it('화자가 다르면 간격이 좁아도 합치지 않는다', () => {
-    const merged = mergeAdjacentChunks(
-      [
-        { text: '그건', startTime: 0, endTime: 1, isFinal: true, speaker: 'local' },
-        { text: '어렵습니다', startTime: 1, endTime: 2, isFinal: true, speaker: 'remote' },
-      ],
-      5,
-    )
-    expect(merged).toHaveLength(2)
-  })
-
-  it('같은 화자면 기존대로 합친다', () => {
-    const merged = mergeAdjacentChunks(
-      [
-        { text: '그건', startTime: 0, endTime: 1, isFinal: true, speaker: 'local' },
-        { text: '가능합니다', startTime: 1, endTime: 2, isFinal: true, speaker: 'local' },
-      ],
-      5,
-    )
-    expect(merged).toHaveLength(1)
-    expect(merged[0].text).toBe('그건 가능합니다')
-    expect(merged[0].speaker).toBe('local')
-  })
-})
-
-describe('assignSpeakers', () => {
-  const id = (n: number) => `spk_${n + 1}`
-
-  const chunks: TranscriptChunk[] = [
-    { text: '안녕하세요', startTime: 0, endTime: 3, isFinal: true },
-    { text: '네 반갑습니다', startTime: 5, endTime: 8, isFinal: true },
-    { text: '그럼 시작하죠', startTime: 10, endTime: 12, isFinal: true },
-  ]
-
-  it('시간이 가장 많이 겹치는 화자를 붙인다', () => {
-    const out = assignSpeakers(
-      chunks,
-      [
-        { start: 0, end: 4, speaker: 0 },
-        { start: 4.5, end: 9, speaker: 1 },
-        { start: 9.5, end: 13, speaker: 0 },
-      ],
-      id,
-    )
-    expect(out.map((c) => c.speaker)).toEqual(['spk_1', 'spk_2', 'spk_1'])
-  })
-
-  it('겹치는 구간이 없으면 화자를 비워 둔다', () => {
-    const out = assignSpeakers(
-      chunks,
-      [{ start: 100, end: 110, speaker: 0 }],
-      id,
-    )
-    expect(out.every((c) => c.speaker === undefined)).toBe(true)
-  })
-
-  it('부분적으로만 겹치면 더 많이 겹치는 쪽을 고른다', () => {
-    const out = assignSpeakers(
-      [{ text: '경계에 걸침', startTime: 0, endTime: 10, isFinal: true }],
-      [
-        { start: 0, end: 3, speaker: 0 },
-        { start: 3, end: 10, speaker: 1 },
-      ],
-      id,
-    )
-    expect(out[0].speaker).toBe('spk_2')
-  })
-
-  it('segments가 비면 원본을 그대로 돌려준다', () => {
-    const out = assignSpeakers(chunks, [], id)
-    expect(out).toEqual(chunks)
-  })
-
-  it('기존 화자 라벨은 새 결과로 덮어쓴다', () => {
-    const out = assignSpeakers(
-      [{ text: 'x', startTime: 0, endTime: 2, isFinal: true, speaker: 'spk_9' }],
-      [{ start: 0, end: 2, speaker: 0 }],
-      id,
-    )
-    expect(out[0].speaker).toBe('spk_1')
-  })
-})

src/__tests__/transcription.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect, vi } from 'vitest'
+import {
+  isGeminiSupportedAudioMimeType,
+  isWhisperSupportedMimeType,
+  parseTimestampedTranscript,
+  resolveSttModel,
+  transcribe,
+  GEMINI_INLINE_AUDIO_LIMIT,
+  DEFAULT_OPENAI_STT_MODEL,
+  DEFAULT_GEMINI_STT_MODEL,
+} from '@/lib/providers'
+import { resolveTranscriptionSettings } from '@/lib/api-keys'
+import {
+  formatTranscriptionSegments,
+  segmentsToChunks,
+} from '@/lib/transcript-formatter'
+import type { TranscriptionInput } from '@/lib/providers/types'
+
+function audio(overrides: Partial<TranscriptionInput> = {}): TranscriptionInput {
+  return {
+    bytes: new Uint8Array([1, 2, 3, 4]),
+    mimeType: 'audio/webm;codecs=opus',
+    fileName: 'meeting.webm',
+    language: 'ko',
+    ...overrides,
+  }
+}
+
+function okResponse(body: unknown) {
+  return { ok: true, status: 200, json: async () => body } as unknown as Response
+}
+
+/** 목의 호출 인자를 좁혀서 읽는다. vi.fn의 추론 타입은 fetch 오버로드와 안 맞는다. */
+function callArgs(
+  mock: { mock: { calls: unknown[][] } },
+  index = 0,
+): { url: string; init: RequestInit } {
+  const [url, init] = mock.mock.calls[index] as [string, RequestInit]
+  return { url, init }
+}
+
+function errResponse(status: number) {
+  return {
+    ok: false,
+    status,
+    json: async () => ({ error: 'nope' }),
+  } as unknown as Response
+}
+
+describe('mime 지원 판정', () => {
+  it('Whisper는 브라우저 녹음(webm)을 받는다', () => {
+    expect(isWhisperSupportedMimeType('audio/webm;codecs=opus')).toBe(true)
+    expect(isWhisperSupportedMimeType('audio/mpeg')).toBe(true)
+    expect(isWhisperSupportedMimeType('audio/x-aiff')).toBe(false)
+  })
+
+  it('Gemini는 webm을 받지 않는다', () => {
+    // 이게 true로 바뀌면 UI의 안내 문구도 같이 고쳐야 한다.
+    expect(isGeminiSupportedAudioMimeType('audio/webm')).toBe(false)
+    expect(isGeminiSupportedAudioMimeType('audio/mpeg')).toBe(true)
+    expect(isGeminiSupportedAudioMimeType('audio/flac')).toBe(true)
+  })
+})
+
+describe('transcribe — OpenAI 호환', () => {
+  const settings = {
+    provider: 'openai-compatible' as const,
+    apiKey: 'sk-test',
+    baseUrl: 'https://api.example.com/v1',
+  }
+
+  it('multipart로 보내고 verbose_json 구간을 파싱한다', async () => {
+    const fetchFn = vi.fn(async () =>
+      okResponse({
+        text: '안녕하세요 회의 시작합니다',
+        segments: [
+          { start: 0, end: 2.5, text: ' 안녕하세요' },
+          { start: 2.5, end: 5, text: ' 회의 시작합니다' },
+        ],
+      }),
+    )
+
+    const result = await transcribe(audio(), settings, { fetchFn })
+
+    expect(result.success).toBe(true)
+    if (!result.success) return
+
+    expect(result.text).toBe('안녕하세요 회의 시작합니다')
+    expect(result.segments).toEqual([
+      { start: 0, end: 2.5, text: '안녕하세요' },
+      { start: 2.5, end: 5, text: '회의 시작합니다' },
+    ])
+    expect(result.model).toBe(DEFAULT_OPENAI_STT_MODEL)
+
+    const { url, init } = callArgs(fetchFn)
+    expect(url).toBe('https://api.example.com/v1/audio/transcriptions')
+    expect(init.body).toBeInstanceOf(FormData)
+
+    const form = init.body as FormData
+    expect(form.get('model')).toBe(DEFAULT_OPENAI_STT_MODEL)
+    expect(form.get('response_format')).toBe('verbose_json')
+    expect(form.get('language')).toBe('ko')
+  })
+
+  it('어휘 힌트를 prompt로 보낸다', async () => {
+    const fetchFn = vi.fn(async () =>
+      okResponse({ text: '내용' }),
+    )
+
+    await transcribe(audio({ vocabularyHint: '김효천, PACS' }), settings, {
+      fetchFn,
+    })
+
+    const form = callArgs(fetchFn).init.body as FormData
+    expect(form.get('prompt')).toBe('김효천, PACS')
+  })
+
+  it('verbose_json 미지원(400)이면 json으로 한 번 더 시도한다', async () => {
+    const fetchFn = vi
+      .fn()
+      .mockResolvedValueOnce(errResponse(400))
+      .mockResolvedValueOnce(okResponse({ text: '타임스탬프 없는 결과' }))
+
+    const result = await transcribe(audio(), settings, { fetchFn })
+
+    expect(fetchFn).toHaveBeenCalledTimes(2)
+    expect(result.success).toBe(true)
+    if (!result.success) return
+    expect(result.segments).toEqual([])
+
+    const second = callArgs(fetchFn, 1).init.body as FormData
+    expect(second.get('response_format')).toBe('json')
+  })
+
+  it('429는 rateLimited로 표시한다', async () => {
+    const fetchFn = vi.fn(async () => errResponse(429))
+    const result = await transcribe(audio(), settings, { fetchFn })
+
+    expect(result.success).toBe(false)
+    if (result.success) return
+    expect(result.rateLimited).toBe(true)
+  })
+
+  it('빈 전사 결과를 성공으로 넘기지 않는다', async () => {
+    const fetchFn = vi.fn(async () => okResponse({ text: '   ' }))
+    const result = await transcribe(audio(), settings, { fetchFn })
+
+    expect(result.success).toBe(false)
+    if (result.success) return
+    expect(result.error).toContain('비어 있습니다')
+  })
+
+  it('base URL이 잘못되면 호출조차 하지 않는다', async () => {
+    const fetchFn = vi.fn()
+    const result = await transcribe(
+      audio(),
+      { ...settings, baseUrl: 'file:///etc/passwd' },
+      { fetchFn },
+    )
+
+    expect(fetchFn).not.toHaveBeenCalled()
+    expect(result.success).toBe(false)
+  })
+
+  it('망가진 구간은 버리고 정상 구간만 남긴다', async () => {
+    const fetchFn = vi.fn(async () =>
+      okResponse({
+        text: 'ok',
+        segments: [
+          { start: 0, end: 1, text: '정상' },
+          { start: 'x', end: 2, text: '시작이 숫자가 아님' },
+          { start: 3, end: 4, text: '   ' },
+          { start: 5, end: 6, text: '또 정상' },
+        ],
+      }),
+    )
+
+    const result = await transcribe(audio(), settings, { fetchFn })
+    expect(result.success).toBe(true)
+    if (!result.success) return
+    expect(result.segments.map((s) => s.text)).toEqual(['정상', '또 정상'])
+  })
+})
+
+describe('transcribe — Gemini', () => {
+  const settings = { provider: 'gemini' as const, apiKey: 'AIza-test' }
+
+  it('webm은 거부하고 대안을 안내한다', async () => {
+    const fetchFn = vi.fn()
+    const result = await transcribe(audio(), settings, { fetchFn })
+
+    expect(fetchFn).not.toHaveBeenCalled()
+    expect(result.success).toBe(false)
+    if (result.success) return
+    expect(result.error).toContain('OpenAI 호환')
+  })
+
+  it('지원 형식은 inline_data로 보낸다', async () => {
+    const fetchFn = vi.fn(async () =>
+      okResponse({
+        candidates: [{ content: { parts: [{ text: '[00:03] 안녕하세요' }] } }],
+      }),
+    )
+
+    const result = await transcribe(
+      audio({ mimeType: 'audio/mpeg', fileName: 'a.mp3' }),
+      settings,
+      { fetchFn },
+    )
+
+    expect(result.success).toBe(true)
+    if (!result.success) return
+    expect(result.segments).toEqual([{ start: 3, end: 4, text: '안녕하세요' }])
+
+    const body = JSON.parse(callArgs(fetchFn).init.body as string)
+    expect(body.contents[0].parts[1].inline_data.mime_type).toBe('audio/mpeg')
+    expect(body.contents[0].parts[1].inline_data.data).toBe(
+      Buffer.from([1, 2, 3, 4]).toString('base64'),
+    )
+  })
+
+  it('inline 상한을 넘으면 호출하지 않고 대안을 안내한다', async () => {
+    const fetchFn = vi.fn()
+    const result = await transcribe(
+      audio({
+        mimeType: 'audio/mpeg',
+        bytes: new Uint8Array(GEMINI_INLINE_AUDIO_LIMIT + 1),
+      }),
+      settings,
+      { fetchFn },
+    )
+
+    expect(fetchFn).not.toHaveBeenCalled()
+    expect(result.success).toBe(false)
+    if (result.success) return
+    expect(result.error).toContain('너무 큽니다')
+  })
+
+  it('키가 없으면 거부한다', async () => {
+    const fetchFn = vi.fn()
+    const result = await transcribe(
+      audio({ mimeType: 'audio/mpeg' }),
+      { provider: 'gemini', apiKey: '  ' },
+      { fetchFn },
+    )
+    expect(fetchFn).not.toHaveBeenCalled()
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('parseTimestampedTranscript', () => {
+  it('MM:SS와 HH:MM:SS를 모두 읽는다', () => {
+    const segments = parseTimestampedTranscript(
+      ['[00:03] 첫 발화', '[01:10] 두 번째', '[1:02:05] 한참 뒤'].join('\n'),
+    )
+
+    expect(segments.map((s) => s.start)).toEqual([3, 70, 3725])
+  })
+
+  it('다음 구간 시작을 이전 구간의 끝으로 잡는다', () => {
+    const segments = parseTimestampedTranscript('[00:00] 가\n[00:10] 나')
+    expect(segments[0]).toEqual({ start: 0, end: 10, text: '가' })
+    expect(segments[1].end).toBeGreaterThan(segments[1].start)
+  })
+
+  it('타임스탬프 없는 줄은 무시한다', () => {
+    expect(parseTimestampedTranscript('그냥 텍스트\n또 텍스트')).toEqual([])
+  })
+})
+
+describe('formatTranscriptionSegments', () => {
+  it('실제 오디오 타임라인으로 전사문을 만든다', () => {
+    const text = formatTranscriptionSegments([
+      { start: 3, text: '어떤 거죠' },
+      { start: 3725, text: '한참 뒤' },
+    ])
+
+    expect(text).toBe('[00:03] 어떤 거죠\n[01:02:05] 한참 뒤')
+  })
+
+  it('빈 구간은 넣지 않는다', () => {
+    // Web Speech 경로에서 빈 청크 19개가 요약 프롬프트를 오염시켰다.
+    expect(
+      formatTranscriptionSegments([
+        { start: 0, text: '  ' },
+        { start: 1, text: '내용' },
+      ]),
+    ).toBe('[00:01] 내용')
+  })
+})
+
+describe('segmentsToChunks', () => {
+  it('청크 구조로 옮기면서 시간을 보존한다', () => {
+    expect(
+      segmentsToChunks([{ start: 1.5, end: 4.25, text: ' 발화 ' }]),
+    ).toEqual([{ text: '발화', startTime: 1.5, endTime: 4.25, isFinal: true }])
+  })
+})
+
+describe('resolveTranscriptionSettings', () => {
+  it('대화 모델이 없어도 전사는 가능하다', () => {
+    // 요약용 resolveProviderSettings는 model이 비면 null을 준다.
+    const settings = resolveTranscriptionSettings({
+      provider: 'openai-compatible',
+      baseUrl: 'https://api.example.com/v1',
+      apiKey: 'sk-x',
+    })
+
+    expect(settings).not.toBeNull()
+    expect(resolveSttModel(settings!)).toBe(DEFAULT_OPENAI_STT_MODEL)
+  })
+
+  it('sttModel을 지정하면 그것을 쓴다', () => {
+    const settings = resolveTranscriptionSettings({
+      provider: 'openai-compatible',
+      baseUrl: 'https://api.example.com/v1',
+      sttModel: 'gpt-4o-transcribe',
+    })
+    expect(resolveSttModel(settings!)).toBe('gpt-4o-transcribe')
+  })
+
+  it('gemini 기본 STT 모델은 오디오를 받는 모델이다', () => {
+    const settings = resolveTranscriptionSettings({
+      provider: 'gemini',
+      apiKey: 'AIza-x',
+    })
+    expect(resolveSttModel(settings!)).toBe(DEFAULT_GEMINI_STT_MODEL)
+  })
+
+  it('base URL이 없으면 null', () => {
+    expect(
+      resolveTranscriptionSettings({ provider: 'openai-compatible' }),
+    ).toBeNull()
+  })
+})

src/__tests__/use-audio-recorder.test.ts

@@ -0,0 +1,239 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { useAudioRecorder } from '@/hooks/useAudioRecorder'
+
+/**
+ * jsdom에는 MediaRecorder도 getUserMedia도 없다. 훅이 다루는 것은
+ * "조각이 언제 오고 어디로 가는가"이므로 그 둘만 흉내 내면 충분하다.
+ */
+
+class FakeMediaRecorder {
+  static isTypeSupported = () => true
+
+  state: 'inactive' | 'recording' = 'inactive'
+  ondataavailable: ((event: { data: Blob }) => void) | null = null
+  onerror: (() => void) | null = null
+  private listeners: Record<string, Array<() => void>> = {}
+
+  constructor(
+    public stream: MediaStream,
+    public options?: MediaRecorderOptions,
+  ) {
+    instances.push(this)
+  }
+
+  start() {
+    this.state = 'recording'
+  }
+
+  stop() {
+    this.state = 'inactive'
+    // 실제 MediaRecorder는 stop() 시 남은 버퍼를 한 번 더 내보낸 뒤 stop을 쏜다.
+    for (const fn of this.listeners.stop ?? []) fn()
+  }
+
+  addEventListener(type: string, fn: () => void) {
+    ;(this.listeners[type] ??= []).push(fn)
+  }
+
+  emit(bytes: number) {
+    this.ondataavailable?.({ data: new Blob([new Uint8Array(bytes)]) })
+  }
+}
+
+let instances: FakeMediaRecorder[] = []
+let stopTracks: ReturnType<typeof vi.fn>
+let fetchMock: ReturnType<typeof vi.fn>
+
+function jsonResponse(body: unknown, ok = true, status = 200) {
+  return { ok, status, json: async () => body }
+}
+
+beforeEach(() => {
+  instances = []
+  stopTracks = vi.fn()
+
+  vi.stubGlobal('MediaRecorder', FakeMediaRecorder)
+  vi.stubGlobal('navigator', {
+    mediaDevices: {
+      getUserMedia: vi.fn(async () => ({
+        getTracks: () => [{ stop: stopTracks }],
+      })),
+    },
+  })
+
+  fetchMock = vi.fn(async (url: string) => {
+    if (url === '/api/recordings') {
+      return jsonResponse({ id: 'a'.repeat(32), mimeType: 'audio/webm' }, true, 201)
+    }
+    if (url.endsWith('/chunk')) return jsonResponse({ bytes: 1024 })
+    return jsonResponse({ bytes: 1024 })
+  })
+  vi.stubGlobal('fetch', fetchMock)
+})
+
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+async function startedHook() {
+  const view = renderHook(() => useAudioRecorder())
+  await waitFor(() => expect(view.result.current.isSupported).toBe(true))
+  await act(async () => {
+    await view.result.current.startRecording()
+  })
+  return view
+}
+
+describe('useAudioRecorder — 캡처 제약', () => {
+  it('원거리 화자를 지우는 전처리를 끄고 마이크를 연다', async () => {
+    await startedHook()
+
+    expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalledWith({
+      audio: expect.objectContaining({
+        noiseSuppression: false,
+        echoCancellation: false,
+        autoGainControl: true,
+      }),
+    })
+  })
+})
+
+describe('useAudioRecorder — 조각 업로드', () => {
+  it('조각이 생길 때마다 서버로 올린다', async () => {
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(2048)
+    })
+
+    await waitFor(() => {
+      const chunkCalls = fetchMock.mock.calls.filter((c) =>
+        String(c[0]).endsWith('/chunk'),
+      )
+      expect(chunkCalls).toHaveLength(1)
+    })
+
+    expect(view.result.current.localBytes).toBe(2048)
+  })
+
+  it('빈 조각은 올리지 않는다', async () => {
+    await startedHook()
+
+    await act(async () => {
+      instances[0].emit(0)
+    })
+
+    const chunkCalls = fetchMock.mock.calls.filter((c) =>
+      String(c[0]).endsWith('/chunk'),
+    )
+    expect(chunkCalls).toHaveLength(0)
+  })
+
+  it('업로드가 끝내 실패하면 뒤 조각을 이어 붙이지 않고 경고한다', async () => {
+    // 중간이 빈 파일은 짧은 파일보다 나쁘다 — 재생도 전사도 안 된다.
+    fetchMock.mockImplementation(async (url: string) => {
+      if (url === '/api/recordings') {
+        return jsonResponse({ id: 'a'.repeat(32) }, true, 201)
+      }
+      if (url.endsWith('/chunk')) return jsonResponse({ error: 'nope' }, false, 500)
+      return jsonResponse({})
+    })
+
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(1024)
+    })
+
+    // 500은 일시 장애일 수 있으므로 백오프를 두고 3회까지 재시도한다.
+    await waitFor(
+      () => {
+        expect(view.result.current.uploadWarning).toContain('서버 저장이 중단')
+      },
+      { timeout: 5_000 },
+    )
+
+    const callsAfterBreak = fetchMock.mock.calls.filter((c) =>
+      String(c[0]).endsWith('/chunk'),
+    ).length
+
+    await act(async () => {
+      instances[0].emit(1024)
+    })
+
+    expect(
+      fetchMock.mock.calls.filter((c) => String(c[0]).endsWith('/chunk')).length,
+    ).toBe(callsAfterBreak)
+  })
+
+  it('세션 생성이 실패해도 녹음은 계속된다', async () => {
+    fetchMock.mockImplementation(async (url: string) => {
+      if (url === '/api/recordings') {
+        return jsonResponse({ error: 'down' }, false, 500)
+      }
+      return jsonResponse({})
+    })
+
+    const view = await startedHook()
+
+    expect(view.result.current.isRecording).toBe(true)
+    expect(view.result.current.uploadWarning).toContain('내려받아')
+
+    await act(async () => {
+      instances[0].emit(4096)
+    })
+    expect(view.result.current.localBytes).toBe(4096)
+  })
+})
+
+describe('useAudioRecorder — 종료', () => {
+  it('오디오를 한 조각도 못 받았으면 보관됐다고 말하지 않는다', async () => {
+    const view = await startedHook()
+
+    await act(async () => {
+      await view.result.current.stopRecording()
+    })
+
+    expect(view.result.current.recording).toBeNull()
+    expect(view.result.current.error).toContain('한 조각도 캡처되지 않았습니다')
+    expect(view.result.current.isRecording).toBe(false)
+  })
+
+  it('받은 조각이 있으면 결과를 넘기고 마이크를 놓는다', async () => {
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(1024)
+    })
+    await act(async () => {
+      await view.result.current.stopRecording()
+    })
+
+    expect(view.result.current.recording?.blob.size).toBe(1024)
+    expect(view.result.current.recording?.recordingId).toBe('a'.repeat(32))
+    expect(stopTracks).toHaveBeenCalled()
+    expect(view.result.current.isRecording).toBe(false)
+  })
+
+  it('서버 사본이 로컬보다 짧으면 경고한다', async () => {
+    fetchMock.mockImplementation(async (url: string) => {
+      if (url === '/api/recordings') {
+        return jsonResponse({ id: 'a'.repeat(32) }, true, 201)
+      }
+      if (url.endsWith('/chunk')) return jsonResponse({ bytes: 10 })
+      return jsonResponse({ bytes: 10 })
+    })
+
+    const view = await startedHook()
+
+    await act(async () => {
+      instances[0].emit(4096)
+    })
+    await act(async () => {
+      await view.result.current.stopRecording()
+    })
+
+    expect(view.result.current.uploadWarning).toContain('서버 사본이 로컬보다 짧습니다')
+  })
+})

src/app/api/diarize/chunk/route.ts

@@ -1,30 +0,0 @@
-import { NextRequest } from 'next/server'
-import { appendAudio } from '@/lib/audio-session'
-
-export const dynamic = 'force-dynamic'
-
-/** 녹음 중 몇 초짜리 PCM 조각을 이어 붙인다. 본문은 16kHz 모노 Int16 raw PCM. */
-export async function POST(request: NextRequest) {
-  const sessionId = request.nextUrl.searchParams.get('session')?.trim()
-  if (!sessionId) {
-    return Response.json({ error: 'session 파라미터가 필요합니다.' }, { status: 400 })
-  }
-
-  const buffer = await request.arrayBuffer()
-  if (buffer.byteLength === 0) {
-    return Response.json({ error: '오디오가 비어 있습니다.' }, { status: 400 })
-  }
-  if (buffer.byteLength % 2 !== 0) {
-    return Response.json(
-      { error: 'Int16 PCM이 아닙니다 (홀수 바이트).' },
-      { status: 400 },
-    )
-  }
-
-  const result = appendAudio(sessionId, new Int16Array(buffer))
-  if (!result.ok) {
-    return Response.json({ error: result.error }, { status: 413 })
-  }
-
-  return Response.json({ seconds: Math.round(result.seconds) })
-}

src/app/api/diarize/route.ts

@@ -1,55 +0,0 @@
-import { NextRequest } from 'next/server'
-import { clearSession, collectSamples, sessionSeconds } from '@/lib/audio-session'
-import { diarize, modelsInstalled } from '@/lib/diarization'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET() {
-  return Response.json({ available: modelsInstalled() })
-}
-
-/**
- * 누적된 오디오 전체에 화자 분리를 돌린다.
- *
- * 창을 잘라 반복 실행하면 실행마다 화자 번호가 달라져 이어 붙일 수 없다.
- * 전역 클러스터링을 위해 녹음 종료 시 한 번만 돌린다.
- */
-export async function POST(request: NextRequest) {
-  try {
-    const body = await request.json().catch(() => ({}))
-    const sessionId = typeof body.session === 'string' ? body.session.trim() : ''
-
-    if (!sessionId) {
-      return Response.json({ error: 'session이 필요합니다.' }, { status: 400 })
-    }
-
-    const samples = collectSamples(sessionId)
-    if (!samples) {
-      return Response.json({ error: '누적된 오디오가 없습니다.' }, { status: 400 })
-    }
-
-    const numSpeakers =
-      typeof body.numSpeakers === 'number' && body.numSpeakers > 1
-        ? Math.floor(body.numSpeakers)
-        : undefined
-
-    const seconds = sessionSeconds(sessionId)
-    const result = await diarize(samples, { numSpeakers })
-
-    if (!result.success) {
-      const status = result.reason === 'models-missing' ? 503 : 500
-      return Response.json({ error: result.error, reason: result.reason }, { status })
-    }
-
-    clearSession(sessionId)
-
-    return Response.json({
-      segments: result.segments,
-      seconds: Math.round(seconds),
-      speakers: new Set(result.segments.map((s) => s.speaker)).size,
-    })
-  } catch (err) {
-    const message = err instanceof Error ? err.message : '알 수 없는 오류'
-    return Response.json({ error: `화자 분리 실패: ${message}` }, { status: 500 })
-  }
-}

src/app/api/meetings/route.ts

@@ -79,6 +79,9 @@ export async function POST(request: NextRequest) {
       customPrompt,
       attendees,
       tags,
+      audioFileName,
+      audioMimeType,
+      audioDuration,
     } = body
 
     if (!title || typeof title !== 'string' || title.trim().length === 0) {
@@ -112,6 +115,14 @@ export async function POST(request: NextRequest) {
         tags: Array.isArray(tags)
           ? tags.filter((t) => typeof t === 'string')
           : [],
+        audioFileName:
+          typeof audioFileName === 'string' ? audioFileName : null,
+        audioMimeType:
+          typeof audioMimeType === 'string' ? audioMimeType : null,
+        audioDuration:
+          typeof audioDuration === 'number' && Number.isFinite(audioDuration)
+            ? Math.max(0, Math.round(audioDuration))
+            : null,
         status: 'COMPLETED',
         actionItems: {
           create: parsed.map((item, index) => ({

src/app/api/recordings/[id]/chunk/route.ts

@@ -0,0 +1,55 @@
+import { NextRequest } from 'next/server'
+import { appendChunk } from '@/lib/recording-store'
+import { MAX_CHUNK_BYTES, isValidRecordingId } from '@/lib/recording'
+
+export const dynamic = 'force-dynamic'
+
+interface RouteContext {
+  params: Promise<{ id: string }>
+}
+
+/**
+ * 녹음 조각 하나를 이어 붙인다.
+ *
+ * 본문은 MediaRecorder가 준 바이트 그대로다. JSON이나 multipart로 감싸면
+ * base64 팽창이나 파싱 비용만 늘어난다.
+ */
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params
+
+    if (!isValidRecordingId(id)) {
+      return Response.json(
+        { error: '잘못된 녹음 세션 ID입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const buffer = Buffer.from(await request.arrayBuffer())
+
+    if (buffer.byteLength === 0) {
+      return Response.json({ error: '빈 조각입니다.' }, { status: 400 })
+    }
+
+    if (buffer.byteLength > MAX_CHUNK_BYTES) {
+      return Response.json(
+        { error: '조각이 너무 큽니다.' },
+        { status: 413 },
+      )
+    }
+
+    const result = await appendChunk(id, buffer)
+
+    if (!result.ok) {
+      return Response.json({ error: result.error }, { status: result.status })
+    }
+
+    return Response.json({ bytes: result.bytes })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json(
+      { error: `녹음 조각 저장 실패: ${message}` },
+      { status: 500 },
+    )
+  }
+}

src/app/api/recordings/[id]/route.ts

@@ -0,0 +1,86 @@
+import { NextRequest } from 'next/server'
+import { Readable } from 'stream'
+import { finalizeRecording, getRecordingStatus, openRecording } from '@/lib/recording-store'
+import { extensionForMimeType, isValidRecordingId } from '@/lib/recording'
+
+export const dynamic = 'force-dynamic'
+
+interface RouteContext {
+  params: Promise<{ id: string }>
+}
+
+/** 녹음 파일 내려받기. 헤더에는 사용자 입력을 넣지 않는다. */
+export async function GET(_request: NextRequest, context: RouteContext) {
+  const { id } = await context.params
+
+  if (!isValidRecordingId(id)) {
+    return Response.json({ error: '잘못된 녹음 세션 ID입니다.' }, { status: 400 })
+  }
+
+  const opened = await openRecording(id)
+  if (!opened) {
+    return Response.json({ error: '녹음을 찾을 수 없습니다.' }, { status: 404 })
+  }
+
+  const { meta, bytes, stream } = opened
+  const stamp = meta.startedAt.slice(0, 16).replace(/[-:]/g, '').replace('T', '-')
+  const fileName = `meeting-${stamp}.${extensionForMimeType(meta.mimeType)}`
+
+  return new Response(Readable.toWeb(stream as Readable) as ReadableStream, {
+    headers: {
+      'Content-Type': meta.mimeType,
+      'Content-Length': String(bytes),
+      'Content-Disposition': `attachment; filename="${fileName}"`,
+      'Cache-Control': 'no-store',
+    },
+  })
+}
+
+/** 녹음 종료. 길이를 확정하고 최종 상태를 돌려준다. */
+export async function POST(request: NextRequest, context: RouteContext) {
+  try {
+    const { id } = await context.params
+
+    if (!isValidRecordingId(id)) {
+      return Response.json(
+        { error: '잘못된 녹음 세션 ID입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const body = await request.json().catch(() => ({}))
+    const durationMs =
+      typeof body.durationMs === 'number' ? body.durationMs : null
+
+    const status = await finalizeRecording(id, durationMs)
+    if (!status) {
+      return Response.json(
+        { error: '녹음을 찾을 수 없습니다.' },
+        { status: 404 },
+      )
+    }
+
+    return Response.json(status)
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json(
+      { error: `녹음 종료 처리 실패: ${message}` },
+      { status: 500 },
+    )
+  }
+}
+
+/** 현재까지 저장된 크기 확인용. */
+export async function HEAD(_request: NextRequest, context: RouteContext) {
+  const { id } = await context.params
+
+  if (!isValidRecordingId(id)) return new Response(null, { status: 400 })
+
+  const status = await getRecordingStatus(id)
+  if (!status) return new Response(null, { status: 404 })
+
+  return new Response(null, {
+    status: 200,
+    headers: { 'Content-Length': String(status.bytes) },
+  })
+}

src/app/api/recordings/route.ts

@@ -0,0 +1,31 @@
+import { NextRequest } from 'next/server'
+import { createRecording } from '@/lib/recording-store'
+import { PREFERRED_MIME_TYPES } from '@/lib/recording'
+
+export const dynamic = 'force-dynamic'
+
+/** 브라우저가 고른 mimeType만 허용한다. 임의 문자열이 확장자로 새어들면 안 된다. */
+const ALLOWED_MIME_TYPES: readonly string[] = PREFERRED_MIME_TYPES
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}))
+    const { mimeType } = body
+
+    if (typeof mimeType !== 'string' || !ALLOWED_MIME_TYPES.includes(mimeType)) {
+      return Response.json(
+        { error: '지원하지 않는 오디오 형식입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const meta = await createRecording(mimeType)
+    return Response.json(meta, { status: 201 })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json(
+      { error: `녹음 세션 생성 실패: ${message}` },
+      { status: 500 },
+    )
+  }
+}

src/app/api/transcribe/route.ts

@@ -0,0 +1,117 @@
+import { NextRequest } from 'next/server'
+import { readFile } from 'fs/promises'
+import path from 'path'
+import { resolveTranscriptionSettings } from '@/lib/api-keys'
+import { resolveSttModel, transcribe } from '@/lib/providers'
+import { getRecording, RECORDINGS_DIR } from '@/lib/recording-store'
+import { isValidRecordingId } from '@/lib/recording'
+import { formatTranscriptionSegments } from '@/lib/transcript-formatter'
+
+export const dynamic = 'force-dynamic'
+
+/** 어휘 힌트는 Whisper가 약 224토큰까지만 본다. 넘겨도 버려지므로 잘라 보낸다. */
+const MAX_VOCABULARY_HINT_CHARS = 800
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json().catch(() => ({}))
+    const { recordingId, language, vocabularyHint } = body
+
+    if (!isValidRecordingId(recordingId)) {
+      return Response.json(
+        { error: '잘못된 녹음 세션 ID입니다.' },
+        { status: 400 },
+      )
+    }
+
+    const meta = await getRecording(recordingId)
+    if (!meta) {
+      return Response.json(
+        { error: '녹음을 찾을 수 없습니다.' },
+        { status: 404 },
+      )
+    }
+
+    const settings = resolveTranscriptionSettings(body)
+    if (!settings) {
+      return Response.json(
+        {
+          error:
+            'AI 프로바이더가 설정되지 않았습니다. /settings에서 먼저 설정해주세요.',
+        },
+        { status: 400 },
+      )
+    }
+
+    let bytes: Buffer
+    try {
+      bytes = await readFile(path.join(RECORDINGS_DIR, meta.fileName))
+    } catch {
+      return Response.json(
+        { error: '녹음 파일을 읽을 수 없습니다. 오디오가 저장되지 않았을 수 있습니다.' },
+        { status: 404 },
+      )
+    }
+
+    if (bytes.byteLength === 0) {
+      return Response.json(
+        { error: '녹음 파일이 비어 있습니다.' },
+        { status: 400 },
+      )
+    }
+
+    const result = await transcribe(
+      {
+        bytes,
+        mimeType: meta.mimeType,
+        fileName: meta.fileName,
+        language: typeof language === 'string' && language ? language : 'ko',
+        vocabularyHint:
+          typeof vocabularyHint === 'string' && vocabularyHint.trim().length > 0
+            ? vocabularyHint.trim().slice(0, MAX_VOCABULARY_HINT_CHARS)
+            : undefined,
+      },
+      settings,
+    )
+
+    if (!result.success) {
+      return Response.json(
+        { error: result.error },
+        { status: result.rateLimited ? 429 : 502 },
+      )
+    }
+
+    // 구간 타임스탬프가 있으면 `[MM:SS]` 형식으로 맞춘다. 없으면 원문 그대로.
+    const transcript =
+      result.segments.length > 0
+        ? formatTranscriptionSegments(result.segments)
+        : result.text
+
+    return Response.json({
+      transcript,
+      text: result.text,
+      segments: result.segments,
+      model: result.model,
+      hasTimestamps: result.segments.length > 0,
+      audioBytes: bytes.byteLength,
+    })
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return Response.json({ error: `전사 실패: ${message}` }, { status: 500 })
+  }
+}
+
+/** 이 프로바이더 설정으로 전사가 가능한지 미리 확인. */
+export async function GET(request: NextRequest) {
+  const url = new URL(request.url)
+  const settings = resolveTranscriptionSettings({
+    provider: url.searchParams.get('provider'),
+    baseUrl: url.searchParams.get('baseUrl'),
+    apiKey: url.searchParams.get('apiKey'),
+  })
+
+  return Response.json({
+    configured: settings !== null,
+    model: settings ? resolveSttModel(settings) : null,
+  })
+}

src/app/api/upload/route.ts

@@ -1,10 +1,20 @@
 import { NextRequest } from 'next/server'
 import { handleUpload } from '@/lib/upload-handler'
-import { writeFile, mkdir } from 'fs/promises'
+import {
-import path from 'path'
+  appendChunk,
+  createRecording,
+  finalizeRecording,
+} from '@/lib/recording-store'
 
-const UPLOAD_DIR = path.join(process.cwd(), 'uploads')
+export const dynamic = 'force-dynamic'
 
+/**
+ * 오디오 파일 업로드.
+ *
+ * 예전에는 `uploads/`에 파일만 떨궈 두고 아무것도 하지 않는 막다른 길이었다.
+ * 지금은 녹음 저장소에 그대로 넣어 `recordingId`를 돌려주므로, 브라우저 녹음과
+ * 똑같이 `/api/transcribe`로 전사할 수 있다. 두 경로가 한 파이프라인으로 만난다.
+ */
 export async function POST(request: NextRequest) {
   try {
     const formData = await request.formData()
@@ -15,19 +25,21 @@ export async function POST(request: NextRequest) {
     }
 
     const audioFile = formData.get('audio') as File
-    const buffer = Buffer.from(await audioFile.arrayBuffer())
+    const bytes = Buffer.from(await audioFile.arrayBuffer())
 
-    await mkdir(UPLOAD_DIR, { recursive: true })
+    const meta = await createRecording(result.data.mimeType)
+    const appended = await appendChunk(meta.id, bytes)
 
-    const timestamp = Date.now()
+    if (!appended.ok) {
-    const safeFileName = `${timestamp}_${result.data.fileName.replace(/[^a-zA-Z0-9._-]/g, '_')}`
+      return Response.json({ error: appended.error }, { status: appended.status })
-    const filePath = path.join(UPLOAD_DIR, safeFileName)
+    }
 
-    await writeFile(filePath, buffer)
+    await finalizeRecording(meta.id, null)
 
     return Response.json({
       ...result.data,
-      savedAs: safeFileName,
+      recordingId: meta.id,
+      savedAs: meta.fileName,
     })
   } catch (err) {
     const message = err instanceof Error ? err.message : '알 수 없는 오류'

src/app/page.tsx

@@ -1,9 +1,12 @@
 'use client'
 
-import { useMemo, useState } from 'react'
+import { useCallback, useMemo, useState } from 'react'
 import Link from 'next/link'
 import { AudioUploader } from '@/components/upload/AudioUploader'
 import { LiveRecorder } from '@/components/recorder/LiveRecorder'
+import type { CompletedRecording } from '@/hooks/useAudioRecorder'
+import { extensionForMimeType } from '@/lib/recording'
+import { useTranscription } from '@/hooks/useTranscription'
 import { MinutesViewer } from '@/components/minutes/MinutesViewer'
 import { getProviderRequestPayload } from '@/lib/api-key-storage'
 import {
@@ -43,6 +46,9 @@ export default function HomePage() {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState<string | null>(null)
   const [uploadedFile, setUploadedFile] = useState<File | null>(null)
+  const [audio, setAudio] = useState<CompletedRecording | null>(null)
+  const [uploadedRecordingId, setUploadedRecordingId] = useState<string | null>(null)
+  const [attendees, setAttendees] = useState('')
 
   const templateList = useMemo(
     () => [
@@ -77,6 +83,7 @@ export default function HomePage() {
 
   async function handleUpload(file: File) {
     setUploadedFile(file)
+    setUploadedRecordingId(null)
     setError(null)
 
     const formData = new FormData()
@@ -93,6 +100,7 @@ export default function HomePage() {
       }
 
       if (!title) setTitle(data.title)
+      setUploadedRecordingId(data.recordingId ?? null)
     } catch {
       setError('파일 업로드에 실패했습니다.')
     }
@@ -146,6 +154,37 @@ export default function HomePage() {
     generateMinutes(text, summaryMode)
   }
 
+  const handleRecordingReady = useCallback((recording: CompletedRecording) => {
+    setAudio(recording)
+  }, [])
+
+  const {
+    isTranscribing: isTranscribingUpload,
+    error: uploadTranscribeError,
+    result: uploadTranscription,
+    transcribeRecording: transcribeUpload,
+  } = useTranscription()
+
+  async function transcribeUploadedFile() {
+    if (!uploadedRecordingId) return
+    const outcome = await transcribeUpload(uploadedRecordingId, {
+      vocabularyHint: attendees,
+    })
+    if (outcome?.transcript) {
+      setTranscript(outcome.transcript)
+      generateMinutes(outcome.transcript, summaryMode)
+    }
+  }
+
+  // 회의록과 함께 저장할 오디오 정보. 서버 사본이 없으면 붙일 게 없다.
+  const audioMeta = audio?.recordingId
+    ? {
+        audioFileName: `${audio.recordingId}.${extensionForMimeType(audio.mimeType)}`,
+        audioMimeType: audio.mimeType,
+        audioDuration: Math.round(audio.durationMs / 1000),
+      }
+    : undefined
+
   const liveSummaryActive =
     summaryMode === 'gemini' && activeTemplateMeta.live && tab === 'record'
 
@@ -188,6 +227,22 @@ export default function HomePage() {
           />
         </section>
 
+        <section className="mb-8">
+          <label className="block text-sm font-medium text-neutral-600 mb-2">
+            참석자 · 용어 <span className="font-normal text-neutral-400">(선택)</span>
+          </label>
+          <input
+            type="text"
+            value={attendees}
+            onChange={(e) => setAttendees(e.target.value)}
+            placeholder="예: 김효천, 이지안, 계명대동산병원, PACS"
+            className="w-full rounded-xl border border-neutral-300 px-4 py-3 text-sm text-neutral-800 placeholder:text-neutral-400 focus:border-blue-400 focus:outline-none focus:ring-2 focus:ring-blue-100 transition-all"
+          />
+          <p className="mt-1.5 text-xs text-neutral-500">
+            이름·제품명·사내 용어를 적어두면 전사가 고유명사를 훨씬 정확히 잡습니다.
+          </p>
+        </section>
+
         <section className="mb-8 space-y-5">
           <div className="flex items-center gap-4">
             <label className="text-sm font-medium text-neutral-600 min-w-20">
@@ -328,6 +383,10 @@ export default function HomePage() {
           {tab === 'record' ? (
             <LiveRecorder
               onTranscriptReady={handleTranscriptReady}
+              onRecordingReady={handleRecordingReady}
+              onTranscriptReplaced={setTranscript}
+              title={title}
+              vocabularyHint={attendees}
               liveSummaryEnabled={liveSummaryActive}
               template={template}
               depth={depth}
@@ -352,12 +411,39 @@ export default function HomePage() {
           </section>
         )}
 
-        {uploadedFile && !transcript && (
+        {uploadedFile && (
-          <section className="mb-8">
+          <section className="mb-8 space-y-3">
             <div className="rounded-xl border border-blue-200 bg-blue-50 p-4 text-sm text-blue-700">
-              <strong>{uploadedFile.name}</strong> 업로드 완료.
+              <strong>{uploadedFile.name}</strong> 업로드 완료
-              실시간 녹음 탭에서 음성 인식을 시작하거나, 텍스트를 직접 입력해주세요.
+              {uploadedRecordingId
+                ? ' — 아래 버튼으로 전사를 시작하세요.'
+                : ' — 서버 저장에 실패해 전사할 수 없습니다.'}
             </div>
+
+            {uploadedRecordingId && (
+              <button
+                onClick={transcribeUploadedFile}
+                disabled={isTranscribingUpload}
+                className="w-full rounded-xl bg-neutral-900 px-6 py-3 text-sm font-medium text-white hover:bg-neutral-800 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+              >
+                {isTranscribingUpload
+                  ? '전사 중… 회의 길이에 따라 몇 분 걸릴 수 있습니다'
+                  : '🔤 전사 시작'}
+              </button>
+            )}
+
+            {uploadTranscribeError && (
+              <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
+                <strong>전사 오류:</strong> {uploadTranscribeError}
+              </div>
+            )}
+
+            {uploadTranscription && (
+              <div className="rounded-xl border border-blue-200 bg-blue-50 p-4 text-sm text-blue-800">
+                🔤 전사 완료 — {uploadTranscription.model} 모델,{' '}
+                {uploadTranscription.segments.length}개 구간
+              </div>
+            )}
           </section>
         )}
 
@@ -391,6 +477,7 @@ export default function HomePage() {
             depth={depth}
             customPrompt={template === 'custom' ? customPrompt : undefined}
             summaryMode={summaryMode}
+            audio={audioMeta}
           />
         )}
       </div>

src/app/settings/page.tsx

@@ -27,6 +27,7 @@ export default function SettingsPage() {
   const [apiKey, setApiKey] = useState('')
   const [baseUrl, setBaseUrl] = useState('')
   const [model, setModel] = useState('')
+  const [sttModel, setSttModel] = useState('')
   const [showKey, setShowKey] = useState(false)
   const [savedKey, setSavedKey] = useState<string | null>(null)
   const [envConfigured, setEnvConfigured] = useState<boolean | null>(null)
@@ -44,12 +45,15 @@ export default function SettingsPage() {
       setApiKey(stored.apiKey)
       setBaseUrl(stored.baseUrl)
       setModel(stored.model)
+      setSttModel(stored.sttModel ?? '')
       setSavedKey(stored.apiKey || null)
     } else {
       // 프로바이더 설정 이전에 저장해둔 Gemini 키를 그대로 이어받는다.
       const legacyKey = getStoredApiKey()
       setApiKey(legacyKey ?? '')
-      setModel(findPreset(DEFAULT_PRESET_ID).defaultModel)
+      const initial = findPreset(DEFAULT_PRESET_ID)
+      setModel(initial.defaultModel)
+      setSttModel(initial.defaultSttModel)
       setSavedKey(legacyKey)
     }
 
@@ -66,6 +70,7 @@ export default function SettingsPage() {
     setPresetId(next.id)
     setBaseUrl(next.baseUrl)
     setModel(next.defaultModel)
+    setSttModel(next.defaultSttModel)
     // 프로바이더가 바뀌면 이전 키는 무의미할 뿐 아니라, 그대로 두면
     // 다른 회사 엔드포인트로 전송될 수 있으므로 비운다.
     setApiKey('')
@@ -78,6 +83,7 @@ export default function SettingsPage() {
       apiKey: apiKey.trim(),
       baseUrl: baseUrl.trim(),
       model: model.trim(),
+      sttModel: sttModel.trim(),
     })
     setSavedKey(apiKey.trim() || null)
     setSavedToast(true)
@@ -99,6 +105,7 @@ export default function SettingsPage() {
     setApiKey('')
     setBaseUrl(fallback.baseUrl)
     setModel(fallback.defaultModel)
+    setSttModel(fallback.defaultSttModel)
     setSavedKey(null)
     setTestState({ status: 'idle' })
   }
@@ -286,6 +293,29 @@ export default function SettingsPage() {
             )}
           </div>
 
+          <div className="mt-5">
+            <label className="mb-2 block text-sm text-neutral-600">
+              음성 전사(STT) 모델
+            </label>
+            <input
+              type="text"
+              value={sttModel}
+              onChange={(e) => setSttModel(e.target.value)}
+              placeholder={preset.defaultSttModel || 'whisper-1'}
+              className="w-full rounded-xl border border-neutral-300 px-4 py-3 font-mono text-sm focus:border-purple-400 focus:outline-none focus:ring-2 focus:ring-purple-100 transition-all"
+            />
+            <p className="mt-1 text-xs text-neutral-500">
+              녹음 오디오를 텍스트로 옮길 때 쓰는 모델입니다. 요약 모델과 별개입니다.
+            </p>
+            {!preset.canTranscribeWebm && (
+              <p className="mt-2 rounded-lg bg-amber-50 px-3 py-2 text-xs text-amber-800">
+                ⚠️ 이 프로바이더는 브라우저 녹음 형식(webm)을 받지 않습니다. 실시간
+                녹음을 전사하려면 OpenAI 호환 프로바이더(OrcaRouter · OpenAI ·
+                로컬 whisper)를 선택하세요. 업로드한 mp3·wav·flac 파일은 전사됩니다.
+              </p>
+            )}
+          </div>
+
           <div className="mt-5">
             <label className="mb-2 block text-sm text-neutral-600">
               {preset.apiKeyLabel}

src/components/minutes/MinutesViewer.tsx

@@ -22,6 +22,12 @@ interface MinutesViewerProps {
   depth?: SummaryDepth
   customPrompt?: string
   summaryMode?: 'simple' | 'gemini'
+  /** 이 회의록의 원본 오디오. 서버에 보관된 녹음이 있을 때만 붙는다. */
+  audio?: {
+    audioFileName: string
+    audioMimeType: string
+    audioDuration: number
+  }
 }
 
 type SaveState =
@@ -38,6 +44,7 @@ export function MinutesViewer({
   template,
   depth,
   customPrompt,
+  audio,
   summaryMode,
 }: MinutesViewerProps) {
   const [renderedView, setRenderedView] = useState<'rendered' | 'raw'>(
@@ -110,6 +117,7 @@ export function MinutesViewer({
           template,
           depth,
           customPrompt,
+          ...audio,
         }),
       })
       const data = await res.json()

src/components/recorder/LiveRecorder.tsx

@@ -1,28 +1,22 @@
 'use client'
 
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useEffect, useRef } from 'react'
 import { useSpeechRecognition } from '@/hooks/useSpeechRecognition'
-import { useDualStreamCapture } from '@/hooks/useDualStreamCapture'
-import { useDiarization } from '@/hooks/useDiarization'
 import { useLiveSummary } from '@/hooks/useLiveSummary'
-import {
+import { useAudioRecorder, type CompletedRecording } from '@/hooks/useAudioRecorder'
-  assignSpeakers,
+import { formatTranscriptChunks } from '@/lib/transcript-formatter'
-  formatTranscriptChunks,
+import { useTranscription } from '@/hooks/useTranscription'
-  mergeSpeakerChunks,
+import { formatBytes, formatDuration } from '@/lib/recording'
-  type TimeSpan,
-} from '@/lib/transcript-formatter'
-import {
-  LOCAL_SPEAKER,
-  REMOTE_SPEAKER,
-  diarizedSpeakerId,
-  resolveSpeakerName,
-} from '@/lib/speakers'
 import type { SummaryDepth, TemplateId } from '@/lib/templates'
 
-type SeparationMode = 'off' | 'remote' | 'in-person'
-
 interface LiveRecorderProps {
   onTranscriptReady: (transcript: string) => void
+  onRecordingReady?: (recording: CompletedRecording) => void
+  /** STT 재전사 결과로 전사문을 갈아끼운다. */
+  onTranscriptReplaced?: (transcript: string) => void
+  title: string
+  /** 참석자 등 고유명사 힌트. STT 정확도를 올린다. */
+  vocabularyHint?: string
   liveSummaryEnabled: boolean
   template: TemplateId
   depth: SummaryDepth
@@ -31,68 +25,48 @@ interface LiveRecorderProps {
 
 export function LiveRecorder({
   onTranscriptReady,
+  onRecordingReady,
+  onTranscriptReplaced,
+  title,
+  vocabularyHint,
   liveSummaryEnabled,
   template,
   depth,
   customPrompt,
 }: LiveRecorderProps) {
-  const [mode, setMode] = useState<SeparationMode>('off')
-  const [attendeeCount, setAttendeeCount] = useState(2)
-  const [pendingStart, setPendingStart] = useState(false)
-  const [speakerNames, setSpeakerNames] = useState<Record<string, string>>({})
-  const [segments, setSegments] = useState<TimeSpan[] | null>(null)
-  const timeOriginRef = useRef(0)
-
-  const capture = useDualStreamCapture()
-  const diarization = useDiarization()
-
-  const speakerSeparation = mode !== 'off'
-
-  // 화자 분리를 켜면 트랙마다 인식기를 붙인다. 트랙이 곧 화자가 되므로
-  // 추론 없이 화자가 갈린다.
-  // 두 트랙을 실제로 확보했을 때만 화자를 라벨링한다.
-  // 마이크만 잡힌 상태에서 라벨을 붙이면 상대 발언이 내 것으로 기록된다.
-  const isSeparating = capture.mode === 'dual-stream'
-
-  const local = useSpeechRecognition({
-    audioTrack: speakerSeparation ? capture.micTrack : null,
-    speaker: isSeparating ? LOCAL_SPEAKER : undefined,
-    timeOrigin: timeOriginRef.current || undefined,
-  })
-
-  const remote = useSpeechRecognition({
-    audioTrack: capture.systemTrack,
-    speaker: REMOTE_SPEAKER,
-    timeOrigin: timeOriginRef.current || undefined,
-  })
-
   const {
     isListening,
     isSupported,
+    chunks,
     interimText,
     error: recognitionError,
     startListening,
-  } = local
+    stopListening,
+    resetChunks,
+  } = useSpeechRecognition()
 
-  const chunks = useMemo(() => {
+  const {
-    if (isSeparating) return mergeSpeakerChunks(local.chunks, remote.chunks)
+    isRecording,
-    if (segments) return assignSpeakers(local.chunks, segments, diarizedSpeakerId)
+    isSupported: isRecordingSupported,
-    return local.chunks
+    error: recordingError,
-  }, [isSeparating, segments, local.chunks, remote.chunks])
+    uploadWarning,
+    elapsedMs,
+    localBytes,
+    uploadedBytes,
+    recording,
+    startRecording,
+    stopRecording,
+    downloadRecording,
+    reset: resetRecording,
+  } = useAudioRecorder()
 
-  // 캡처가 끝나 트랙이 준비되면 그때 인식기를 시작한다.
+  const {
-  useEffect(() => {
+    isTranscribing,
-    if (!pendingStart) return
+    error: transcriptionError,
-    if (capture.mode === 'idle') return
+    result: transcription,
-
+    transcribeRecording,
-    setPendingStart(false)
+    reset: resetTranscription,
-    local.startListening()
+  } = useTranscription()
-    if (capture.systemTrack) remote.startListening()
-    if (mode === 'in-person' && capture.micTrack) {
-      diarization.start(capture.micTrack)
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [pendingStart, capture.mode, capture.systemTrack, capture.micTrack])
 
   const {
     summary,
@@ -121,6 +95,11 @@ export function LiveRecorder({
     summaryEndRef.current?.scrollIntoView({ behavior: 'smooth', block: 'end' })
   }, [summary])
 
+  // 녹음이 끝나 파일이 확정되면 상위로 올려 회의록과 함께 저장되게 한다.
+  useEffect(() => {
+    if (recording) onRecordingReady?.(recording)
+  }, [recording, onRecordingReady])
+
   if (isSupported === null) {
     return (
       <div className="rounded-2xl border border-neutral-200 bg-neutral-50 p-6 text-center text-sm text-neutral-400">
@@ -141,45 +120,22 @@ export function LiveRecorder({
   }
 
   async function handleStart() {
-    timeOriginRef.current = Date.now()
+    resetRecording()
-    setSegments(null)
+    resetTranscription()
-
+    // 오디오 녹음을 먼저 건다. 전사가 실패하더라도 원본은 남아야 한다.
-    if (mode === 'off') {
+    await startRecording()
-      startListening()
+    startListening()
-      return
-    }
-
-    setPendingStart(true)
-    await capture.start({ withSystemAudio: mode === 'remote' })
   }
 
   async function handleStop() {
-    local.stopListening()
+    stopListening()
-    remote.stopListening()
 
-    // 대면 모드는 녹음이 끝난 뒤 전체 오디오에 한 번 화자 분리를 돌린다.
+    const transcript = formatTranscriptChunks(chunks)
-    let finalChunks = chunks
-    if (mode === 'in-person') {
-      const result = await diarization.finish(attendeeCount)
-      if (result.length > 0) {
-        setSegments(result)
-        finalChunks = assignSpeakers(local.chunks, result, diarizedSpeakerId)
-      }
-    }
-
-    capture.stop()
-
-    const transcript = formatTranscriptChunks(finalChunks, speakerNames)
     if (transcript.length > 0) {
       onTranscriptReady(transcript)
     }
-  }
 
-  function handleReset() {
+    await stopRecording()
-    local.resetChunks()
-    remote.resetChunks()
-    diarization.reset()
-    setSegments(null)
   }
 
   const lastUpdatedLabel = lastUpdatedAt
@@ -240,9 +196,37 @@ export function LiveRecorder({
           </button>
         )}
 
+        {recording?.recordingId && !isListening && (
+          <button
+            onClick={async () => {
+              const outcome = await transcribeRecording(recording.recordingId!, {
+                vocabularyHint,
+              })
+              if (outcome?.transcript) onTranscriptReplaced?.(outcome.transcript)
+            }}
+            disabled={isTranscribing}
+            className="flex items-center gap-2 rounded-full bg-neutral-900 px-5 py-2.5 text-sm font-medium text-white hover:bg-neutral-800 disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+          >
+            {isTranscribing ? '전사 중… (몇 분 걸릴 수 있습니다)' : '🔤 원본 오디오로 다시 전사'}
+          </button>
+        )}
+
+        {recording && !isListening && (
+          <button
+            onClick={() => downloadRecording(title)}
+            className="flex items-center gap-2 rounded-full border border-emerald-300 bg-emerald-50 px-4 py-2 text-sm font-medium text-emerald-700 hover:bg-emerald-100 transition-colors"
+          >
+            ⬇️ 오디오 내려받기 ({formatBytes(recording.blob.size)})
+          </button>
+        )}
+
         {chunks.length > 0 && !isListening && (
           <button
-            onClick={handleReset}
+            onClick={() => {
+              resetChunks()
+              resetRecording()
+              resetTranscription()
+            }}
             className="rounded-full border border-neutral-300 px-4 py-2 text-sm text-neutral-600 hover:bg-neutral-50 transition-colors"
           >
             초기화
@@ -256,145 +240,35 @@ export function LiveRecorder({
           </div>
         )}
 
-        {isListening && capture.mode === 'dual-stream' && (
+        {isRecording && (
-          <div className="flex items-center gap-1.5 rounded-full bg-purple-50 px-4 py-1.5 text-xs text-purple-700">
+          <div className="flex items-center gap-2 rounded-full bg-neutral-100 px-4 py-1.5 text-xs text-neutral-600">
-            <span className="h-2 w-2 rounded-full bg-purple-500" />
+            <span className="text-sm">🎧</span>
-            화자 분리 중
+            오디오 {formatDuration(elapsedMs)} · 저장 {formatBytes(uploadedBytes)}
+            {localBytes > 0 && uploadedBytes < localBytes && (
+              <span className="text-amber-600">
+                (전송 대기 {formatBytes(localBytes - uploadedBytes)})
+              </span>
+            )}
           </div>
         )}
       </div>
 
-      {!isListening && chunks.length === 0 && (
+      {isRecordingSupported === false && (
-        <div className="rounded-xl border border-neutral-200 bg-white p-4">
-          <p className="mb-3 text-sm font-medium text-neutral-800">화자 분리</p>
-
-          <div className="flex flex-wrap gap-2">
-            {(
-              [
-                { id: 'off', label: '사용 안 함' },
-                { id: 'remote', label: '원격 회의' },
-                { id: 'in-person', label: '대면 회의' },
-              ] as const
-            ).map((option) => (
-              <button
-                key={option.id}
-                onClick={() => setMode(option.id)}
-                disabled={option.id === 'in-person' && diarization.available === false}
-                className={`rounded-lg border px-3 py-2 text-sm font-medium transition-all disabled:opacity-40 ${
-                  mode === option.id
-                    ? 'border-purple-400 bg-purple-50 text-purple-700'
-                    : 'border-neutral-200 bg-white text-neutral-600 hover:border-neutral-300'
-                }`}
-              >
-                {option.label}
-              </button>
-            ))}
-          </div>
-
-          {mode === 'remote' && (
-            <>
-              <p className="mt-3 text-xs text-neutral-500">
-                내 마이크와 상대 목소리를 별도 트랙으로 받아 구분합니다. 추론이 없어
-                정확합니다. 시작 시{' '}
-                <strong>화면 공유 대화상자에서 &ldquo;탭 오디오 공유&rdquo;를 반드시 켜주세요.</strong>
-              </p>
-              <p className="mt-1.5 text-xs text-amber-700">
-                노트북 한 대를 두고 마주 앉은 대면 회의에서는 동작하지 않습니다.
-                그 경우 &ldquo;대면 회의&rdquo;를 선택하세요.
-              </p>
-              <div className="mt-4 grid gap-3 sm:grid-cols-2">
-                {(
-                  [
-                    { id: LOCAL_SPEAKER, label: '내 이름', placeholder: '나' },
-                    { id: REMOTE_SPEAKER, label: '상대 이름', placeholder: '상대' },
-                  ] as const
-                ).map((field) => (
-                  <label key={field.id} className="block">
-                    <span className="mb-1 block text-xs text-neutral-500">
-                      {field.label}
-                    </span>
-                    <input
-                      type="text"
-                      value={speakerNames[field.id] ?? ''}
-                      onChange={(e) =>
-                        setSpeakerNames((prev) => ({
-                          ...prev,
-                          [field.id]: e.target.value,
-                        }))
-                      }
-                      placeholder={field.placeholder}
-                      className="w-full rounded-lg border border-neutral-300 px-3 py-2 text-sm focus:border-purple-400 focus:outline-none"
-                    />
-                  </label>
-                ))}
-              </div>
-            </>
-          )}
-
-          {mode === 'in-person' && (
-            <>
-              <p className="mt-3 text-xs text-neutral-500">
-                마이크 하나에 섞여 들어온 목소리를 내 PC에서 분석해 화자를 나눕니다.
-                외부로 오디오를 보내지 않습니다.{' '}
-                <strong>녹음이 끝난 뒤 한 번에 분석</strong>하므로 실시간 화자 표시는 없습니다.
-              </p>
-              <label className="mt-4 block max-w-40">
-                <span className="mb-1 block text-xs text-neutral-500">참석자 수</span>
-                <input
-                  type="number"
-                  min={2}
-                  max={8}
-                  value={attendeeCount}
-                  onChange={(e) =>
-                    setAttendeeCount(Math.max(2, Math.min(8, Number(e.target.value) || 2)))
-                  }
-                  className="w-full rounded-lg border border-neutral-300 px-3 py-2 text-sm focus:border-purple-400 focus:outline-none"
-                />
-                <span className="mt-1 block text-xs text-neutral-500">
-                  정확한 수를 넣을수록 결과가 좋아집니다. 자동 추정은 화자 수를 잘못 세는
-                  경우가 많습니다.
-                </span>
-              </label>
-            </>
-          )}
-
-          {diarization.available === false && (
-            <p className="mt-3 text-xs text-amber-700">
-              대면 회의 화자 분리를 쓰려면 모델이 필요합니다 —{' '}
-              <code className="rounded bg-amber-50 px-1">npm run setup:diarization</code>{' '}
-              을 실행한 뒤 서버를 다시 시작하세요.
-            </p>
-          )}
-        </div>
-      )}
-
-      {diarization.status.state === 'analyzing' && (
-        <div className="rounded-xl border border-purple-200 bg-purple-50 p-4 text-sm text-purple-700">
-          화자를 분석하는 중입니다... 회의가 길수록 시간이 걸립니다.
-        </div>
-      )}
-
-      {diarization.status.state === 'done' && (
-        <div className="rounded-xl border border-green-200 bg-green-50 p-4 text-sm text-green-700">
-          화자 {diarization.status.speakers}명을 구분했습니다.
-        </div>
-      )}
-
-      {diarization.status.state === 'error' && (
-        <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
-          <strong>화자 분리 오류:</strong> {diarization.status.message}
-        </div>
-      )}
-
-      {capture.error && (
-        <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
-          <strong>오디오 캡처 오류:</strong> {capture.error}
-        </div>
-      )}
-
-      {capture.warning && (
         <div className="rounded-xl border border-amber-200 bg-amber-50 p-4 text-sm text-amber-800">
-          ⚠️ {capture.warning}
+          이 브라우저는 오디오 녹음을 지원하지 않습니다. 전사만 진행되며,
+          <strong> 놓친 발화를 나중에 복구할 수 없습니다.</strong> Chrome을 사용해주세요.
+        </div>
+      )}
+
+      {recordingError && (
+        <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
+          <strong>오디오 녹음 오류:</strong> {recordingError}
+        </div>
+      )}
+
+      {uploadWarning && (
+        <div className="rounded-xl border border-amber-200 bg-amber-50 p-4 text-sm text-amber-800">
+          <strong>⚠️ 서버 저장 문제:</strong> {uploadWarning}
         </div>
       )}
 
@@ -404,6 +278,39 @@ export function LiveRecorder({
         </div>
       )}
 
+      {transcriptionError && (
+        <div className="rounded-xl border border-red-200 bg-red-50 p-4 text-sm text-red-700">
+          <strong>전사 오류:</strong> {transcriptionError}
+        </div>
+      )}
+
+      {transcription && (
+        <div className="rounded-xl border border-blue-200 bg-blue-50 p-4 text-sm text-blue-800">
+          <strong>🔤 재전사 완료</strong> — {transcription.model} 모델,{' '}
+          {transcription.segments.length > 0
+            ? `${transcription.segments.length}개 구간 (실제 오디오 타임스탬프)`
+            : '타임스탬프 없음'}
+          . 아래 텍스트가 교체되었습니다.
+        </div>
+      )}
+
+      {recording && !isListening && (
+        <div className="rounded-xl border border-emerald-200 bg-emerald-50 p-4 text-sm text-emerald-800">
+          <strong>
+            🎧 오디오 {formatDuration(recording.durationMs)} ·{' '}
+            {formatBytes(recording.blob.size)} 확보
+          </strong>
+          {' — '}
+          {recording.recordingId
+            ? `서버에 ${formatBytes(recording.uploadedBytes)} 저장됨.`
+            : '서버 저장 실패 — 브라우저 사본만 있습니다.'}{' '}
+          전사가 놓친 발화는 이 오디오로 다시 살릴 수 있습니다.
+          {!recording.recordingId && (
+            <strong> 지금 내려받아 보관해주세요.</strong>
+          )}
+        </div>
+      )}
+
       {isListening && !hasTranscript && (
         <div className="rounded-2xl border border-dashed border-blue-300 bg-blue-50/50 p-6 text-center">
           <p className="text-sm text-blue-700">
@@ -441,20 +348,7 @@ export function LiveRecorder({
               {hasTranscript ? (
                 <div className="space-y-1 text-sm font-mono leading-relaxed text-neutral-700">
                   {chunks.map((chunk, i) => (
-                    <p key={i}>
+                    <p key={i}>{chunk.text}</p>
-                      {chunk.speaker && (
-                        <span
-                          className={`mr-1.5 font-semibold ${
-                            chunk.speaker === LOCAL_SPEAKER
-                              ? 'text-purple-600'
-                              : 'text-teal-600'
-                          }`}
-                        >
-                          {resolveSpeakerName(chunk.speaker, speakerNames)}:
-                        </span>
-                      )}
-                      {chunk.text}
-                    </p>
                   ))}
                   {interimText && (
                     <p className="text-neutral-400 italic">

src/hooks/useAudioRecorder.ts

@@ -0,0 +1,390 @@
+'use client'
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  AUDIO_BITS_PER_SECOND,
+  CHUNK_INTERVAL_MS,
+  RECORDING_AUDIO_CONSTRAINTS,
+  pickRecorderMimeType,
+  recordingDownloadName,
+} from '@/lib/recording'
+
+export interface CompletedRecording {
+  /** 서버 세션 id. 세션 생성에 실패했으면 null이고 로컬 사본만 있다. */
+  recordingId: string | null
+  mimeType: string
+  blob: Blob
+  durationMs: number
+  startedAt: Date
+  /** 서버에 실제로 저장된 바이트. 0이거나 blob보다 작으면 일부가 못 올라갔다. */
+  uploadedBytes: number
+}
+
+export interface AudioRecorderHook {
+  isRecording: boolean
+  isSupported: boolean | null
+  /** 녹음을 시작조차 못하게 만든 오류. */
+  error: string | null
+  /** 녹음은 되고 있으나 서버 사본에 문제가 있을 때의 경고. */
+  uploadWarning: string | null
+  elapsedMs: number
+  localBytes: number
+  uploadedBytes: number
+  recording: CompletedRecording | null
+  startRecording: () => Promise<void>
+  stopRecording: () => Promise<void>
+  downloadRecording: (title: string) => void
+  reset: () => void
+}
+
+const MAX_CHUNK_RETRIES = 3
+
+function describeCaptureError(err: unknown): string {
+  const name = err instanceof Error ? err.name : ''
+
+  switch (name) {
+    case 'NotAllowedError':
+    case 'SecurityError':
+      return '마이크 권한이 거부되어 녹음할 수 없습니다. 주소창 왼쪽 자물쇠 아이콘에서 마이크를 허용해주세요.'
+    case 'NotFoundError':
+      return '마이크를 찾을 수 없습니다. 장치가 연결되어 있는지 확인해주세요.'
+    case 'NotReadableError':
+      return '다른 프로그램이 마이크를 사용 중입니다. 해당 프로그램을 종료하고 다시 시도해주세요.'
+    default:
+      return err instanceof Error
+        ? `마이크를 열 수 없습니다: ${err.message}`
+        : '마이크를 열 수 없습니다.'
+  }
+}
+
+/**
+ * 회의 오디오를 파일로 남긴다.
+ *
+ * 전사와 독립적으로 동작한다. Web Speech가 발화를 놓치든 네트워크가 끊기든
+ * 오디오만은 남아야 나중에 서버 STT로 다시 살릴 수 있다. 그래서 서버 업로드가
+ * 실패해도 녹음을 중단하지 않고, 브라우저 안의 사본을 끝까지 들고 간다.
+ */
+export function useAudioRecorder(): AudioRecorderHook {
+  const [isSupported, setIsSupported] = useState<boolean | null>(null)
+  const [isRecording, setIsRecording] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [uploadWarning, setUploadWarning] = useState<string | null>(null)
+  const [elapsedMs, setElapsedMs] = useState(0)
+  const [localBytes, setLocalBytes] = useState(0)
+  const [uploadedBytes, setUploadedBytes] = useState(0)
+  const [recording, setRecording] = useState<CompletedRecording | null>(null)
+
+  const recorderRef = useRef<MediaRecorder | null>(null)
+  const streamRef = useRef<MediaStream | null>(null)
+  const partsRef = useRef<Blob[]>([])
+  const sessionIdRef = useRef<string | null>(null)
+  const mimeTypeRef = useRef<string | null>(null)
+  const startedAtRef = useRef<Date | null>(null)
+  const uploadChainRef = useRef<Promise<void>>(Promise.resolve())
+  const uploadBrokenRef = useRef(false)
+
+  useEffect(() => {
+    setIsSupported(
+      typeof window !== 'undefined' &&
+        typeof window.MediaRecorder !== 'undefined' &&
+        typeof navigator !== 'undefined' &&
+        !!navigator.mediaDevices?.getUserMedia,
+    )
+  }, [])
+
+  // 녹음 중에는 1초마다 경과 시간을 갱신한다. 이 시각이 나중에 전사 청크를
+  // 오디오 타임라인에 맞추는 기준이 된다.
+  useEffect(() => {
+    if (!isRecording) return
+
+    const timer = setInterval(() => {
+      if (startedAtRef.current) {
+        setElapsedMs(Date.now() - startedAtRef.current.getTime())
+      }
+    }, 1000)
+
+    return () => clearInterval(timer)
+  }, [isRecording])
+
+  // 녹음 중 탭을 닫으면 아직 못 올린 조각이 사라진다. 확인을 한 번 받는다.
+  useEffect(() => {
+    if (!isRecording) return
+
+    function warn(event: BeforeUnloadEvent) {
+      event.preventDefault()
+    }
+
+    window.addEventListener('beforeunload', warn)
+    return () => window.removeEventListener('beforeunload', warn)
+  }, [isRecording])
+
+  /**
+   * 조각을 순서대로 올린다.
+   *
+   * 순서가 곧 파일의 순서이므로 병렬로 보내지 않는다. 한 조각이 끝내 실패하면
+   * 그 뒤를 이어 붙여봐야 중간이 비어 재생도 전사도 안 되는 파일이 되므로,
+   * 그 시점에 업로드를 멈추고 로컬 사본을 쓰라고 알린다.
+   */
+  const queueUpload = useCallback((chunk: Blob) => {
+    const id = sessionIdRef.current
+    if (!id || uploadBrokenRef.current) return
+
+    uploadChainRef.current = uploadChainRef.current.then(async () => {
+      if (uploadBrokenRef.current) return
+
+      for (let attempt = 1; attempt <= MAX_CHUNK_RETRIES; attempt++) {
+        try {
+          const res = await fetch(`/api/recordings/${id}/chunk`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/octet-stream' },
+            body: chunk,
+          })
+
+          if (res.ok) {
+            const data = await res.json()
+            setUploadedBytes(data.bytes)
+            return
+          }
+
+          // 4xx는 재시도해도 같은 답이 온다.
+          if (res.status >= 400 && res.status < 500) break
+        } catch {
+          // 네트워크 오류 — 아래에서 재시도한다.
+        }
+
+        if (attempt < MAX_CHUNK_RETRIES) {
+          await new Promise((resolve) => setTimeout(resolve, 500 * attempt))
+        }
+      }
+
+      uploadBrokenRef.current = true
+      setUploadWarning(
+        '서버 저장이 중단되었습니다. 녹음은 계속되고 있으니 종료 후 반드시 오디오를 내려받아 주세요.',
+      )
+    })
+  }, [])
+
+  const startRecording = useCallback(async () => {
+    if (recorderRef.current) return
+
+    setError(null)
+    setUploadWarning(null)
+    setRecording(null)
+    setElapsedMs(0)
+    setLocalBytes(0)
+    setUploadedBytes(0)
+    partsRef.current = []
+    sessionIdRef.current = null
+    uploadBrokenRef.current = false
+    uploadChainRef.current = Promise.resolve()
+
+    if (isSupported !== true) {
+      setError('이 브라우저는 오디오 녹음을 지원하지 않습니다. Chrome을 사용해주세요.')
+      return
+    }
+
+    const mimeType = pickRecorderMimeType((type) =>
+      MediaRecorder.isTypeSupported(type),
+    )
+    if (!mimeType) {
+      setError('브라우저가 지원하는 녹음 형식을 찾지 못했습니다.')
+      return
+    }
+
+    let stream: MediaStream
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({
+        audio: RECORDING_AUDIO_CONSTRAINTS,
+      })
+    } catch (err) {
+      setError(describeCaptureError(err))
+      return
+    }
+
+    // 서버 세션은 있으면 좋고 없어도 녹음은 간다. 여기서 포기하면
+    // 오디오를 남기려던 목적 자체를 잃는다.
+    try {
+      const res = await fetch('/api/recordings', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ mimeType }),
+      })
+
+      if (res.ok) {
+        const meta = await res.json()
+        sessionIdRef.current = meta.id
+      } else {
+        uploadBrokenRef.current = true
+        setUploadWarning(
+          '서버에 녹음 세션을 만들지 못했습니다. 브라우저에만 저장되니 종료 후 반드시 내려받아 주세요.',
+        )
+      }
+    } catch {
+      uploadBrokenRef.current = true
+      setUploadWarning(
+        '서버에 연결하지 못했습니다. 브라우저에만 저장되니 종료 후 반드시 내려받아 주세요.',
+      )
+    }
+
+    const recorder = new MediaRecorder(stream, {
+      mimeType,
+      audioBitsPerSecond: AUDIO_BITS_PER_SECOND,
+    })
+
+    recorder.ondataavailable = (event) => {
+      if (event.data.size === 0) return
+      partsRef.current.push(event.data)
+      setLocalBytes((prev) => prev + event.data.size)
+      queueUpload(event.data)
+    }
+
+    recorder.onerror = () => {
+      setError('녹음 중 오류가 발생했습니다. 지금까지의 오디오는 보존되어 있습니다.')
+    }
+
+    streamRef.current = stream
+    recorderRef.current = recorder
+    mimeTypeRef.current = mimeType
+    startedAtRef.current = new Date()
+
+    recorder.start(CHUNK_INTERVAL_MS)
+    setIsRecording(true)
+  }, [isSupported, queueUpload])
+
+  const stopRecording = useCallback(async () => {
+    const recorder = recorderRef.current
+    if (!recorder) return
+    recorderRef.current = null
+
+    // stop()은 남은 버퍼를 dataavailable로 한 번 더 내보낸 뒤 stop을 쏜다.
+    // 그 마지막 조각까지 받아야 회의 끝부분이 잘리지 않는다.
+    if (recorder.state !== 'inactive') {
+      await new Promise<void>((resolve) => {
+        recorder.addEventListener('stop', () => resolve(), { once: true })
+        recorder.stop()
+      })
+    }
+
+    streamRef.current?.getTracks().forEach((track) => track.stop())
+    streamRef.current = null
+
+    await uploadChainRef.current
+
+    const startedAt = startedAtRef.current ?? new Date()
+    const durationMs = Date.now() - startedAt.getTime()
+    const mimeType = mimeTypeRef.current ?? 'audio/webm'
+    const id = sessionIdRef.current
+
+    const blob = new Blob(partsRef.current, { type: mimeType })
+
+    // 한 바이트도 못 받았으면 보관됐다고 말하면 안 된다. 이 기능의 요점은
+    // 오디오가 남는 것인데, 남지 않았는데 남았다고 알리면 사용자는 회의가
+    // 끝난 뒤에야 아무것도 없다는 걸 알게 된다.
+    if (blob.size === 0) {
+      setError(
+        '오디오가 한 조각도 캡처되지 않았습니다. 마이크 입력 장치를 확인하고 다시 녹음해주세요.',
+      )
+      setElapsedMs(durationMs)
+      setIsRecording(false)
+      return
+    }
+
+    let serverBytes = 0
+    if (id && !uploadBrokenRef.current) {
+      try {
+        const res = await fetch(`/api/recordings/${id}`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ durationMs }),
+        })
+        if (res.ok) {
+          serverBytes = (await res.json()).bytes ?? 0
+        }
+      } catch {
+        setUploadWarning(
+          '녹음 종료 처리에 실패했습니다. 저장된 조각은 남아 있지만, 로컬 사본도 내려받아 두시길 권합니다.',
+        )
+      }
+    }
+
+    // 서버 사본이 로컬보다 짧으면 조각이 새어나간 것이다. 조용히 넘기지 않는다.
+    if (id && !uploadBrokenRef.current && serverBytes < blob.size) {
+      setUploadWarning(
+        `서버 사본이 로컬보다 짧습니다 (${serverBytes} / ${blob.size} bytes). 오디오를 내려받아 보관해주세요.`,
+      )
+    }
+
+    setElapsedMs(durationMs)
+    setUploadedBytes(serverBytes)
+    setRecording({
+      recordingId: uploadBrokenRef.current ? null : id,
+      mimeType,
+      blob,
+      durationMs,
+      startedAt,
+      uploadedBytes: serverBytes,
+    })
+    setIsRecording(false)
+  }, [])
+
+  const downloadRecording = useCallback((title: string) => {
+    const parts = partsRef.current
+    if (parts.length === 0) return
+
+    const mimeType = mimeTypeRef.current ?? 'audio/webm'
+    const blob = new Blob(parts, { type: mimeType })
+    const url = URL.createObjectURL(blob)
+
+    const anchor = document.createElement('a')
+    anchor.href = url
+    anchor.download = recordingDownloadName(
+      title,
+      startedAtRef.current ?? new Date(),
+      mimeType,
+    )
+    document.body.appendChild(anchor)
+    anchor.click()
+    anchor.remove()
+
+    setTimeout(() => URL.revokeObjectURL(url), 1_000)
+  }, [])
+
+  const reset = useCallback(() => {
+    partsRef.current = []
+    sessionIdRef.current = null
+    startedAtRef.current = null
+    uploadBrokenRef.current = false
+    setRecording(null)
+    setElapsedMs(0)
+    setLocalBytes(0)
+    setUploadedBytes(0)
+    setError(null)
+    setUploadWarning(null)
+  }, [])
+
+  // 언마운트 시 마이크를 놓아준다. 탭 표시등이 켜진 채 남지 않도록.
+  useEffect(() => {
+    return () => {
+      const recorder = recorderRef.current
+      if (recorder && recorder.state !== 'inactive') {
+        recorder.stop()
+      }
+      streamRef.current?.getTracks().forEach((track) => track.stop())
+    }
+  }, [])
+
+  return {
+    isRecording,
+    isSupported,
+    error,
+    uploadWarning,
+    elapsedMs,
+    localBytes,
+    uploadedBytes,
+    recording,
+    startRecording,
+    stopRecording,
+    downloadRecording,
+    reset,
+  }
+}

src/hooks/useDiarization.ts

@@ -1,169 +0,0 @@
-'use client'
-
-import { useCallback, useEffect, useRef, useState } from 'react'
-import type { TimeSpan } from '@/lib/transcript-formatter'
-
-export type DiarizationStatus =
-  | { state: 'idle' }
-  | { state: 'unavailable'; message: string }
-  | { state: 'recording'; seconds: number }
-  | { state: 'analyzing' }
-  | { state: 'done'; speakers: number; segments: TimeSpan[] }
-  | { state: 'error'; message: string }
-
-interface UseDiarizationResult {
-  /** 모델 설치 여부. null이면 확인 중. */
-  available: boolean | null
-  status: DiarizationStatus
-  /** 오디오 수집 시작. 마이크 트랙을 넘긴다. */
-  start: (track: MediaStreamTrack) => Promise<void>
-  /** 수집을 멈추고 전체 오디오에 화자 분리를 돌린다. */
-  finish: (numSpeakers?: number) => Promise<TimeSpan[]>
-  reset: () => void
-}
-
-function newSessionId(): string {
-  return `s_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`
-}
-
-/**
- * 대면 회의용 화자 분리.
- *
- * 녹음 중에는 4초짜리 PCM 조각을 서버에 쌓아두기만 하고, 녹음이 끝나면
- * 전체 오디오에 한 번 분리를 돌린다. 창을 잘라 반복 실행하면 실행마다
- * 화자 번호가 달라져 이어 붙일 수 없기 때문이다.
- */
-export function useDiarization(): UseDiarizationResult {
-  const [available, setAvailable] = useState<boolean | null>(null)
-  const [status, setStatus] = useState<DiarizationStatus>({ state: 'idle' })
-
-  const sessionRef = useRef<string>('')
-  const contextRef = useRef<AudioContext | null>(null)
-  const nodeRef = useRef<AudioWorkletNode | null>(null)
-  const secondsRef = useRef(0)
-
-  useEffect(() => {
-    let cancelled = false
-    fetch('/api/diarize')
-      .then((r) => r.json())
-      .then((d) => {
-        if (!cancelled) setAvailable(!!d.available)
-      })
-      .catch(() => {
-        if (!cancelled) setAvailable(false)
-      })
-    return () => {
-      cancelled = true
-    }
-  }, [])
-
-  const teardown = useCallback(() => {
-    nodeRef.current?.port.close()
-    nodeRef.current?.disconnect()
-    nodeRef.current = null
-    contextRef.current?.close().catch(() => {})
-    contextRef.current = null
-  }, [])
-
-  const start = useCallback(
-    async (track: MediaStreamTrack) => {
-      sessionRef.current = newSessionId()
-      secondsRef.current = 0
-
-      try {
-        // 16kHz로 열면 브라우저가 리샘플링해준다 — 모델이 받는 샘플레이트.
-        const context = new AudioContext({ sampleRate: 16_000 })
-        contextRef.current = context
-
-        await context.audioWorklet.addModule('/pcm-worklet.js')
-
-        const source = context.createMediaStreamSource(new MediaStream([track]))
-        const node = new AudioWorkletNode(context, 'pcm-collector')
-        nodeRef.current = node
-
-        node.port.onmessage = (event) => {
-          const pcm = event.data as Int16Array
-          secondsRef.current += pcm.length / 16_000
-          setStatus({
-            state: 'recording',
-            seconds: Math.round(secondsRef.current),
-          })
-
-          // 실패해도 녹음을 막지 않는다. 그 구간만 화자 분리에서 빠진다.
-          fetch(`/api/diarize/chunk?session=${sessionRef.current}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/octet-stream' },
-            // 워크릿이 매번 새 버퍼를 transfer 하므로 buffer 전체가 곧 이 조각이다.
-            body: pcm.buffer as ArrayBuffer,
-          }).catch(() => {})
-        }
-
-        source.connect(node)
-        setStatus({ state: 'recording', seconds: 0 })
-      } catch (err) {
-        teardown()
-        setStatus({
-          state: 'error',
-          message:
-            err instanceof Error
-              ? `오디오 수집 실패: ${err.message}`
-              : '오디오 수집에 실패했습니다.',
-        })
-      }
-    },
-    [teardown],
-  )
-
-  const finish = useCallback(
-    async (numSpeakers?: number): Promise<TimeSpan[]> => {
-      teardown()
-
-      if (!sessionRef.current || secondsRef.current < 1) {
-        setStatus({ state: 'idle' })
-        return []
-      }
-
-      setStatus({ state: 'analyzing' })
-
-      try {
-        const res = await fetch('/api/diarize', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ session: sessionRef.current, numSpeakers }),
-        })
-        const data = await res.json()
-
-        if (!res.ok) {
-          setStatus({
-            state: 'error',
-            message: data.error ?? '화자 분리에 실패했습니다.',
-          })
-          return []
-        }
-
-        const segments: TimeSpan[] = data.segments ?? []
-        setStatus({ state: 'done', speakers: data.speakers ?? 0, segments })
-        return segments
-      } catch (err) {
-        setStatus({
-          state: 'error',
-          message:
-            err instanceof Error ? err.message : '화자 분리 요청에 실패했습니다.',
-        })
-        return []
-      }
-    },
-    [teardown],
-  )
-
-  const reset = useCallback(() => {
-    teardown()
-    sessionRef.current = ''
-    secondsRef.current = 0
-    setStatus({ state: 'idle' })
-  }, [teardown])
-
-  useEffect(() => teardown, [teardown])
-
-  return { available, status, start, finish, reset }
-}

src/hooks/useDualStreamCapture.ts

@@ -1,121 +0,0 @@
-'use client'
-
-import { useCallback, useEffect, useRef, useState } from 'react'
-
-export type CaptureMode = 'idle' | 'mic-only' | 'dual-stream'
-
-interface DualStreamCapture {
-  mode: CaptureMode
-  /** 내 목소리 트랙 (마이크) */
-  micTrack: MediaStreamTrack | null
-  /** 상대 목소리 트랙 (시스템·탭 오디오). 화면 공유를 거부하거나 오디오를 안 켜면 null */
-  systemTrack: MediaStreamTrack | null
-  error: string | null
-  /** 시스템 오디오 없이 마이크만 잡힌 경우의 안내 */
-  warning: string | null
-  start: (options?: { withSystemAudio?: boolean }) => Promise<void>
-  stop: () => void
-}
-
-function describeCaptureError(err: unknown): string {
-  if (!(err instanceof Error)) return '오디오 캡처에 실패했습니다.'
-
-  switch (err.name) {
-    case 'NotAllowedError':
-      return '오디오 캡처 권한이 거부되었습니다. 마이크와 화면 공유를 모두 허용해주세요.'
-    case 'NotFoundError':
-      return '사용할 수 있는 마이크를 찾을 수 없습니다.'
-    case 'NotReadableError':
-      return '다른 앱이 마이크를 사용 중입니다. 해당 앱을 종료하고 다시 시도해주세요.'
-    default:
-      return `오디오 캡처 실패: ${err.message}`
-  }
-}
-
-/**
- * 화자 분리를 위한 2트랙 캡처.
- *
- * 내 마이크와 시스템(탭) 오디오를 **별도 트랙으로** 잡는다. 트랙이 곧 화자이므로
- * 추론 없이 정확도 100%로 화자가 갈린다. 원격 1:1 회의를 겨냥한 경로다.
- *
- * 시스템 오디오는 Chrome/Windows와 Chrome 141+/macOS 14.2+ 에서만 캡처된다.
- * 실패하면 마이크 단독 모드로 떨어지며, 그 경우 화자 분리는 되지 않는다.
- */
-export function useDualStreamCapture(): DualStreamCapture {
-  const [mode, setMode] = useState<CaptureMode>('idle')
-  const [micTrack, setMicTrack] = useState<MediaStreamTrack | null>(null)
-  const [systemTrack, setSystemTrack] = useState<MediaStreamTrack | null>(null)
-  const [error, setError] = useState<string | null>(null)
-  const [warning, setWarning] = useState<string | null>(null)
-
-  const streamsRef = useRef<MediaStream[]>([])
-
-  const stop = useCallback(() => {
-    for (const stream of streamsRef.current) {
-      for (const track of stream.getTracks()) track.stop()
-    }
-    streamsRef.current = []
-    setMicTrack(null)
-    setSystemTrack(null)
-    setMode('idle')
-  }, [])
-
-  const start = useCallback(
-    async (options?: { withSystemAudio?: boolean }) => {
-      const withSystemAudio = options?.withSystemAudio ?? true
-
-      setError(null)
-      setWarning(null)
-
-      let micStream: MediaStream
-      try {
-        micStream = await navigator.mediaDevices.getUserMedia({ audio: true })
-      } catch (err) {
-        setError(describeCaptureError(err))
-        return
-      }
-      streamsRef.current.push(micStream)
-      const mic = micStream.getAudioTracks()[0] ?? null
-      setMicTrack(mic)
-
-      if (!withSystemAudio) {
-        setMode('mic-only')
-        return
-      }
-
-      try {
-        // 오디오만 필요해도 video:true를 함께 요청해야 한다 (스펙 요구사항).
-        const displayStream = await navigator.mediaDevices.getDisplayMedia({
-          video: true,
-          audio: true,
-        })
-        streamsRef.current.push(displayStream)
-
-        // 영상은 쓰지 않으므로 즉시 끊어 자원과 프라이버시 노출을 줄인다.
-        for (const track of displayStream.getVideoTracks()) track.stop()
-
-        const system = displayStream.getAudioTracks()[0] ?? null
-        if (!system) {
-          setWarning(
-            '시스템 오디오가 공유되지 않아 화자 분리가 비활성화됩니다. 공유 대화상자에서 "탭 오디오 공유"를 켜주세요.',
-          )
-          setMode('mic-only')
-          return
-        }
-
-        setSystemTrack(system)
-        setMode('dual-stream')
-      } catch (err) {
-        setWarning(
-          `${describeCaptureError(err)} 마이크만으로 계속 녹음합니다 (화자 분리 없음).`,
-        )
-        setMode('mic-only')
-      }
-    },
-    [],
-  )
-
-  useEffect(() => stop, [stop])
-
-  return { mode, micTrack, systemTrack, error, warning, start, stop }
-}

src/hooks/useSpeechRecognition.ts

@@ -3,22 +3,6 @@
 import { useState, useRef, useCallback, useEffect } from 'react'
 import type { TranscriptChunk } from '@/lib/transcript-formatter'
 
-export interface UseSpeechRecognitionOptions {
-  /**
-   * 전사할 오디오 트랙. 지정하면 기본 마이크 대신 이 트랙을 인식한다.
-   * 트랙마다 인식기를 붙이면 화자가 트랙으로 확정된다.
-   */
-  audioTrack?: MediaStreamTrack | null
-  /** 이 인식기가 만든 청크에 붙일 화자 식별자. */
-  speaker?: string
-  /**
-   * 타임스탬프 기준 시각(ms). 여러 인식기를 병합하려면 같은 값을 넘겨야
-   * 한 시간축 위에 놓인다. 생략하면 startListening 호출 시각을 쓴다.
-   */
-  timeOrigin?: number
-  lang?: string
-}
-
 interface SpeechRecognitionHook {
   isListening: boolean
   isSupported: boolean | null
@@ -46,10 +30,7 @@ function describeError(code: string): string {
   }
 }
 
-export function useSpeechRecognition(
+export function useSpeechRecognition(): SpeechRecognitionHook {
-  options: UseSpeechRecognitionOptions = {},
-): SpeechRecognitionHook {
-  const { audioTrack, speaker, timeOrigin, lang = 'ko-KR' } = options
   const [isListening, setIsListening] = useState(false)
   const [chunks, setChunks] = useState<TranscriptChunk[]>([])
   const [interimText, setInterimText] = useState('')
@@ -59,12 +40,6 @@ export function useSpeechRecognition(
   const startTimeRef = useRef<number>(0)
   const networkRetryRef = useRef<number>(0)
 
-  // start()/onend 콜백이 항상 최신 값을 보도록 ref로 들고 있는다.
-  const configRef = useRef({ audioTrack, speaker, timeOrigin, lang })
-  useEffect(() => {
-    configRef.current = { audioTrack, speaker, timeOrigin, lang }
-  }, [audioTrack, speaker, timeOrigin, lang])
-
   const MAX_NETWORK_RETRIES = 8
 
   useEffect(() => {
@@ -84,15 +59,12 @@ export function useSpeechRecognition(
     const SpeechRecognitionAPI =
       window.SpeechRecognition || window.webkitSpeechRecognition
 
-    const { audioTrack: track, speaker: speakerId, timeOrigin: origin, lang: language } =
-      configRef.current
-
     const recognition = new SpeechRecognitionAPI()
-    recognition.lang = language
+    recognition.lang = 'ko-KR'
     recognition.continuous = true
     recognition.interimResults = true
 
-    startTimeRef.current = origin ?? Date.now()
+    startTimeRef.current = Date.now()
     networkRetryRef.current = 0
     setError(null)
 
@@ -116,7 +88,6 @@ export function useSpeechRecognition(
               startTime: Math.max(0, now - 2),
               endTime: now,
               isFinal: true,
-              ...(speakerId ? { speaker: speakerId } : {}),
             },
           ])
           setInterimText('')
@@ -132,14 +103,8 @@ export function useSpeechRecognition(
       const delay = networkRetryRef.current > 0 ? 1500 : 0
       setTimeout(() => {
         if (recognitionRef.current !== recognition) return
-        // 트랙이 끝났으면(화면 공유 중단 등) 재시작하지 않는다.
-        if (track && track.readyState !== 'live') {
-          setIsListening(false)
-          recognitionRef.current = null
-          return
-        }
         try {
-          recognition.start(track ?? undefined)
+          recognition.start()
         } catch {
           setIsListening(false)
           recognitionRef.current = null
@@ -176,7 +141,7 @@ export function useSpeechRecognition(
 
     recognitionRef.current = recognition
     try {
-      recognition.start(track ?? undefined)
+      recognition.start()
       setIsListening(true)
     } catch (err) {
       setError(

src/hooks/useTranscription.ts

@@ -0,0 +1,86 @@
+'use client'
+
+import { useCallback, useState } from 'react'
+import { getProviderRequestPayload } from '@/lib/api-key-storage'
+import type { TranscriptionSegment } from '@/lib/providers/types'
+
+export interface TranscriptionOutcome {
+  transcript: string
+  segments: TranscriptionSegment[]
+  model: string
+  hasTimestamps: boolean
+}
+
+export interface TranscriptionHook {
+  isTranscribing: boolean
+  error: string | null
+  result: TranscriptionOutcome | null
+  transcribeRecording: (
+    recordingId: string,
+    options?: { vocabularyHint?: string },
+  ) => Promise<TranscriptionOutcome | null>
+  reset: () => void
+}
+
+/**
+ * 보관된 녹음을 서버 STT로 전사한다.
+ *
+ * Web Speech 결과를 덮어쓰는 것이 목적이다. 실시간 텍스트는 회의 중 흐름을
+ * 보기 위한 초안이고, 확정본은 원본 오디오에서 다시 뽑는다.
+ */
+export function useTranscription(): TranscriptionHook {
+  const [isTranscribing, setIsTranscribing] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [result, setResult] = useState<TranscriptionOutcome | null>(null)
+
+  const transcribeRecording = useCallback(
+    async (recordingId: string, options: { vocabularyHint?: string } = {}) => {
+      setIsTranscribing(true)
+      setError(null)
+
+      try {
+        const res = await fetch('/api/transcribe', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({
+            recordingId,
+            language: 'ko',
+            vocabularyHint: options.vocabularyHint,
+            ...getProviderRequestPayload(),
+          }),
+        })
+
+        const data = await res.json().catch(() => ({}))
+
+        if (!res.ok) {
+          setError(data.error ?? '전사에 실패했습니다.')
+          return null
+        }
+
+        const outcome: TranscriptionOutcome = {
+          transcript: data.transcript ?? '',
+          segments: Array.isArray(data.segments) ? data.segments : [],
+          model: data.model ?? '',
+          hasTimestamps: Boolean(data.hasTimestamps),
+        }
+        setResult(outcome)
+        return outcome
+      } catch (err) {
+        setError(
+          err instanceof Error ? `전사 요청 실패: ${err.message}` : '전사 요청 실패',
+        )
+        return null
+      } finally {
+        setIsTranscribing(false)
+      }
+    },
+    [],
+  )
+
+  const reset = useCallback(() => {
+    setResult(null)
+    setError(null)
+  }, [])
+
+  return { isTranscribing, error, result, transcribeRecording, reset }
+}

src/lib/api-key-storage.ts

@@ -48,6 +48,8 @@ export interface StoredProviderConfig {
   apiKey: string
   baseUrl: string
   model: string
+  /** 음성 전사 모델. 비우면 프리셋 기본값을 쓴다. */
+  sttModel?: string
 }
 
 export interface ProviderRequestPayload {
@@ -55,6 +57,7 @@ export interface ProviderRequestPayload {
   apiKey: string
   baseUrl: string
   model: string
+  sttModel: string
 }
 
 export function getStoredProviderConfig(): StoredProviderConfig | null {
@@ -69,6 +72,7 @@ export function getStoredProviderConfig(): StoredProviderConfig | null {
       apiKey: typeof parsed.apiKey === 'string' ? parsed.apiKey : '',
       baseUrl: typeof parsed.baseUrl === 'string' ? parsed.baseUrl : '',
       model: typeof parsed.model === 'string' ? parsed.model : '',
+      sttModel: typeof parsed.sttModel === 'string' ? parsed.sttModel : '',
     }
   } catch {
     return null
@@ -108,6 +112,7 @@ export function getProviderRequestPayload(): ProviderRequestPayload {
       apiKey: getStoredApiKey() ?? '',
       baseUrl: '',
       model: '',
+      sttModel: '',
     }
   }
 
@@ -117,5 +122,6 @@ export function getProviderRequestPayload(): ProviderRequestPayload {
     apiKey: stored.apiKey || (preset.provider === 'gemini' ? getStoredApiKey() ?? '' : ''),
     baseUrl: stored.baseUrl,
     model: stored.model,
+    sttModel: stored.sttModel ?? '',
   }
 }

src/lib/api-keys.ts

@@ -1,4 +1,9 @@
-import { isProviderId, type ProviderId, type ProviderSettings } from './providers'
+import {
+  isProviderId,
+  type ProviderId,
+  type ProviderSettings,
+  type TranscriptionSettings,
+} from './providers'
 
 /**
  * Gemini API 키 해석 우선순위:
@@ -88,3 +93,38 @@ function str(value: unknown): string {
 function env(name: string): string {
   return (process.env[name] ?? '').trim()
 }
+
+export interface TranscriptionRequestBody extends ProviderRequestBody {
+  sttModel?: unknown
+}
+
+/**
+ * 전사용 프로바이더 설정.
+ *
+ * 요약과 달리 대화 모델 이름이 없어도 된다. 전사는 `sttModel`(비우면 프로바이더
+ * 기본값)로 별도 엔드포인트를 호출하므로, 대화 모델을 지정하지 않은 사용자도
+ * 전사는 쓸 수 있어야 한다.
+ */
+export function resolveTranscriptionSettings(
+  body: TranscriptionRequestBody | null | undefined,
+): TranscriptionSettings | null {
+  const provider = resolveProvider(body?.provider)
+  const sttModel = str(body?.sttModel) || env('LLM_STT_MODEL')
+
+  if (provider === 'gemini') {
+    const apiKey = resolveGeminiApiKey(str(body?.apiKey) || env('LLM_API_KEY'))
+    if (!apiKey) return null
+    return { provider, apiKey, sttModel: sttModel || undefined }
+  }
+
+  const baseUrl = str(body?.baseUrl) || env('LLM_BASE_URL')
+  if (baseUrl.length === 0) return null
+
+  return {
+    provider,
+    apiKey: str(body?.apiKey) || env('LLM_API_KEY'),
+    baseUrl,
+    model: str(body?.model) || env('LLM_MODEL'),
+    sttModel: sttModel || undefined,
+  }
+}

src/lib/audio-session.ts

@@ -1,93 +0,0 @@
-/**
- * 녹음 중 들어오는 PCM 조각을 세션별로 모아 둔다.
- *
- * 화자 분리는 녹음이 끝난 뒤 전체 오디오에 한 번 돌린다. 누적분을 매번
- * 다시 보내면 1시간 회의에서 100MB가 넘는 요청이 되므로, 녹음 중에는
- * 몇 초짜리 조각만 올리고 서버가 이어 붙인다.
- *
- * 단일 사용자 로컬 실행을 전제로 한 메모리 저장소다. 여러 사용자가 붙는
- * 환경이라면 디스크나 외부 저장소로 옮겨야 한다.
- */
-
-export const SAMPLE_RATE = 16_000
-
-/** 세션당 최대 녹음 길이. 초과분은 거부한다. */
-export const MAX_SESSION_SECONDS = 3 * 60 * 60
-
-/** 마지막 갱신 이후 이 시간이 지난 세션은 정리한다. */
-const SESSION_TTL_MS = 6 * 60 * 60 * 1000
-
-interface Session {
-  chunks: Int16Array[]
-  totalSamples: number
-  updatedAt: number
-}
-
-const sessions = new Map<string, Session>()
-
-function sweep(): void {
-  const cutoff = Date.now() - SESSION_TTL_MS
-  for (const [id, session] of sessions) {
-    if (session.updatedAt < cutoff) sessions.delete(id)
-  }
-}
-
-export type AppendResult =
-  | { ok: true; totalSamples: number; seconds: number }
-  | { ok: false; error: string }
-
-export function appendAudio(sessionId: string, pcm: Int16Array): AppendResult {
-  sweep()
-
-  const session = sessions.get(sessionId) ?? {
-    chunks: [],
-    totalSamples: 0,
-    updatedAt: Date.now(),
-  }
-
-  const nextTotal = session.totalSamples + pcm.length
-  if (nextTotal > MAX_SESSION_SECONDS * SAMPLE_RATE) {
-    return {
-      ok: false,
-      error: `녹음이 최대 길이(${MAX_SESSION_SECONDS / 3600}시간)를 초과했습니다.`,
-    }
-  }
-
-  session.chunks.push(pcm)
-  session.totalSamples = nextTotal
-  session.updatedAt = Date.now()
-  sessions.set(sessionId, session)
-
-  return {
-    ok: true,
-    totalSamples: nextTotal,
-    seconds: nextTotal / SAMPLE_RATE,
-  }
-}
-
-/** 누적된 PCM을 모델이 받는 [-1, 1] float32로 펼친다. */
-export function collectSamples(sessionId: string): Float32Array | null {
-  const session = sessions.get(sessionId)
-  if (!session || session.totalSamples === 0) return null
-
-  const out = new Float32Array(session.totalSamples)
-  let offset = 0
-
-  for (const chunk of session.chunks) {
-    for (let i = 0; i < chunk.length; i++) {
-      out[offset + i] = chunk[i] / 32768
-    }
-    offset += chunk.length
-  }
-
-  return out
-}
-
-export function clearSession(sessionId: string): void {
-  sessions.delete(sessionId)
-}
-
-export function sessionSeconds(sessionId: string): number {
-  const session = sessions.get(sessionId)
-  return session ? session.totalSamples / SAMPLE_RATE : 0
-}

src/lib/diarization.ts

@@ -1,135 +0,0 @@
-import path from 'node:path'
-import { existsSync } from 'node:fs'
-
-/**
- * 로컬 화자 분리 (speaker diarization).
- *
- * pyannote-segmentation-3.0 + 3D-Speaker 임베딩을 ONNX Runtime으로 돌린다.
- * GPU도 파이썬 런타임도 필요 없고, 노트북 CPU에서 실시간의 수십 배 속도로 처리된다.
- *
- * 마이크 하나에 여러 사람이 섞여 들어오는 대면 회의용 경로다. 원격 회의처럼
- * 트랙이 이미 나뉘어 있으면 이 모듈을 쓰지 않는 편이 정확하다.
- */
-
-export interface SpeakerSegment {
-  /** 발화 시작 (초) */
-  start: number
-  /** 발화 종료 (초) */
-  end: number
-  /** 0부터 시작하는 화자 번호 */
-  speaker: number
-}
-
-export type DiarizationResult =
-  | { success: true; segments: SpeakerSegment[] }
-  | { success: false; error: string; reason: 'models-missing' | 'failed' }
-
-export interface DiarizeOptions {
-  /**
-   * 참석자 수. 알면 반드시 넘길 것.
-   *
-   * 자동 추정은 화자 수를 과다·과소 계수하는 것이 주 실패 모드다.
-   * 실측에서 4인 오디오가 자동 모드로는 5명, 힌트를 주면 4명으로 나왔다.
-   */
-  numSpeakers?: number
-  /** 자동 추정 시 클러스터 분리 임계값. 낮을수록 화자를 많이 잡는다. */
-  threshold?: number
-}
-
-const MODEL_DIR = process.env.DIARIZATION_MODEL_DIR ?? 'models/diarization'
-const SEGMENTATION_MODEL = 'segmentation.onnx'
-const EMBEDDING_MODEL = 'embedding.onnx'
-
-export function resolveModelPaths(): {
-  segmentation: string
-  embedding: string
-} {
-  const root = path.isAbsolute(MODEL_DIR)
-    ? MODEL_DIR
-    : path.join(process.cwd(), MODEL_DIR)
-
-  return {
-    segmentation: path.join(root, SEGMENTATION_MODEL),
-    embedding: path.join(root, EMBEDDING_MODEL),
-  }
-}
-
-export function modelsInstalled(): boolean {
-  const { segmentation, embedding } = resolveModelPaths()
-  return existsSync(segmentation) && existsSync(embedding)
-}
-
-/**
- * 모델 로딩이 수백 ms 걸리므로 프로세스당 한 번만 만들고 재사용한다.
- * 클러스터링 설정은 요청마다 바뀔 수 있어 setConfig로 갈아끼운다.
- */
-type Diarizer = {
-  process: (samples: Float32Array) => SpeakerSegment[]
-  setConfig: (config: {
-    clustering: { numClusters?: number; threshold?: number }
-  }) => void
-}
-
-let cached: Diarizer | null = null
-
-async function getDiarizer(): Promise<Diarizer> {
-  if (cached) return cached
-
-  const { segmentation, embedding } = resolveModelPaths()
-  const { OfflineSpeakerDiarization } = await import('sherpa-onnx-node')
-
-  cached = new OfflineSpeakerDiarization({
-    segmentation: {
-      pyannote: { model: segmentation },
-      numThreads: 2,
-    },
-    embedding: { model: embedding, numThreads: 2 },
-    clustering: { threshold: 0.5 },
-  }) as unknown as Diarizer
-
-  return cached
-}
-
-export async function diarize(
-  samples: Float32Array,
-  options: DiarizeOptions = {},
-): Promise<DiarizationResult> {
-  if (samples.length === 0) {
-    return { success: true, segments: [] }
-  }
-
-  if (!modelsInstalled()) {
-    return {
-      success: false,
-      reason: 'models-missing',
-      error:
-        '화자 분리 모델이 설치되지 않았습니다. `npm run setup:diarization`을 실행해주세요.',
-    }
-  }
-
-  try {
-    const diarizer = await getDiarizer()
-
-    // 참석자 수를 알면 클러스터 개수를 고정한다. 정확도가 크게 오른다.
-    diarizer.setConfig({
-      clustering:
-        options.numSpeakers && options.numSpeakers > 0
-          ? { numClusters: options.numSpeakers }
-          : { threshold: options.threshold ?? 0.5 },
-    })
-
-    const segments = diarizer.process(samples)
-
-    return {
-      success: true,
-      segments: segments.map((s) => ({
-        start: s.start,
-        end: s.end,
-        speaker: s.speaker,
-      })),
-    }
-  } catch (err) {
-    const message = err instanceof Error ? err.message : '알 수 없는 오류'
-    return { success: false, reason: 'failed', error: `화자 분리 실패: ${message}` }
-  }
-}

src/lib/providers/gemini.ts

@@ -2,6 +2,11 @@ import type {
   CompletionOptions,
   CompletionResult,
   ProviderSettings,
+  TranscriptionInput,
+  TranscriptionOptions,
+  TranscriptionResult,
+  TranscriptionSegment,
+  TranscriptionSettings,
 } from './types'
 
 export const DEFAULT_GEMINI_MODEL = 'gemini-3.5-flash-lite'
@@ -74,3 +79,187 @@ function describeHttpError(status: number): string {
   }
   return `Gemini API 호출 실패: ${status}`
 }
+
+/**
+ * Gemini 오디오 입력 기본 모델.
+ * flash-lite는 오디오를 받지 않으므로 요약용 기본값과 다르다.
+ */
+export const DEFAULT_GEMINI_STT_MODEL = 'gemini-3.6-flash'
+
+/**
+ * Gemini가 문서로 밝힌 오디오 형식.
+ *
+ * **webm은 여기에 없다.** 우리 브라우저 녹음이 webm/opus이므로 Gemini로는
+ * 실시간 녹음을 전사할 수 없고, 업로드한 mp3/wav/flac/ogg/m4a만 된다.
+ * 녹음 전사는 Whisper 호환 엔드포인트(OrcaRouter·OpenAI·로컬)를 써야 한다.
+ */
+const GEMINI_AUDIO_MIME_TYPES = [
+  'audio/wav',
+  'audio/x-wav',
+  'audio/mp3',
+  'audio/mpeg',
+  'audio/aiff',
+  'audio/aac',
+  'audio/ogg',
+  'audio/flac',
+  'audio/mp4',
+  'audio/x-m4a',
+]
+
+export function isGeminiSupportedAudioMimeType(mimeType: string): boolean {
+  const base = mimeType.split(';')[0].trim().toLowerCase()
+  return GEMINI_AUDIO_MIME_TYPES.includes(base)
+}
+
+/**
+ * inline_data로 보낼 수 있는 최대 오디오 크기.
+ *
+ * generateContent 요청 전체가 20MB를 넘으면 안 되는데 base64가 약 4/3배로
+ * 부풀리므로, 원본 기준 14MB에서 끊는다. 더 큰 파일은 Files API가 필요하다.
+ */
+export const GEMINI_INLINE_AUDIO_LIMIT = 14 * 1024 * 1024
+
+function buildTranscriptionPrompt(input: TranscriptionInput): string {
+  const lines = [
+    '이 오디오는 회의 녹음입니다. 들리는 발화를 그대로 받아쓰세요.',
+    '',
+    '규칙:',
+    '- 요약하거나 문장을 다듬지 말고 말한 그대로 옮깁니다.',
+    '- 들리지 않는 구간은 지어내지 말고 건너뜁니다.',
+    '- 각 발화 앞에 `[MM:SS]` 형식으로 시작 시각을 붙입니다.',
+    '- 설명이나 머리말 없이 전사문만 출력합니다.',
+  ]
+
+  if (input.vocabularyHint) {
+    lines.push(
+      '',
+      `이 회의에 나올 수 있는 고유명사·용어: ${input.vocabularyHint}`,
+    )
+  }
+
+  return lines.join('\n')
+}
+
+/** `[MM:SS] 텍스트` 또는 `[HH:MM:SS] 텍스트` 줄을 구간으로 바꾼다. */
+export function parseTimestampedTranscript(text: string): TranscriptionSegment[] {
+  const segments: TranscriptionSegment[] = []
+  const pattern = /^\[(?:(\d{1,2}):)?(\d{1,2}):(\d{2})\]\s*(.+)$/
+
+  for (const line of text.split('\n')) {
+    const match = pattern.exec(line.trim())
+    if (!match) continue
+
+    const [, h, m, s, body] = match
+    const start = (h ? Number(h) * 3600 : 0) + Number(m) * 60 + Number(s)
+    const content = body.trim()
+    if (content.length === 0) continue
+
+    // 다음 구간이 시작될 때까지가 이 구간이다. 마지막은 뒤에서 채운다.
+    if (segments.length > 0) {
+      segments[segments.length - 1].end = start
+    }
+    segments.push({ start, end: start, text: content })
+  }
+
+  if (segments.length > 0) {
+    const last = segments[segments.length - 1]
+    if (last.end <= last.start) last.end = last.start + 1
+  }
+
+  return segments
+}
+
+/** Gemini에 오디오를 inline으로 실어 전사한다. */
+export async function transcribeWithGemini(
+  input: TranscriptionInput,
+  settings: TranscriptionSettings,
+  options: TranscriptionOptions = {},
+): Promise<TranscriptionResult> {
+  const { fetchFn = fetch } = options
+  const apiKey = settings.apiKey.trim()
+
+  if (apiKey.length === 0) {
+    return { success: false, error: 'Gemini API 키가 필요합니다.' }
+  }
+
+  const baseMime = input.mimeType.split(';')[0].trim().toLowerCase()
+
+  if (!isGeminiSupportedAudioMimeType(input.mimeType)) {
+    return {
+      success: false,
+      error:
+        `Gemini는 ${baseMime} 형식을 받지 않습니다. ` +
+        '브라우저 녹음(webm)을 전사하려면 설정에서 OpenAI 호환 프로바이더' +
+        '(OrcaRouter · OpenAI · 로컬 whisper)를 선택해주세요.',
+    }
+  }
+
+  if (input.bytes.byteLength > GEMINI_INLINE_AUDIO_LIMIT) {
+    return {
+      success: false,
+      error:
+        `오디오가 너무 큽니다 (${Math.round(input.bytes.byteLength / 1024 / 1024)}MB). ` +
+        `Gemini 직접 호출은 ${Math.round(GEMINI_INLINE_AUDIO_LIMIT / 1024 / 1024)}MB까지만 가능합니다. ` +
+        'OpenAI 호환 프로바이더를 쓰거나 오디오를 나눠주세요.',
+    }
+  }
+
+  const model = settings.sttModel?.trim() || DEFAULT_GEMINI_STT_MODEL
+  const url = `${API_ROOT}/${encodeURIComponent(model)}:generateContent`
+
+  try {
+    const response = await fetchFn(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-goog-api-key': apiKey,
+      },
+      body: JSON.stringify({
+        contents: [
+          {
+            parts: [
+              { text: buildTranscriptionPrompt(input) },
+              {
+                inline_data: {
+                  mime_type: baseMime,
+                  data: Buffer.from(input.bytes).toString('base64'),
+                },
+              },
+            ],
+          },
+        ],
+      }),
+    })
+
+    if (!response.ok) {
+      if (response.status === 429) {
+        return {
+          success: false,
+          error: 'Gemini API 요청 한도 초과. 잠시 후 다시 시도해주세요.',
+          rateLimited: true,
+        }
+      }
+      return { success: false, error: describeHttpError(response.status) }
+    }
+
+    const data = await response.json()
+    const text: string = data?.candidates?.[0]?.content?.parts?.[0]?.text ?? ''
+
+    if (text.trim().length === 0) {
+      return {
+        success: false,
+        error: '전사 결과가 비어 있습니다. 오디오에 음성이 들어 있는지 확인해주세요.',
+      }
+    }
+
+    return {
+      success: true,
+      text: text.trim(),
+      segments: parseTimestampedTranscript(text),
+      model,
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return { success: false, error: `전사 호출 중 오류: ${message}` }
+  }
+}

src/lib/providers/index.ts

@@ -1,15 +1,39 @@
-import { completeWithGemini, resolveGeminiModel } from './gemini'
+import {
-import { completeWithOpenAICompatible } from './openai-compatible'
+  DEFAULT_GEMINI_STT_MODEL,
+  completeWithGemini,
+  resolveGeminiModel,
+  transcribeWithGemini,
+} from './gemini'
+import {
+  DEFAULT_OPENAI_STT_MODEL,
+  completeWithOpenAICompatible,
+  transcribeWithOpenAICompatible,
+} from './openai-compatible'
 import type {
   CompletionOptions,
   CompletionResult,
   ProviderSettings,
+  TranscriptionInput,
+  TranscriptionOptions,
+  TranscriptionResult,
+  TranscriptionSettings,
 } from './types'
 
 export * from './types'
 export * from './presets'
-export { DEFAULT_GEMINI_MODEL, resolveGeminiModel } from './gemini'
+export {
-export { normalizeBaseUrl } from './openai-compatible'
+  DEFAULT_GEMINI_MODEL,
+  DEFAULT_GEMINI_STT_MODEL,
+  GEMINI_INLINE_AUDIO_LIMIT,
+  isGeminiSupportedAudioMimeType,
+  parseTimestampedTranscript,
+  resolveGeminiModel,
+} from './gemini'
+export {
+  DEFAULT_OPENAI_STT_MODEL,
+  isWhisperSupportedMimeType,
+  normalizeBaseUrl,
+} from './openai-compatible'
 
 /**
  * 설정된 프로바이더로 프롬프트 1회 호출.
@@ -41,3 +65,31 @@ export function toProviderSettings(
 ): ProviderSettings {
   return settings ?? { provider: 'gemini', apiKey: apiKey ?? '' }
 }
+
+/**
+ * 설정된 프로바이더로 오디오 1건 전사.
+ *
+ * 요약과 마찬가지로 실패를 예외로 던지지 않는다. 전사는 회의가 끝난 뒤
+ * 한 번뿐인 기회이므로, 호출부가 오류 문구를 그대로 사용자에게 보여주고
+ * 원본 오디오를 내려받도록 안내할 수 있어야 한다.
+ */
+export async function transcribe(
+  input: TranscriptionInput,
+  settings: TranscriptionSettings,
+  options: TranscriptionOptions = {},
+): Promise<TranscriptionResult> {
+  if (settings.provider === 'openai-compatible') {
+    return transcribeWithOpenAICompatible(input, settings, options)
+  }
+  return transcribeWithGemini(input, settings, options)
+}
+
+/** 전사에 실제로 쓰일 모델 이름. */
+export function resolveSttModel(settings: TranscriptionSettings): string {
+  const explicit = settings.sttModel?.trim()
+  if (explicit) return explicit
+
+  return settings.provider === 'openai-compatible'
+    ? DEFAULT_OPENAI_STT_MODEL
+    : DEFAULT_GEMINI_STT_MODEL
+}

src/lib/providers/openai-compatible.ts

@@ -2,6 +2,11 @@ import type {
   CompletionOptions,
   CompletionResult,
   ProviderSettings,
+  TranscriptionInput,
+  TranscriptionOptions,
+  TranscriptionResult,
+  TranscriptionSegment,
+  TranscriptionSettings,
 } from './types'
 
 /**
@@ -110,3 +115,142 @@ function describeHttpError(status: number): string {
   }
   return `API 호출 실패: ${status}`
 }
+
+/** Whisper 계열 기본 모델. OrcaRouter·OpenAI·로컬 whisper.cpp 모두 이 이름을 쓴다. */
+export const DEFAULT_OPENAI_STT_MODEL = 'whisper-1'
+
+/**
+ * Whisper가 받아주는 컨테이너.
+ * 우리 녹음(webm/opus)이 여기 포함되므로 별도 변환 없이 그대로 보낸다.
+ */
+const WHISPER_MIME_TYPES = [
+  'audio/webm',
+  'audio/mp4',
+  'audio/mpeg',
+  'audio/mpga',
+  'audio/m4a',
+  'audio/x-m4a',
+  'audio/wav',
+  'audio/x-wav',
+  'audio/ogg',
+  'audio/flac',
+]
+
+export function isWhisperSupportedMimeType(mimeType: string): boolean {
+  const base = mimeType.split(';')[0].trim().toLowerCase()
+  return WHISPER_MIME_TYPES.includes(base)
+}
+
+/**
+ * OpenAI `/audio/transcriptions` 호환 엔드포인트로 전사.
+ *
+ * `verbose_json`을 먼저 요청한다. 구간별 실제 타임스탬프가 같이 오기 때문이다 —
+ * Web Speech가 주지 못하던 진짜 오디오 타임라인이며, 화자 분리를 얹으려면
+ * 반드시 필요하다. 이 형식을 지원하지 않는 최신 모델(gpt-4o-transcribe 등)은
+ * 400을 돌려주므로 그때는 `json`으로 한 번 더 시도한다.
+ */
+export async function transcribeWithOpenAICompatible(
+  input: TranscriptionInput,
+  settings: TranscriptionSettings,
+  options: TranscriptionOptions = {},
+): Promise<TranscriptionResult> {
+  const { fetchFn = fetch } = options
+
+  const baseUrl = normalizeBaseUrl(settings.baseUrl ?? '')
+  if (!baseUrl) {
+    return {
+      success: false,
+      error: 'API 주소(base URL)가 올바르지 않습니다. http:// 또는 https:// 로 시작해야 합니다.',
+    }
+  }
+
+  if (!isWhisperSupportedMimeType(input.mimeType)) {
+    return {
+      success: false,
+      error: `이 엔드포인트가 지원하지 않는 오디오 형식입니다 (${input.mimeType}).`,
+    }
+  }
+
+  const model = settings.sttModel?.trim() || DEFAULT_OPENAI_STT_MODEL
+
+  const headers: Record<string, string> = {}
+  const apiKey = settings.apiKey.trim()
+  if (apiKey.length > 0) {
+    headers.Authorization = `Bearer ${apiKey}`
+  }
+  // Content-Type은 지정하지 않는다. FormData가 boundary까지 붙여 설정한다.
+
+  async function send(responseFormat: 'verbose_json' | 'json') {
+    const form = new FormData()
+    form.append(
+      'file',
+      new Blob([input.bytes as BlobPart], { type: input.mimeType }),
+      input.fileName,
+    )
+    form.append('model', model)
+    form.append('response_format', responseFormat)
+    if (input.language) form.append('language', input.language)
+    if (input.vocabularyHint) form.append('prompt', input.vocabularyHint)
+
+    return fetchFn(`${baseUrl}/audio/transcriptions`, {
+      method: 'POST',
+      headers,
+      body: form,
+    })
+  }
+
+  try {
+    let response = await send('verbose_json')
+
+    // verbose_json 미지원 모델 → 타임스탬프를 포기하고 텍스트만 받는다.
+    if (response.status === 400) {
+      response = await send('json')
+    }
+
+    if (!response.ok) {
+      if (response.status === 429) {
+        return {
+          success: false,
+          error: '전사 API 요청 한도를 초과했습니다. 잠시 후 다시 시도해주세요.',
+          rateLimited: true,
+        }
+      }
+      return { success: false, error: describeHttpError(response.status) }
+    }
+
+    const data = await response.json()
+    const text: string = typeof data?.text === 'string' ? data.text : ''
+
+    if (text.trim().length === 0) {
+      return {
+        success: false,
+        error: '전사 결과가 비어 있습니다. 오디오에 음성이 들어 있는지 확인해주세요.',
+      }
+    }
+
+    return { success: true, text, segments: parseWhisperSegments(data), model }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : '알 수 없는 오류'
+    return { success: false, error: `전사 호출 중 오류: ${message}` }
+  }
+}
+
+function parseWhisperSegments(data: unknown): TranscriptionSegment[] {
+  const raw = (data as { segments?: unknown })?.segments
+  if (!Array.isArray(raw)) return []
+
+  const segments: TranscriptionSegment[] = []
+
+  for (const item of raw) {
+    const start = Number((item as { start?: unknown })?.start)
+    const end = Number((item as { end?: unknown })?.end)
+    const text = String((item as { text?: unknown })?.text ?? '').trim()
+
+    if (!Number.isFinite(start) || !Number.isFinite(end)) continue
+    if (text.length === 0) continue
+
+    segments.push({ start: Math.max(0, start), end: Math.max(start, end), text })
+  }
+
+  return segments
+}

src/lib/providers/presets.ts

@@ -1,4 +1,5 @@
-import { DEFAULT_GEMINI_MODEL } from './gemini'
+import { DEFAULT_GEMINI_MODEL, DEFAULT_GEMINI_STT_MODEL } from './gemini'
+import { DEFAULT_OPENAI_STT_MODEL } from './openai-compatible'
 import type { ProviderId } from './types'
 
 export interface ProviderPreset {
@@ -8,6 +9,10 @@ export interface ProviderPreset {
   /** openai-compatible 프리셋의 기본 base URL. 사용자가 수정할 수 있다. */
   baseUrl: string
   defaultModel: string
+  /** 음성 전사(STT)에 쓸 기본 모델. 요약용 모델과 다르다. */
+  defaultSttModel: string
+  /** 이 프로바이더로 브라우저 녹음(webm)을 전사할 수 있는지. */
+  canTranscribeWebm: boolean
   description: string
   apiKeyLabel: string
   apiKeyPlaceholder: string
@@ -25,6 +30,9 @@ export const PROVIDER_PRESETS: ProviderPreset[] = [
     provider: 'gemini',
     baseUrl: '',
     defaultModel: DEFAULT_GEMINI_MODEL,
+    defaultSttModel: DEFAULT_GEMINI_STT_MODEL,
+    // Gemini는 webm 오디오를 받지 않는다 — 업로드한 mp3/wav/flac만 전사 가능.
+    canTranscribeWebm: false,
     description: 'Google에 직접 호출합니다. 무료 티어가 있어 가장 간단합니다.',
     apiKeyLabel: 'Gemini API 키',
     apiKeyPlaceholder: 'AIzaSy...',
@@ -39,7 +47,9 @@ export const PROVIDER_PRESETS: ProviderPreset[] = [
     provider: 'openai-compatible',
     baseUrl: 'https://api.openai.com/v1',
     defaultModel: 'gpt-4o-mini',
-    description: 'OpenAI Chat Completions API를 사용합니다.',
+    defaultSttModel: DEFAULT_OPENAI_STT_MODEL,
+    canTranscribeWebm: true,
+    description: 'OpenAI Chat Completions + Whisper 전사를 사용합니다.',
     apiKeyLabel: 'OpenAI API 키',
     apiKeyPlaceholder: 'sk-...',
     docsUrl: 'https://platform.openai.com/api-keys',
@@ -52,6 +62,8 @@ export const PROVIDER_PRESETS: ProviderPreset[] = [
     provider: 'openai-compatible',
     baseUrl: 'https://api.orcarouter.ai/v1',
     defaultModel: 'google/gemini-3.5-flash-lite',
+    defaultSttModel: 'openai/whisper-1',
+    canTranscribeWebm: true,
     description:
       '하나의 키로 여러 제공사 모델을 사용합니다. 별도 가입과 크레딧 충전(또는 BYOK 등록)이 필요합니다.',
     apiKeyLabel: 'OrcaRouter API 키',
@@ -67,6 +79,8 @@ export const PROVIDER_PRESETS: ProviderPreset[] = [
     provider: 'openai-compatible',
     baseUrl: 'http://localhost:11434/v1',
     defaultModel: 'llama3.1',
+    defaultSttModel: 'whisper-1',
+    canTranscribeWebm: true,
     description:
       'Ollama · LM Studio · vLLM 등 내 PC에서 도는 모델. 회의 내용이 외부로 나가지 않습니다.',
     apiKeyLabel: 'API 키 (보통 불필요)',
@@ -80,6 +94,8 @@ export const PROVIDER_PRESETS: ProviderPreset[] = [
     provider: 'openai-compatible',
     baseUrl: '',
     defaultModel: '',
+    defaultSttModel: DEFAULT_OPENAI_STT_MODEL,
+    canTranscribeWebm: true,
     description: 'OpenAI 호환 엔드포인트라면 무엇이든 연결할 수 있습니다.',
     apiKeyLabel: 'API 키',
     apiKeyPlaceholder: 'sk-...',

src/lib/providers/types.ts

@@ -30,3 +30,53 @@ export type CompletionResult =
 export interface CompletionOptions {
   fetchFn?: typeof fetch
 }
+
+/* ------------------------------------------------------------------------- *
+ * 음성 전사 (STT)
+ * ------------------------------------------------------------------------- */
+
+/**
+ * 전사할 오디오.
+ *
+ * 파일 전체를 메모리에 올린다. 회의 하나가 상한(수십 MB) 안에 들어오도록
+ * 녹음 비트레이트를 낮춰 두었으므로 스트리밍까지 갈 필요는 없다.
+ */
+export interface TranscriptionInput {
+  bytes: Uint8Array
+  mimeType: string
+  fileName: string
+  /** BCP-47 앞부분. 예: 'ko'. 지정하면 인식 정확도가 눈에 띄게 오른다. */
+  language?: string
+  /**
+   * 어휘 힌트. 참석자 이름·제품명·사내 용어를 넣으면 고유명사 오인식이 준다.
+   * Whisper는 이 문자열을 직전 문맥처럼 취급한다(약 224토큰까지).
+   */
+  vocabularyHint?: string
+}
+
+/** 전사 구간. Whisper `verbose_json`이 주는 실제 오디오 타임라인 기준. */
+export interface TranscriptionSegment {
+  /** 초 단위, 오디오 시작 기준. */
+  start: number
+  end: number
+  text: string
+}
+
+export type TranscriptionResult =
+  | {
+      success: true
+      text: string
+      /** 프로바이더가 타임스탬프를 주지 않으면 비어 있다. */
+      segments: TranscriptionSegment[]
+      model: string
+    }
+  | { success: false; error: string; rateLimited?: boolean }
+
+export interface TranscriptionOptions {
+  fetchFn?: typeof fetch
+}
+
+/** 전사에 쓸 모델은 대화용 모델과 다르므로 따로 받는다. */
+export interface TranscriptionSettings extends ProviderSettings {
+  sttModel?: string
+}

src/lib/recording-store.ts

@@ -0,0 +1,195 @@
+/**
+ * 녹음 조각을 디스크에 이어 붙이는 서버 저장소.
+ *
+ * 메모리에 모아 뒀다가 종료 시 한 번에 쓰지 않는다. 그러면 탭이나 서버가
+ * 죽는 순간 회의 전체가 사라진다. 조각이 도착할 때마다 곧바로 append 하므로
+ * 어느 시점에 중단되든 그때까지의 오디오는 파일로 남아 있다.
+ *
+ * MediaRecorder가 timeslice 모드에서 내보내는 조각은 첫 조각에 컨테이너
+ * 헤더가 들어 있고 이후에는 클러스터만 이어진다. 받은 순서대로 이어 붙이면
+ * 그대로 재생·전사 가능한 파일이 된다. 단 헤더의 duration 필드는 비어 있어
+ * 플레이어에 따라 탐색(seek)이 부정확할 수 있다 — 재전사에는 영향이 없다.
+ */
+
+import { randomBytes } from 'crypto'
+import { createReadStream } from 'fs'
+import type { Readable } from 'stream'
+import { appendFile, mkdir, readFile, stat, writeFile } from 'fs/promises'
+import path from 'path'
+import {
+  MAX_RECORDING_BYTES,
+  extensionForMimeType,
+  isValidRecordingId,
+} from './recording'
+
+/** 별도 볼륨에 두고 싶으면 `RECORDINGS_DIR`로 덮어쓴다. */
+export const RECORDINGS_DIR =
+  process.env.RECORDINGS_DIR ?? path.join(process.cwd(), 'uploads', 'recordings')
+
+export interface RecordingMeta {
+  id: string
+  mimeType: string
+  /** `uploads/recordings/` 기준 상대 파일명. */
+  fileName: string
+  startedAt: string
+  finalizedAt: string | null
+  durationMs: number | null
+}
+
+export interface RecordingStatus extends RecordingMeta {
+  bytes: number
+}
+
+/**
+ * id별 직렬화 큐.
+ *
+ * 조각의 순서가 곧 파일의 순서다. 두 요청이 겹쳐 들어오면 컨테이너가
+ * 깨지므로 같은 녹음에 대한 쓰기는 한 줄로 세운다.
+ */
+const queues = new Map<string, Promise<unknown>>()
+
+function enqueue<T>(id: string, task: () => Promise<T>): Promise<T> {
+  const previous = queues.get(id) ?? Promise.resolve()
+  const next = previous.then(task, task)
+
+  // 앞 작업이 실패해도 뒤 작업은 돌아야 하므로, 큐에는 절대 거부되지 않는
+  // 프로미스를 넣는다. 실패는 호출자가 받는 `next`로만 전달된다.
+  const settled = next.then(
+    () => undefined,
+    () => undefined,
+  )
+
+  // 큐가 무한정 자라지 않도록, 마지막 작업이 끝나면 항목을 지운다.
+  queues.set(id, settled)
+  settled.then(() => {
+    if (queues.get(id) === settled) queues.delete(id)
+  })
+
+  return next
+}
+
+function metaPath(id: string): string {
+  return path.join(RECORDINGS_DIR, `${id}.json`)
+}
+
+function audioPath(meta: RecordingMeta): string {
+  return path.join(RECORDINGS_DIR, meta.fileName)
+}
+
+async function fileSize(filePath: string): Promise<number> {
+  try {
+    return (await stat(filePath)).size
+  } catch {
+    return 0
+  }
+}
+
+/** 새 녹음 세션을 만든다. 오디오 파일은 첫 조각이 도착할 때 생긴다. */
+export async function createRecording(
+  mimeType: string,
+): Promise<RecordingMeta> {
+  const id = randomBytes(16).toString('hex')
+  const meta: RecordingMeta = {
+    id,
+    mimeType,
+    fileName: `${id}.${extensionForMimeType(mimeType)}`,
+    startedAt: new Date().toISOString(),
+    finalizedAt: null,
+    durationMs: null,
+  }
+
+  await mkdir(RECORDINGS_DIR, { recursive: true })
+  await writeFile(metaPath(id), JSON.stringify(meta, null, 2), 'utf-8')
+
+  return meta
+}
+
+export async function getRecording(id: string): Promise<RecordingMeta | null> {
+  if (!isValidRecordingId(id)) return null
+
+  try {
+    const raw = await readFile(metaPath(id), 'utf-8')
+    return JSON.parse(raw) as RecordingMeta
+  } catch {
+    return null
+  }
+}
+
+export async function getRecordingStatus(
+  id: string,
+): Promise<RecordingStatus | null> {
+  const meta = await getRecording(id)
+  if (!meta) return null
+
+  return { ...meta, bytes: await fileSize(audioPath(meta)) }
+}
+
+export type AppendResult =
+  | { ok: true; bytes: number }
+  | { ok: false; error: string; status: number }
+
+/** 조각 하나를 파일 끝에 이어 붙이고 누적 크기를 돌려준다. */
+export async function appendChunk(
+  id: string,
+  chunk: Buffer,
+): Promise<AppendResult> {
+  const meta = await getRecording(id)
+  if (!meta) {
+    return { ok: false, error: '녹음 세션을 찾을 수 없습니다.', status: 404 }
+  }
+
+  return enqueue(id, async () => {
+    const filePath = audioPath(meta)
+    const current = await fileSize(filePath)
+
+    if (current + chunk.byteLength > MAX_RECORDING_BYTES) {
+      return {
+        ok: false as const,
+        error: `녹음이 상한(${Math.round(
+          MAX_RECORDING_BYTES / 1024 / 1024,
+        )}MB)을 넘었습니다.`,
+        status: 413,
+      }
+    }
+
+    await appendFile(filePath, chunk)
+    return { ok: true as const, bytes: current + chunk.byteLength }
+  })
+}
+
+/** 녹음을 닫는다. 이후 조각은 더 오지 않는다고 보고 길이를 확정한다. */
+export async function finalizeRecording(
+  id: string,
+  durationMs: number | null,
+): Promise<RecordingStatus | null> {
+  const meta = await getRecording(id)
+  if (!meta) return null
+
+  return enqueue(id, async () => {
+    const updated: RecordingMeta = {
+      ...meta,
+      finalizedAt: new Date().toISOString(),
+      durationMs:
+        typeof durationMs === 'number' && Number.isFinite(durationMs)
+          ? Math.max(0, Math.round(durationMs))
+          : null,
+    }
+
+    await writeFile(metaPath(id), JSON.stringify(updated, null, 2), 'utf-8')
+    return { ...updated, bytes: await fileSize(audioPath(updated)) }
+  })
+}
+
+/** 다운로드용 읽기 스트림. 파일이 없으면 null. */
+export async function openRecording(
+  id: string,
+): Promise<{ meta: RecordingMeta; bytes: number; stream: Readable } | null> {
+  const meta = await getRecording(id)
+  if (!meta) return null
+
+  const filePath = audioPath(meta)
+  const bytes = await fileSize(filePath)
+  if (bytes === 0) return null
+
+  return { meta, bytes, stream: createReadStream(filePath) }
+}

src/lib/recording.ts

@@ -0,0 +1,148 @@
+/**
+ * 회의 오디오 녹음 — 브라우저·서버가 공유하는 상수와 순수 함수.
+ *
+ * 녹음의 목적은 재생이 아니라 **재전사**다. Web Speech가 놓친 발화를 나중에
+ * 서버 STT로 되살리려면 원본 오디오가 남아 있어야 한다. 그래서 전사와
+ * 무관하게, 전사가 실패하더라도 오디오만은 반드시 파일로 남긴다.
+ */
+
+/** MediaRecorder에 우선순위대로 시도할 컨테이너/코덱. */
+export const PREFERRED_MIME_TYPES = [
+  'audio/webm;codecs=opus',
+  'audio/webm',
+  'audio/ogg;codecs=opus',
+  'audio/mp4',
+] as const
+
+/**
+ * 대면 회의 기준 캡처 제약.
+ *
+ * 브라우저 기본값은 세 가지가 모두 켜져 있고 전화 통화용으로 튜닝돼 있다.
+ * 노이즈 억제는 멀리 앉은 화자의 목소리를 노이즈로 오판해 지워버릴 수 있고,
+ * 에코 제거는 스피커 출력이 없는 대면 회의에서는 얻을 게 없다. 둘 다 끈다.
+ * 반면 AGC는 조용한 화자의 레벨을 끌어올려 주므로 남긴다.
+ *
+ * 원격 회의(스피커 출력이 마이크로 되먹임되는 경우)에는 echoCancellation을
+ * 다시 켜야 한다. 그 경로는 dual-stream 캡처와 함께 다룬다.
+ */
+export const RECORDING_AUDIO_CONSTRAINTS: MediaTrackConstraints = {
+  channelCount: 1,
+  echoCancellation: false,
+  noiseSuppression: false,
+  autoGainControl: true,
+}
+
+/**
+ * 서버로 조각을 올리는 간격.
+ *
+ * 짧을수록 탭이 죽었을 때 잃는 양이 적고, 길수록 요청 수가 준다. 15초면
+ * 최악의 경우에도 15초치만 잃는다.
+ */
+export const CHUNK_INTERVAL_MS = 15_000
+
+/**
+ * 녹음 비트레이트.
+ *
+ * 이 오디오는 감상용이 아니라 STT 입력이다. Opus는 음성 대역에서 32kbps만
+ * 되어도 인식 정확도에 영향이 없고, 대신 파일이 작아야 전사 API에 통째로
+ * 넣을 수 있다. 128kbps로 두면 46분 회의가 44MB가 되어 Whisper 상한(25MB)도,
+ * Gemini inline 상한도 넘긴다.
+ *
+ * 32kbps 기준 대략:  46분 → 11MB,  1시간 → 14MB,  1시간 40분 → 24MB
+ */
+export const AUDIO_BITS_PER_SECOND = 32_000
+
+/** 회의 하나의 상한. 128kbps 기준 약 8.6시간. */
+export const MAX_RECORDING_BYTES = 500 * 1024 * 1024
+
+/** 조각 하나의 상한. 15초 × 128kbps면 240KB 남짓이라 넉넉하다. */
+export const MAX_CHUNK_BYTES = 8 * 1024 * 1024
+
+/** 브라우저가 지원하는 첫 번째 후보를 고른다. 없으면 null. */
+export function pickRecorderMimeType(
+  isTypeSupported: (type: string) => boolean,
+): string | null {
+  for (const type of PREFERRED_MIME_TYPES) {
+    if (isTypeSupported(type)) return type
+  }
+  return null
+}
+
+/** `audio/webm;codecs=opus` → `webm` */
+export function extensionForMimeType(mimeType: string): string {
+  const base = mimeType.split(';')[0].trim().toLowerCase()
+
+  switch (base) {
+    case 'audio/webm':
+      return 'webm'
+    case 'audio/ogg':
+      return 'ogg'
+    case 'audio/mp4':
+    case 'audio/x-m4a':
+      return 'm4a'
+    case 'audio/mpeg':
+      return 'mp3'
+    case 'audio/wav':
+    case 'audio/x-wav':
+      return 'wav'
+    case 'audio/flac':
+      return 'flac'
+    default:
+      return 'bin'
+  }
+}
+
+/**
+ * 녹음 세션 식별자 검증.
+ *
+ * 이 값이 그대로 파일 경로가 되므로 `..`이나 구분자가 섞이면 안 된다.
+ * 경로 조립 전에 반드시 통과시킨다.
+ */
+const RECORDING_ID_PATTERN = /^[0-9a-f]{32}$/
+
+export function isValidRecordingId(id: unknown): id is string {
+  return typeof id === 'string' && RECORDING_ID_PATTERN.test(id)
+}
+
+/** 사용자가 내려받을 때 보게 될 파일 이름. */
+export function recordingDownloadName(
+  title: string,
+  startedAt: Date,
+  mimeType: string,
+): string {
+  const stamp = [
+    startedAt.getFullYear(),
+    String(startedAt.getMonth() + 1).padStart(2, '0'),
+    String(startedAt.getDate()).padStart(2, '0'),
+    '-',
+    String(startedAt.getHours()).padStart(2, '0'),
+    String(startedAt.getMinutes()).padStart(2, '0'),
+  ].join('')
+
+  const safeTitle = title
+    .trim()
+    .replace(/[\\/:*?"<>|]/g, '')
+    .replace(/\s+/g, '_')
+    .slice(0, 60)
+
+  const stem = safeTitle.length > 0 ? `${stamp}_${safeTitle}` : stamp
+  return `${stem}.${extensionForMimeType(mimeType)}`
+}
+
+export function formatBytes(bytes: number): string {
+  if (!Number.isFinite(bytes) || bytes < 0) return '0B'
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)}KB`
+  return `${(bytes / 1024 / 1024).toFixed(1)}MB`
+}
+
+export function formatDuration(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000))
+  const h = Math.floor(total / 3600)
+  const m = Math.floor((total % 3600) / 60)
+  const s = total % 60
+  const mm = String(m).padStart(2, '0')
+  const ss = String(s).padStart(2, '0')
+
+  return h > 0 ? `${h}:${mm}:${ss}` : `${mm}:${ss}`
+}

src/lib/speakers.ts

@@ -1,55 +0,0 @@
-/**
- * 화자 식별자.
- *
- * dual-stream 캡처에서는 트랙이 곧 화자이므로 추론이 개입하지 않는다.
- * 단일 트랙에서 화자를 추정하는 경로가 생기면 'spk_1' 같은 식별자가 추가된다.
- */
-export const LOCAL_SPEAKER = 'local'
-export const REMOTE_SPEAKER = 'remote'
-
-export type SpeakerNames = Readonly<Record<string, string>>
-
-/** diarization이 매긴 화자 번호를 식별자로 바꾼다. 0-based → 1-based. */
-export function diarizedSpeakerId(index: number): string {
-  return `spk_${index + 1}`
-}
-
-const DEFAULT_NAMES: SpeakerNames = {
-  [LOCAL_SPEAKER]: '나',
-  [REMOTE_SPEAKER]: '상대',
-}
-
-/** 화자 식별자를 표시용 이름으로 바꾼다. 사용자가 지정한 이름이 우선한다. */
-export function resolveSpeakerName(
-  speaker: string,
-  names?: SpeakerNames,
-): string {
-  const custom = names?.[speaker]?.trim()
-  if (custom) return custom
-
-  const preset = DEFAULT_NAMES[speaker]
-  if (preset) return preset
-
-  // spk_1 → "화자 1"
-  const diarized = /^spk_(\d+)$/.exec(speaker)
-  if (diarized) return `화자 ${diarized[1]}`
-
-  return speaker
-}
-
-/** 회의록에 저장할 참석자 목록. 지정된 이름이 없으면 기본 표기를 쓴다. */
-export function listAttendees(
-  speakers: readonly string[],
-  names?: SpeakerNames,
-): string[] {
-  const seen = new Set<string>()
-  const result: string[] = []
-
-  for (const speaker of speakers) {
-    if (seen.has(speaker)) continue
-    seen.add(speaker)
-    result.push(resolveSpeakerName(speaker, names))
-  }
-
-  return result
-}

src/lib/transcript-formatter.ts

@@ -1,12 +1,8 @@
-import { resolveSpeakerName, type SpeakerNames } from './speakers'
-
 export interface TranscriptChunk {
   text: string
   startTime: number
   endTime: number
   isFinal: boolean
-  /** 화자 식별자. 단일 트랙 녹음에서는 없다. */
-  speaker?: string
 }
 
 function formatTimestamp(seconds: number): string {
@@ -20,42 +16,14 @@ function formatTimestamp(seconds: number): string {
   return `[${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}]`
 }
 
-export function formatTranscriptChunks(
+export function formatTranscriptChunks(chunks: readonly TranscriptChunk[]): string {
-  chunks: readonly TranscriptChunk[],
-  names?: SpeakerNames,
-): string {
   if (chunks.length === 0) return ''
 
   return chunks
-    .map((chunk) => {
+    .map((chunk) => `${formatTimestamp(chunk.startTime)} ${chunk.text}`)
-      const stamp = formatTimestamp(chunk.startTime)
-      if (!chunk.speaker) return `${stamp} ${chunk.text}`
-      return `${stamp} ${resolveSpeakerName(chunk.speaker, names)}: ${chunk.text}`
-    })
     .join('\n')
 }
 
-/**
- * 여러 트랙에서 나온 청크를 하나의 시간축으로 합친다.
- *
- * 각 인식기가 독립적으로 동작하므로 도착 순서가 발화 순서와 다를 수 있다.
- * 모든 트랙이 같은 timeOrigin을 공유한다는 전제 아래 startTime으로 정렬한다.
- */
-export function mergeSpeakerChunks(
-  ...streams: readonly (readonly TranscriptChunk[])[]
-): TranscriptChunk[] {
-  const merged = streams.flat()
-
-  return merged
-    .map((chunk, index) => ({ chunk, index }))
-    .sort((a, b) => {
-      const diff = a.chunk.startTime - b.chunk.startTime
-      // 같은 시각이면 원래 순서를 유지해 결과가 흔들리지 않게 한다.
-      return diff !== 0 ? diff : a.index - b.index
-    })
-    .map(({ chunk }) => chunk)
-}
-
 export function mergeAdjacentChunks(
   chunks: readonly TranscriptChunk[],
   gapThreshold: number,
@@ -68,19 +36,12 @@ export function mergeAdjacentChunks(
     const current = chunks[i]
     const last = result[result.length - 1]
 
-    // 화자가 다르면 붙이지 않는다 — 서로 다른 사람의 발화가 한 덩어리가 되면 안 된다.
-    if (current.speaker !== last.speaker) {
-      result.push({ ...current })
-      continue
-    }
-
     if (current.startTime - last.endTime <= gapThreshold) {
       result[result.length - 1] = {
         text: `${last.text} ${current.text}`,
         startTime: last.startTime,
         endTime: current.endTime,
         isFinal: current.isFinal,
-        ...(last.speaker ? { speaker: last.speaker } : {}),
       }
     } else {
       result.push({ ...current })
@@ -90,63 +51,31 @@ export function mergeAdjacentChunks(
   return result
 }
 
-export interface TimeSpan {
-  start: number
-  end: number
-  speaker: number
-}
-
-function overlap(
-  aStart: number,
-  aEnd: number,
-  bStart: number,
-  bEnd: number,
-): number {
-  return Math.max(0, Math.min(aEnd, bEnd) - Math.max(aStart, bStart))
-}
-
 /**
- * diarization 결과를 전사 청크에 붙인다.
+ * 서버 STT가 준 구간을 전사문으로 옮긴다.
  *
- * 청크마다 시간이 가장 많이 겹치는 화자 구간을 고른다. 겹치는 구간이 없으면
+ * 여기 붙는 타임스탬프는 실제 오디오 타임라인이다. Web Speech 경로가 쓰던
- * 화자를 비워 둔다 — 틀린 화자를 붙이는 것보다 없는 편이 낫다.
+ * `결과 이벤트 시각 − 2초` 추정값과 달리 화자 분리·구간 재생에 그대로 쓸 수 있다.
- *
- * Web Speech API가 주는 청크 타임스탬프는 근사값이므로 이 매칭도 근사다.
  */
-export function assignSpeakers(
+export function formatTranscriptionSegments(
-  chunks: readonly TranscriptChunk[],
+  segments: readonly { start: number; text: string }[],
-  segments: readonly TimeSpan[],
+): string {
-  speakerId: (index: number) => string,
+  return segments
+    .filter((segment) => segment.text.trim().length > 0)
+    .map((segment) => `${formatTimestamp(segment.start)} ${segment.text.trim()}`)
+    .join('\n')
+}
+
+/** STT 구간을 기존 청크 구조로 변환한다 (화자 배정·병합 로직 재사용용). */
+export function segmentsToChunks(
+  segments: readonly { start: number; end: number; text: string }[],
 ): TranscriptChunk[] {
-  if (segments.length === 0) return chunks.map((chunk) => ({ ...chunk }))
+  return segments
-
+    .filter((segment) => segment.text.trim().length > 0)
-  return chunks.map((chunk) => {
+    .map((segment) => ({
-    let best: TimeSpan | null = null
+      text: segment.text.trim(),
-    let bestOverlap = 0
+      startTime: Math.max(0, segment.start),
-
+      endTime: Math.max(segment.start, segment.end),
-    for (const segment of segments) {
+      isFinal: true,
-      const value = overlap(
+    }))
-        chunk.startTime,
-        chunk.endTime,
-        segment.start,
-        segment.end,
-      )
-      if (value > bestOverlap) {
-        bestOverlap = value
-        best = segment
-      }
-    }
-
-    if (!best) {
-      // 겹치는 구간이 없으면 이전 라벨도 남기지 않는다.
-      return {
-        text: chunk.text,
-        startTime: chunk.startTime,
-        endTime: chunk.endTime,
-        isFinal: chunk.isFinal,
-      }
-    }
-
-    return { ...chunk, speaker: speakerId(best.speaker) }
-  })
 }

src/types/sherpa-onnx-node.d.ts

@@ -1,36 +0,0 @@
-/**
- * sherpa-onnx-node는 JSDoc만 제공하고 .d.ts를 배포하지 않는다.
- * 이 프로젝트가 실제로 쓰는 화자 분리 API만 선언한다.
- */
-declare module 'sherpa-onnx-node' {
-  export interface SherpaSpeakerSegment {
-    start: number
-    end: number
-    speaker: number
-  }
-
-  export interface FastClusteringConfig {
-    numClusters?: number
-    threshold?: number
-  }
-
-  export interface OfflineSpeakerDiarizationConfig {
-    segmentation?: {
-      pyannote?: { model?: string; windowShiftRatio?: number }
-      numThreads?: number
-      provider?: string
-      debug?: boolean | number
-    }
-    embedding?: { model?: string; numThreads?: number; provider?: string }
-    clustering?: FastClusteringConfig
-    minDurationOn?: number
-    minDurationOff?: number
-  }
-
-  export class OfflineSpeakerDiarization {
-    constructor(config: OfflineSpeakerDiarizationConfig)
-    readonly sampleRate: number
-    process(samples: Float32Array): SherpaSpeakerSegment[]
-    setConfig(config: { clustering: FastClusteringConfig }): void
-  }
-}

src/types/speech-recognition.d.ts

@@ -5,11 +5,7 @@ interface SpeechRecognition extends EventTarget {
   onresult: ((event: SpeechRecognitionEvent) => void) | null
   onend: (() => void) | null
   onerror: ((event: SpeechRecognitionErrorEvent) => void) | null
-  /**
+  start(): void
-   * audioTrack을 넘기면 기본 마이크 대신 그 트랙을 전사한다 (Chrome 한정).
-   * 트랙별로 인식기를 붙이면 화자가 트랙 번호로 확정된다.
-   */
-  start(audioTrack?: MediaStreamTrack): void
   stop(): void
   abort(): void
 }