React 스트리밍 SSR 은 HTTP 응답 하나를 닫지 않고 조금씩 써 보낸다. 먼저 데이터를 기다리지 않는 부분인 셸을 보낸다. 아직 준비 안 된 Suspense 경계 자리에는 주석 표시와 빈 template, 그리고 fallback 이 들어간다. 경계의 데이터가 오면 같은 응답 뒤쪽에 숨긴 div 로 진짜 내용을 붙이고, 짧은 스크립트가 fallback 을 그 내용으로 바꿔 끼운다. 경계는 준비된 순서대로 오므로 느린 경계 하나가 뒤의 경계를 막지 않는다. 바꿔 끼우기는 바로 하지 않고 모아서 다음 프레임에 하고, 한 번 바꾼 뒤에는 300ms 가 지나야 다시 바꾼다. 마지막 경계가 와야 응답이 닫히고 브라우저의 문서 파싱이 끝난다. 사람에게는 셸이 되자마자 흘려보내고, 크롤러처럼 완성된 문서가 필요하면 모든 경계가 풀릴 때까지 기다렸다가 한 번에 보낸다.

-- 응답 하나 = 셸 하나 + 기다리던 경계마다 조각 하나. 마지막 경계까지 응답은 열려 있다
stream :: Tree -> [Chunk]
stream t = shell t : [ segment b <> swap b | b <- readyOrder (pending t) ]   -- 준비된 순서, 문서 순서가 아니다
  -- 마지막 조각 뒤에야 응답이 닫히고 브라우저 파싱이 끝난다 → defer 스크립트는 가장 느린 경계를 기다린다

-- 셸에서 경계 자리
boundary :: Boundary -> Chunk
boundary b | ready b   = "<!--$-->"  <> html b                                        <> "<!--/$-->"
           | failed b  = "<!--$!-->" <> fallback b                                    <> "<!--/$-->"  -- 클라이언트가 다시 그린다
           | otherwise = "<!--$?--><template id=\"B:" <> n b <> "\"></template>" <> fallback b <> "<!--/$-->"
  -- ready 라도 뒤로 뺀다(셸엔 $? 자리, 내용은 segment+swap): 500B 넘는 경계가 이미 쓴 것과 합쳐 12,800B(progressiveChunkSize) 를 넘을 때
  --   · 스타일시트를 기다려야 할 때 · defer 일 때. 셸이 너무 커져 첫 화면이 늦어지지 않게

segment b = "<div hidden id=\"S:" <> n b <> "\">" <> html b <> "</div>"   -- 화면 밖에 먼저 붙는다
swap    b = "<script>$RC(\"B:" <> n b <> "\",\"S:" <> n b <> "\")</script>" -- $RC 정의는 첫 swap 앞에 한 번 인라인으로

-- $RC: 바로 바꾸지 않는다. 표시를 $~ 로 바꿔 대기열에 넣고 한꺼번에 바꾼다($RV)
reveal :: Ms -> Maybe Ms -> Delay
reveal _   Nothing               = nextFrame                 -- 아직 한 번도 안 바꿨다
reveal now (Just _) | 2000 < now && now < 2300 = 2300 - now  -- 이 구간이면 2.3초에 맞춘다
reveal now (Just last)           = last + 300 - now          -- 지난 바꾸기 300ms 뒤
  -- $RV: 표시 사이 fallback 노드를 지우고 S:n 의 자식을 옮겨 넣고 표시를 "$" 로. _reactRetry 가 있으면 다음 프레임에 그 경계를 하이드레이트
  -- B:n 이 없으면(그 사이 지워졌다) S:n 도 지운다

-- 언제 흘려보내나 (renderToPipeableStream)
send :: Reader -> Hook
send Person  = onShellReady   -- 셸이 되면 pipe. 경계는 오는 대로
send Crawler = onAllReady     -- 다 풀린 뒤 pipe. 작은 경계는 셸 안에 "<!--$-->" 로, 큰 경계는 여전히 뒤로 빠져 $RC 로 끼운다
  -- 셸조차 실패하면 onShellError
  -- pipe: 버퍼가 차면 멈췄다 'drain' 에 이어 쓴다. 'close'·'error' 면 렌더를 취소. pipe 는 한 번만
#612

Text.js 는 React 화면을 브라우저 콘솔에 그린다. 화면을 글자 칸 격자로 만든 뒤, 한 줄 안에서 스타일이 같은 칸끼리 묶고, 묶음마다 %c 와 CSS 하나를 붙여 서식 문자열 하나로 만든다. 장면 하나가 console.log 한 번이다. 바뀐 칸이 없으면 아무것도 부르지 않는다. 다음 장면은 지우지 않고 아래에 덧붙인다. 장면 앞에 높이가 화면만 한 빈 줄을 넣어 앞 장면을 위로 밀어내면, 맨 아래를 따라가는 콘솔 스크롤이 장면을 바꿔 보여준다. 매번 지우면 DevTools 가 지우기는 바로, 새 메시지는 50ms 마다 묶어 그려서 빈 콘솔이 깜빡인다. 그래서 지우기는 첫 장면, 300 장째, 100 장이 쌓이고 1초 쉰 뒤에만 한다.

-- 장면 하나 = console.log 한 번
frame :: Grid -> Maybe (Format, [Css])
frame g | changedCells g == 0 = Nothing                 -- log 도 clear 도 부르지 않는다
        | otherwise           = Just (assemble (map spans (rows g)))
  -- Grid: 칸마다 글자 · 글자색 · 배경색(0xRRGGBBAA) · 속성. React 리컨실러 → Yoga 레이아웃이 채운다
  -- spans: 행 해시가 바뀐 행만 다시 훑어 같은 스타일 칸을 묶는다
  -- assemble: 묶음마다 "%c" ++ 글자, css 인자 하나. \n 양쪽 스타일이 같으면 한 묶음으로 잇는다
  --           빈칸은 배경이 같은 이웃에 흡수, 묶이지 않은 \n 앞에선 %c "" 로 스타일을 끊는다

-- 장면 바꾸기: 지우지 않고 아래에 덧붙인다
emit :: Count -> Frame -> IO ()
emit n f | n == 0 || n >= 300 || (n >= 100 && idle 1000) = clear >> log (curtain <> f)
         | otherwise                                        =          log (curtain <> f)
  -- curtain: margin-top:100vh 짜리 폭 0 묶음. 앞 장면을 위로 밀어 짧은 장면 아래로 옛 꼬리가 안 보이게
  --          Firefox · Safari 는 인라인의 세로 margin 을 무시해 line-height:100vh
  -- 매 장면 clear 하면: DevTools 는 clear 는 바로, 새 메시지는 50ms throttle 로 그린다 → 빈 콘솔이 깜빡
  -- 간격은 66ms 이상(~15fps): 더 빠르면 throttle 이 다시 걸려 장면이 버려진다
  -- clear 직후엔 한 번 110ms 기다린다: "Console was cleared" 줄이 즉시 슬롯을 먹어 다음 장면이 50ms 타이머로 밀린다
  -- 행 해시는 같은데 다시 그려야 하면 끝에 ​ 를 번갈아 붙인다: 같은 메시지는 반복 배지로 접혀 옆으로 밀린다

-- 글자를 서식 문자열에 넣을 때 DevTools 가 망치는 것
escape :: Text -> Text
escape = replace "%" "%%"                    -- "100%" 가 %c 인자를 먹지 않게
       . insertWordJoiner ["://", "www.", "path:line"]   -- ⁠: 링크로 바뀌며 색을 덮어쓰지 않게
  -- css 는 개별 속성만(font: 같은 축약 X): DevTools 가 묶음의 개별 속성을 줄마다 복사한다
  -- 배경 묶음엔 padding-right:1px; margin-right:-1px: Chromium 이 묶음마다 픽셀을 맞춰 생기는 1px 틈을 덮는다
  -- 입력은 콘솔에 없어서 페이지의 숨긴 <textarea> 로 받는다
#611

ripgrep 은 질의마다 모든 파일을 열어 읽는다. tgrep 은 미리 만든 trigram 인덱스에서 후보 파일을 마이크로초 단위로 고르고, 후보만 열어 정규식으로 확인한다. 리눅스 커널에서는 후보가 전체 9만 6천 파일의 4~12% 였다. 그래서 파일 하나를 여는 비용이 비싼 Windows 와, 파일이 많은 큰 저장소에서 차이가 가장 크다. 대신 tgrep 은 서버와 클라이언트로 나뉘어 있어 결과 한 줄마다 직렬화하고 프로세스 사이로 보내고 다시 읽어 출력하는 배달비가 든다. 결과가 수만 줄이면 이 배달비가 인덱스로 아낀 것보다 커져 ripgrep 이 이긴다. 페이지 캐시가 따뜻한 리눅스에서는 ripgrep 의 병렬 스캔도 싸서 차이가 작다.

-- 질의 한 번의 비용. ripgrep 은 모든 파일을 열고, tgrep 은 고르는 데 거의 안 쓰고 후보만 연다
cost :: Tool -> Query -> Time
cost Ripgrep q = scanAll files q                                     -- 파일마다 열기·읽기·스캔. 찾은 줄은 스캔 스레드가 stdout 으로 바로
cost Tgrep   q = startup + rtt + lookup q + verify (candidates q) + deliver * matches q
  -- startup + rtt: 질의마다 새 클라이언트 프로세스 + 루프백 TCP 왕복 (벤치에 포함)
  -- lookup: 게시 목록이 파일 번호로 정렬돼 있어 정렬·중복 제거 없이 교집합 — AND 1만 파일 29μs, OR 64항 122μs
  --         마스크 두 바이트(이웃 자리 mod 8 · 다음 바이트 Bloom)가 확인 전에 한 번 더 거른다
  -- candidates: 커널 9.6만 파일에서 4~12% → 여는 파일 수가 한 자릿수 배로 준다
  -- deliver: 결과 한 줄마다 직렬화 → IPC → 역직렬화 → 출력. ripgrep 엔 없는 항
  -- 빠진 항: 인덱스 짓기(Go 3초 · Chromium 248초, macOS) — 한 번 내고 서버가 바뀐 것만 고친다. 벤치는 이걸 빼고 잰다

-- 그래서 차이를 움직이는 것 (행 순서 = 따지는 순서)
margin :: Query -> Repo -> Platform -> Effect
margin q _ _       | matches q `isTensOfThousands` = Flips    -- 배달비가 아낀 것보다 크다
                   | noUsefulTrigram q            = Shrinks  -- MatchAll: 전부 후보
margin _ _ Linux   = Shrinks                                   -- 따뜻한 페이지 캐시 + ripgrep 병렬 스캔이면 무작정 읽기도 싸다
margin _ _ Windows = Grows                                     -- 파일 하나 열기가 비싸 건너뛰는 이득이 어디서나 크다
margin _ r _       | largest r = Grows                         -- 파일이 많을수록 건너뛸 게 많다: Chromium 50만 · gecko 39만은 모든 플랫폼에서 이겼다
                   | otherwise = Shrinks                       -- 가장 작은 Go(1.6만)는 Linux 1.29x
  -- 2026-08-24 측정: 기하 평균 Windows 14.6x · macOS 8.61x · Linux 2.82x. 18칸 중 Kubernetes·Linux 만 0.93x
  -- 커널을 흔한 토큰(read · write)으로 쟀을 땐 후보가 4~12% 로 줄었는데도 0.74~0.95x 로 졌다
  --   → 실제로 쓸 법한 질의로 바꾸자 tgrep 49~128초 → 4.6~8.1초, ripgrep 은 그대로 33~46초 = 배달비만 따로 본 것
  -- 공용 러너 측정이라 같은 줄 안에서만 비교한다. macOS ripgrep 은 같은 질의도 385~550초로 흔들렸다
#610

아이디어를 실행할 권리를 얻는 수단이 바뀌었다. 실행이 비쌀 때는 조직이 아이디어에 걸어 보기 전에 지위부터 쌓아야 했고, 기획서와 동의와 디자이너·PM 시간을 구하는 승인 층을 넘어야 했다. 실행이 싸진 지금은 주말에 만든 돌아가는 프로토타입이 그 자리를 대신한다. 보면 기회와 이걸 끌고 갈 사람을 바로 알아보기 때문이다. 지위 없는 사람이 볼 수 있는 것이 있어서 이 변화가 그들에게 특히 크다. 순서는 회사가 이루려는 목표를 알고, 그 목표를 크게 당길 아이디어를 고르고, 주말에 만들고, 좋은 아이디어 하나만 담는 것이다.

-- 아이디어를 실행할 권리를 무엇으로 얻나
greenlight :: Era -> Idea -> Person -> Bool
greenlight ExpensiveExec _    p = status p >= enough     -- 몇 사람이 켜고 끄는 승인 층. 조직이 걸어 보기 전에 지위부터
greenlight CheapExec     idea _ = works (prototype idea)  -- 돌아가는 것을 보면 기회와 "끌고 갈 사람"을 바로 알아본다
  -- 왜 지위 없는 사람에게 특히 큰가: 고참이 더는 못 느끼는 어색함, 아무도 확인 안 한 "불가능"이 보인다
  -- "주니어"는 연차가 아니라 사회적 자본·지위·권한이 없는 사람이다

-- 그래서 백로그가 아니라 이것을 만든다
pitch :: Company -> Prototype
pitch = goals |> radical |> buildOverWeekend |> focusOne
  -- goals: 회사(큰 곳이면 내 그룹)가 실제로 이루려는 것. 높이는 내 매니저의 매니저가 가진 목표쯤
  -- radical: 되면 그 목표 달성 확률을 크게 올릴 아이디어 몇 개
  -- buildOverWeekend: 기획서 · 동의 구하기 · 디자이너·PM 시간 로비를 돌아가는 것으로 건너뛴다
  -- focusOne: 좋은 셋을 나쁜 스물 사이에 숨기지 않는다
  -- 내내: 사용자 쪽이면 바깥 사용자의 감각을, 인프라면 "불가능"한 이유를 배운 적 없다는 것을 쓴다

-- 다만 (원문이 비워 둔 곳): 프로토타입이 승인 층을 뚫는 근거는 "보면 안다" 한 줄이고, 사례는 이 방식을 보상하는 회사의 성공담뿐이다
--       고참의 "불가능"이 맞는 때도 있다 — 원문의 오프라인 모드 일화에서도 데이터 모델이 복잡하다는 판단은 맞았다
#609

스프레드시트 두 장이 지도 이야기 한 편이 된다. Options 탭은 제목·배경 지도 같은 설정, Chapters 탭은 장마다 한 줄이다. 저장소의 csv 폴더에 두 파일이 있으면 그걸 읽고, 없으면 Google Sheets API 로 두 탭을 받는다. 장 한 줄은 왼쪽 글 블록 하나와, 좌표가 있으면 지도 마커 하나가 된다. 처음에 블록 높이를 재서 장마다 시작 위치를 누적해 둔다. 글을 스크롤하면 지금 위치가 어느 장의 구간에 드는지 찾아, 그 장의 마커를 강조하고 덧씌운 레이어를 바꾸고 그 좌표로 2초 동안 날아간다. 다음 장 시작 140px 전부터는 어느 장 구간도 아니라 지금 장이 그대로다. 반대로 마커를 누르면 글이 그 장으로 스크롤된다.

-- ① 읽기: 시트 두 장 — Options(설정) · Chapters(한 줄 = 한 장)
load :: IO ([Row], [Row])
load = csv "csv/Options.csv" "csv/Chapters.csv"          -- 저장소에 CSV 가 있으면 먼저
   <|> sheetsV4 apiKey sheetId ["Options", "Chapters"]   -- 없으면 values/<탭>?key= · 첫 줄이 열 이름

settings :: [Row] -> Map Label String
settings = fromList . map (\r -> (r ! "Setting", r ! "Customize"))
  -- 코드는 constants.js 를 거쳐 읽는다: _mapTitle → 'Storymap Title'. 비어 있으면 기본값

-- ② 그리기: 한 줄 → 글 블록 하나 + (좌표가 있으면) 마커 하나
chapter :: Row -> (Block, Maybe Marker)
  -- Marker 열: Numbered → 번호 · Plain → 빈 아이콘 · Hidden → 투명·클릭 안 됨 · 그 밖 → 그 글자
  -- Media Link: youtube.com → iframe · jpg·png·gif·tiff → img · mp3·ogg·wav → audio

-- ③ 스크롤 → 지금 장. 블록 높이는 처음 한 번 재서 누적한다
top :: [Px]
top = scanl (\y h -> y + h + 70) (-100) heights ++ [maxBound]

chapterAt :: Px -> Maybe Int
chapterAt y = find (\i -> top !! i <= y && y < top !! (i + 1) - 140) [0 ..]
  -- 다음 장 시작 140px 전부터는 어느 장도 아니다 → 지금 장이 그대로 남는다

onFocus :: Int -> [Effect]
onFocus i = [ Hash (i + 1), InFocus i, MarkerActive i
            , RemoveOverlays, Overlay (c ! "Overlay"), GeoJson (c ! "GeoJSON Overlay")
            , FlyTo (lat c, lon c) (zoom c `orElse` 15) 2 ]
  where c = chapters !! i
  -- Overlay: .geojson 이면 GeoJSON, 아니면 타일 URL 로 본다
  -- GeoJSON Feature Properties 칸은 "color: red; weight: 2" 를 파싱한다. 스타일은 feature 값 → 이 칸 → 기본값 순

-- 반대 방향: 마커를 누르면 글이 top !! i + 5 로 스크롤된다
-- 처음: 모든 마커로 fitBounds. URL 에 #n 이 있으면 n 번째 장으로 스크롤한다
#608

Freeze 는 바깥부터 Fragment, Suspense, 그 안의 Suspend 와 children 으로 되어 있다. frozen 이 되면 Suspend 가 끝나지 않는 promise 로 Suspense 를 중단시킨다. 그러면 React 는 안쪽을 계속 렌더하지만 DOM 에 커밋하지 않아, 팝오버가 사라지는 동안 내용이 닫기 직전 모습 그대로 멈춘다. 한 번의 커밋 안에서 React 는 자식을 먼저 처리하므로, Suspense 가 바로 아래 요소에 display none 을 붙이고 안쪽의 layout effect 를 정리하고 ref 를 뗀 다음에 Freeze 의 insertion effect 가 돌아 display 를 되돌린다. 숨긴 모습은 한 번도 그려지지 않는다. 되돌릴 요소는 Fragment ref 에 가짜 관찰자를 넣어 미리 모아 둔다. 풀리면 쌓여 있던 최신 렌더가 한 번에 커밋된다.

-- 닫기와 내용 변경(안내 문구, 고른 항목 맨 위로)이 한 배치로 커밋되면 사라지는 중에 내용이 바뀐다
-- → 퇴장 중엔 커밋을 멈춘다. Suspense 를 빌리고, 딸려 오는 숨김만 걷어낸다
freeze :: Bool -> Tree -> Dom -> Dom
freeze False t _   = commit t                    -- 평소: 렌더한 대로 커밋
freeze True  _ old = unhide (suspend old)        -- 얼림: 렌더는 계속, 커밋은 안 함 → 닫기 직전 모습

-- Suspense 가 중단되면 하는 일 셋 — 앞의 둘은 그대로 쓰고, 셋째만 되돌린다
suspend :: Dom -> Dom
suspend = keepState . skipCommit . hide
  -- {frozen && <Suspend />}: 모듈에 하나 둔 끝나지 않는 promise 를 use → 계속 중단
  -- hide: 바로 아래 요소에 display: none !important, 텍스트는 nodeValue = '', layout effect 정리·ref 떼기

unhide :: Dom -> Dom
unhide = mapElems (\el -> el { display = "" })
  -- 언제: useInsertionEffect. 커밋은 자식 먼저라 Suspense 가 숨긴 직후 같은 커밋 안에서 돈다 → 숨긴 모습이 안 그려진다
  -- 누구를: <Fragment ref> 의 observeUsing 에 가짜 관찰자를 넣어 바로 아래 요소를 Set 으로 모은다
  --         (붙으면 observe · 빠지면 unobserve 가 다시 불린다)
  -- deps 는 [frozen]: React 가 다시 숨기는 건 보임↔숨김이 바뀔 때뿐이다

-- 풀릴 때: 쌓인 최신 렌더가 한 번에 커밋되고, display 는 style prop 의 값(없으면 '')으로 돌아온다
-- 쓰는 쪽: <Popover>{({ isExiting }) => <Freeze frozen={isExiting}>…</Freeze>}</Popover> (React Aria)
--          React 상태로 그리는 hover·press·focus 도 같이 언다. CSS :hover 는 안 언다
-- 버린 길: 닫기 전 상태를 저장 → 다시 그리게 하는 상태를 전부 챙겨야 한다
--          onOpenChangeComplete 로 업데이트를 미룸 → 퇴장이 중간에 끊기면 복잡하다
-- 다만: observeUsing 은 react-dom 19.3 부터다(19.2.0 엔 없다). ref cleanup·use 도 19
--       텍스트 자식은 되돌리지 않아 얼어 있는 동안 비어 보인다
--       퇴장 중엔 ref 가 떨어져 있어 ref 로 재거나 포커스를 다루는 코드는 못 돈다
--       원래 인라인 display 를 지운다 · React 내부 동작에 기댄 트릭이다
#607

원작 .exe 에서 기능을 찾을 때는 손에 쥔 실마리에 따라 길을 고른다. 화면 문구를 알면 EXE 안의 그 문구 바이트를 찾고, 그 주소를 참조하는 코드를 찾아 함수로 바로 간다. 값을 알면 지금 값을 가진 메모리를 전부 잡아 두고 게임을 한 걸음 진행해 바뀐 것만 남긴다. 값을 모르는 화면 상태는 들어갈 때 바뀐 바이트와 나올 때 바뀐 바이트의 교집합으로 좁힌다. 배열은 비슷한 값이 일정 간격으로 도시 수만큼 늘어선 곳으로 찾는다. 소스 없는 남의 플러그인 바이너리에서는 박혀 있는 주소를 긁는다. 데이터 주소를 얻으면 그 주소를 쓰는 코드를 잡아 함수로 간다. 함수는 디스어셈블해 읽고, 어떻게 찾았는지와 틀렸던 해석까지 함수 주소를 이름에 붙인 노트에 적은 뒤, 근거 주소를 주석에 달아 옮긴다.

-- 원작 .exe 에서 "그 기능이 어디 있나"를 찾는다. 손에 쥔 실마리에 따라 길을 고른다
locate :: Clue -> Addr
locate (Text s)        = refs (le32 (find (cp949 s) dotData)) dotText
  -- 한국어 문구는 EXE 에 CP949 그대로 있다. 그 VA 를 .text 에서 4바이트 리터럴로 찾는다
  -- "값을 깎는다" @0x532890 → 참조 한 곳 0x481211 → 흥정 함수 0x4811E0
locate (Known v next)  = diff (snapshot (== v)) (after next (== v + 1))
  -- 날짜 19일인 바이트를 전부 잡고 → 여관에서 하루 → 20 이 된 것만, 근처에 년·월이 있는지 대조
  -- → 년·월·일 = 0x5A4D20/24/28 (i32 셋)
locate (Toggle a b)    = changed a b ∩ changed b a
  -- 값을 모르는 상태(지금 어느 화면인가): 메모리 전체 스냅샷 → 화면 A→B 에서 바뀐 것 ∩ B→A 에서 바뀐 것
locate (Array lo hi n) = longestRun (\x -> lo <= x && x <= hi) n
  -- 한 값은 노이즈지만, 시세 90~105 가 같은 간격으로 도시 수(226)만큼 늘어선 곳은 거의 하나다
  -- → 도시 구조체 0x5863B4, stride 92
locate (Plugin bin)    = immAfter (cmp eax version) bin
  -- 소스 없는 남의 .plugin: 버전을 4바이트로 묶어 CMP EAX,imm32 한 번에 비교한다
  -- 그 분기 안 MOV [x],imm32 · MOV reg,[addr] 에 게임 주소가 그대로 박혀 있다 (일본판 기준)

-- 데이터 주소 → 그걸 쓰는 코드 → 함수
toFunc :: Addr -> Func
toFunc a = enclosing (writers a ++ refs (le32 a) dotText)
  -- 런타임: Cheat Engine "find what writes/accesses" — 커널 디버거라 게임이 안 죽는다
  -- 정적: .text 에서 4바이트 검색. 예: 지금 도시 0x5B6154 를 쓰는 세 곳 앞이
  --       전부 call 0x49E3E0 ; cmp eax,2 → "들어가겠습니까?" 대화상자
  -- 상수도 앵커가 된다: 숙박 +30일 → 0x1E 를 쓰는 명령 중 날짜·소지금 주소 근처

-- 함수 하나 = 노트 하나 (note/TradeBargain-0x4811E0.md)
note :: Func -> Note
note f = Note { target    = "한국어판 CDS_95.EXE 1.2.0.0 · MD5 · ImageBase · 섹션"
              , howFound  = "찾은 길"
              , signature = "__thiscall int(Ctx*, int* price, int* outMode), ret 8"
              , tables    = "구조체 오프셋 · 반환값 매핑"
              , mistakes  = "처음엔 0x4A17F0 을 Player() 로 읽었다. 틀렸다" }
  -- 옮길 때 주석에 근거 주소(0x004xxxxx)를 달고 문구는 원본 그대로. 원본의 흠(안 걸리는 조건)도 그대로 두고 적는다
  -- 여러 함수를 훑어야 하는 화면 한 벌은 서브에이전트에 맡긴다: 정확한 주소·식·문구·표 값·부르는 곳

-- 밟은 것
--   문구가 서식으로 쪼개져 있으면 못 찾는다: "항구로" ✕ ← "[%s]의 %s%s 들어가겠습니까?" → 아는 주소에서 거꾸로
--   일본판(1.4.0.0)과 한국어판(1.2.0.0)은 주소가 전혀 다르다 → 노트마다 기준 EXE 를 맨 위에
--   세이브는 u16 년 + u8 월·일, 메모리는 i32 셋 → 세이브 오프셋에서 유도한 주소 가설은 전부 틀렸다
--   직접 짠 유저모드 HW 브레이크포인트(DR0/DR7)는 WOW64 게임을 죽였다 → 폐기하고 CE 를 Lua 로 자동화
--   대사가 하나 같아도 말투 셋·부관 유무 둘로 여러 벌인 때가 많다 → 문자열 앞뒤를 훑어 짝을 찾는다
#606

브라우저 밖에서 PDF 의 텍스트나 이미지를 꺼내려고 PDF.js(pdfjs-dist)를 직접 쓰면 할 일이 따라온다. 워커 경로를 맞추거나 워커를 꺼야 하고, Node 에서는 legacy 빌드를 쓰라는 경고가 나오고, Cloudflare Workers 에는 PDF.js 가 쓰는 전역이 없고 실행 중 WASM 컴파일이 막혀 있으며, 이미지 디코더 WASM 을 URL 로 서빙해야 하고, 텍스트는 페이지를 돌며 조각을 이어 붙여야 한다. unpdf 는 이걸 미리 해둔 PDF.js 번들과 함수를 준다. import 하고 extractText 한 줄이면 된다.

-- 브라우저 밖에서 PDF 텍스트·이미지를 꺼낼 때, pdfjs-dist 를 직접 쓰면 따라오는 배관 → unpdf 에선
chore :: Obstacle -> (PdfjsDist, Unpdf)
chore Worker     = ("workerSrc 를 맞추거나 워커를 끈다",       "워커를 번들에 넣어 같은 스레드에서 돌린다")
chore NodeBuild  = ("\"legacy 빌드를 쓰라\" 경고",             "경고를 지우고, 빠진 최신 API 는 폴리필")
chore WorkersEnv = ("FinalizationRegistry·navigator 가 없다",  "PDF.js 보다 먼저 전역을 채운다")
chore WorkersWasm= ("실행 중 WASM 컴파일이 막혀 있다",          "JBIG2·JPEG 2000 디코더를 JS 판으로")
chore Decoders   = ("디코더 WASM 을 URL(wasmUrl)로 서빙한다",  "번들 조각으로 넣어두고 필요할 때만 불러온다")
chore TextLoop   = ("페이지를 돌며 텍스트 조각을 잇는다",       "extractText pdf { mergePages = True }")
  -- 나머지도 함수 하나씩: extractImages(PNG) · renderPageAsImage · inspectPages(스캔 페이지 → OCR 판단) · 링크 · 메타
  -- getDocumentProxy 로 한 번 열어 여러 함수에 넘기면 다시 파싱하지 않는다

-- 그래서 고르는 법
pick :: Need -> Where -> Library
pick (Create _) _   = Other              -- 꺼내기·그리기만 한다: 만들거나 고치는 함수가 없다
pick (Edit _)   _   = Other
pick _ Browser      = Either             -- pdfjs-dist 는 워커로 따로 돌고, unpdf 번들은 내 스레드에서 돈다
pick _ _            = Unpdf              -- Node 24+ · Bun · Cloudflare Workers. pdf-parse 의 대안 (README)

-- 대가: 워커가 없으니 파싱이 내 이벤트 루프에서 돈다 → 추출 호출을 타임아웃과 경주시킨다 (README)
-- 페이지를 이미지로 그리려면 @napi-rs/canvas 를 따로 설치한다 (선택적 peerDependency)
-- 다른 PDF.js(버전 고정 등)를 쓰려면: definePDFJSModule (\_ -> import "pdfjs-dist/legacy/build/pdf.mjs")
#605

WebSocket 은 별도 핸드셰이크로 여는 양방향 연결이고, SSE 는 서버가 text/event-stream 으로 계속 내보내는 평범한 HTTP 응답이라 서버에서 클라이언트로 한 방향만 간다. SSE 는 UTF-8 텍스트만 나르고, 끊기면 브라우저가 알아서 다시 연결하며 마지막 이벤트 id 를 기억한다. 이벤트에 이름을 붙일 수 있다. 대신 HTTP/1.1 에서는 브라우저와 도메인마다 연결이 6개로 묶이고, HTTP/2 에서는 기본 100개까지다. WebSocket API 는 역압이 없어 받는 속도를 못 따라가면 메모리에 쌓이고, 열린 연결이 있으면 뒤로 가기 캐시에서 빠질 수 있다. 가장 큰 갈림은 쓰기다: SSE 는 쓰기를 Fetch 로 따로 보내 같은 화면을 고치는 줄이 둘이 되고, 두 줄은 서로 경주해 순서가 깨진다. WebSocket 은 한 줄이라 내 요청과 응답의 순서가 지켜지고, 연결을 한 번만 인증한다.

-- 행 = 비교 항목, 값 = (WebSocket, SSE). "—" 는 출처가 말하지 않은 칸
versus :: Aspect -> (WebSocket, SSE)
versus Direction    = ("양방향",                       "서버 → 클라이언트만")
versus Wire         = ("Sec-WebSocket-* 핸드셰이크",   "평범한 HTTP 응답, text/event-stream")
versus Payload      = ("—",                            "UTF-8 텍스트만")
versus Reconnect    = ("—",                            "끊기면 자동 재연결, retry: ms, id: 로 마지막 이벤트 id 기억")
versus Events       = ("message",                      "event: 로 이름 붙인 이벤트, ':' 주석 줄로 타임아웃 방지")
versus Connections  = ("—",                            "HTTP/1.1 은 브라우저+도메인당 6 (Chrome·Firefox Won't fix), HTTP/2 는 협상·기본 100")
versus Backpressure = ("없음: 못 따라가면 메모리에 쌓인다 → WebTransport", "—")
versus Bfcache      = ("열린 연결이 있으면 빠질 수 있다 → 다 쓰면 닫는다", "—")

-- 여기부터 Valim: 진짜 갈림은 성능이 아니라 순서다
versus Writes       = ("같은 연결로",                  "Fetch 로 따로")
versus Ordering     = ("한 줄: 요청·응답 순서가 공짜", "두 줄이 경주한다 — 둘 사이엔 인과 순서가 없다")
versus PerRequest   = ("연결을 한 번 인증, 사용자는 메모리에", "Fetch 마다 세션 복호화·사용자 조회를 다시")

-- 원인은 SSE 가 아니라 줄 수다: WebSocket 이어도 쓰기를 Fetch 로 하면 두 줄이다
ordered :: Setup -> Bool
ordered setup = streams setup == 1

-- 두 줄인 채로 맞추려면 값을 치른다
cost :: Fix -> Cost
cost WritesViaStream = ExtraHops            -- 내 쓰기를 큐로 서버 사이를 돌려 SSE 로 받는다 → 지연↑
cost RefetchOnNotify = ServerLoad <> Queue  -- 알림 오면 다시 가져오기 → 부하↑, 동시 fetch 를 막으려 줄 세운다
cost ClientReorder   = HarderThanItLooks    -- 삭제가 생성보다 먼저 올 수 있다, 갱신 순서가 DB 순서라는 보장도 없다
#604

transform 은 CSS 를 네 단계로 TypeScript 모듈로 바꾼다. 먼저 파싱하고, 문법 오류가 있으면 진단을 남긴 뒤 관대한 파서로 다시 읽는다. 다음으로 내보낼 이름(클래스, id, keyframes, @value, :export 키)을 모으면서 CSS 에 적힌 위치를 같이 적는다. 그다음 이름을 설정에 따라 camelCase 같은 키로 바꾼다. 마지막으로 TypeScript 를 써 내려가면서, 키를 하나 쓸 때마다 그 자리를 원본 CSS 의 이름 자리에 잇는 대응 한 칸을 남긴다. 키와 원본 이름의 글자가 달라도 hover 와 정의로 가기는 CSS 의 그 이름으로 간다.

-- TS 7 content mapper 가 transform 요청을 받으면: CSS 모듈 → TS 모듈 + 대응표 + 진단
transform :: Options -> Content -> Result
transform opts = stripBom >>> parse >>> collectLocals >>> exportsOf (localsConvention opts)
             >>> render opts >>> shiftBom
  -- BOM: postcss 가 떼므로 그만큼 원본 위치·진단 위치를 다시 민다

-- ① 오타 하나가 이 파일을 import 하는 모든 곳을 깨지 않게
parse :: CSS -> (Root, [Diagnostic])
parse css = case postcss css of
  Right root -> (root, [])
  Left err   -> (safeParse css, [syntaxError err])   -- 진단을 남기고 살릴 수 있는 만큼 살린다

-- ② 내보낼 이름과, CSS 에 적힌 그 이름의 위치 (escape 포함) — 이 위치가 ④의 대응 끝점이다
locals :: Node -> [Local]
locals (Rule ":export" decls)       = map prop decls          -- ICSS: 키 그대로
locals (Rule sel) | inKeyframes     = []                      -- from·to·50% 는 이름이 아니다
                  | otherwise       = classesAndIds sel       -- :global(…) 안은 빼고, 인자 없는 :global 은 뒤쪽 전부를 뺀다
locals (AtRule "keyframes" name)    = [name]                  -- :global 이면 없음
locals (AtRule "value" params)      = valueNames params       -- @value a: …  /  @value a, b as c from "…"
locals (AtRule "scope" params)      = parenthesized params >>= classesAndIds   -- @scope (.card) to (.content)
locals (Decl "composes" v)          = []                      -- 대신 검사: 이 파일에 없는 클래스면 진단, from 이 붙으면 건너뜀
  -- 같은 이름은 처음 것만. hover 문서 = 앞의 /** */ 주석 + 선언 CSS (12줄까지)

-- ③ 이름 → 키. Vite 의 css.modules.localsConvention 과 같은 값
keys :: Convention -> Name -> [Key]
keys CamelCase     n = [n, camelCase n]          -- camelCase = lodash.camelcase (postcss-modules 와 같게)
keys CamelCaseOnly n = [camelCase n]
keys Dashes        n = [n, dashesCamelCase n]    -- 대시 뒤 글자만 대문자로
keys DashesOnly    n = [dashesCamelCase n]
keys _             n = [n]

-- ④ TS 를 써 내려가다 키를 쓰는 순간, 그 자리를 원본 이름 자리에 잇는다
emitKey :: Key -> Local -> Writer (Text, [SpanMapping]) ()
emitKey key local = do
  here <- length <$> text
  tell ( key
       , [(here, length key, start local, length local, Alias, Hover .|. Definition .|. References .|. DocumentHighlights)] )
  -- Alias: 키(btnPrimary)와 원본(btn-primary)이 달라도 에러·정의로 가기는 원본 이름에 붙는다

render :: Options -> [(Key, Local)] -> (Text, [SpanMapping])
render opts exports =
     [ "declare const styles: { readonly " <> emitKey k l <> ": string; … }; export default styles;" | defaultExport opts ]
                                                     -- 식별자가 아닌 키는 "btn-primary" 문자열 키로
                                                     -- styles 라는 키가 있으면 바인딩을 _styles 로
  <> [ "export declare const " <> emitKey k l <> ": string;" | namedExports opts, isBindingName k ]
                                                     -- 식별자이고 예약어가 아닐 때만
  `orElse` "export {};"                              -- 내보낼 게 없어도 모듈이어야 한다
#603
24 중 1페이지