@lemondouble/lemon-auth 0.7.3 → 0.9.0

package/README.md

@@ -23,7 +23,7 @@ NEXT_PUBLIC_LEMON_AUTH_MOCK_USER='{"uid":"local-user","nickname":"Local User","p
 Mock User가 활성화되면:
 
 - `getUser()`, `getSession()`, `requireAuth()`, `requireClient()`는 mock user를 로그인 유저처럼 반환합니다.
-- `createAuthProxy()`는 mock user를 인증 성공으로 처리하고, `clientId` 승인 체크는 유지합니다.
+- `createAuthProxy()`는 모든 요청을 통과시킵니다. 승인 체크는 DAL에서 수행됩니다.
 - `loginUrl(redirectUrl)`은 `redirectUrl`을 그대로 반환합니다.
 - `profileUrl(redirectUrl?)`은 `redirectUrl ?? "/"`를 반환합니다.
 - `refreshToken()`은 `true`, `logout()`은 no-op 후 `true`를 반환합니다.
@@ -34,7 +34,7 @@ Mock User가 활성화되면:
 |------|------|------|
 | `@lemondouble/lemon-auth/server` | Server Components, Route Handlers, Server Actions | JWT 검증, 유저 조회, 인증 체크 |
 | `@lemondouble/lemon-auth/client` | Client Components | AuthProvider, useAuth 훅, URL 헬퍼 |
-| `@lemondouble/lemon-auth/proxy` | proxy.ts | 토큰 자동 갱신 프록시 |
+| `@lemondouble/lemon-auth/proxy` | proxy.ts | 쿠키 기반 optimistic check |
 
 ---
 
@@ -188,32 +188,6 @@ export default async function Page() {
 | `options.loginRedirectTo` | `string` | `"/"` | 미인증 시 redirect 경로 |
 | `options.unapprovedRedirectTo` | `string` | `undefined` | 로그인은 됐지만 클라이언트 미승인 시 redirect 경로. 미설정 시 auth-server `/error?code=FORBIDDEN`로 redirect (proxy 동작과 동일) |
 
-### `refreshTokenFromCookie(refreshTokenCookie, deviceIdCookie?)`
-
-서버사이드에서 토큰 갱신을 수행합니다. Route Handler 등에서 수동으로 갱신할 때 사용합니다.
-
-```ts
-import { refreshTokenFromCookie } from "@lemondouble/lemon-auth/server";
-
-export async function POST(request: Request) {
-  const cookieStore = await cookies();
-  const refreshToken = cookieStore.get("lemon_refresh_token")?.value;
-  const deviceId = cookieStore.get("device_id")?.value;
-  if (!refreshToken) return new Response(null, { status: 401 });
-
-  const result = await refreshTokenFromCookie(refreshToken, deviceId);
-  // result: { ok: boolean, setCookieHeaders: string[] }
-
-  if (!result.ok) return new Response(null, { status: 401 });
-
-  const response = new Response(null, { status: 200 });
-  for (const header of result.setCookieHeaders) {
-    response.headers.append("Set-Cookie", header);
-  }
-  return response;
-}
-```
-
 ### 상수
 
 서버 엔트리포인트에서 모든 상수를 re-export합니다.
@@ -237,7 +211,20 @@ import {
 
 ## Proxy — `@lemondouble/lemon-auth/proxy`
 
-Next.js 16의 `proxy.ts`에서 사용합니다. 보호 경로 접근 시 JWT 검증 + 만료 임박 토큰 자동 갱신을 처리합니다.
+Next.js 16의 `proxy.ts`에서 사용합니다. **쿠키만 읽는 optimistic check** 만 합니다.
+
+> 프록시는 토큰을 갱신하지 않고 JWT 서명도 검증하지 않습니다. 갱신은
+> `<SessionRestore />`(브라우저)가 유일하게 맡고, 진짜 검증은
+> DAL(`getSession` / `requireClient`)이 합니다. 마이그레이션은
+> [0.8.x → 0.9.0](#08x--090-마이그레이션) 참고.
+
+Next.js 공식 인증 가이드의 권장 구조를 그대로 따릅니다.
+
+> since Proxy runs on every route, including prefetched routes, it's important to
+> only read the session from the cookie (optimistic checks), and avoid database
+> checks to prevent performance issues.
+>
+> — [Next.js — Authentication](https://nextjs.org/docs/app/guides/authentication)
 
 ### `createAuthProxy(options?)`
 
@@ -248,9 +235,7 @@ import { createAuthProxy } from "@lemondouble/lemon-auth/proxy";
 export default createAuthProxy({
   publicPaths: ["/", "/about", "/api/public/*"],
   bypassPaths: ["/workbox-*"],
-  clientId: process.env.CLIENT_ID,
   loginRedirectUrl: (request) => request.url,
-  unapprovedRedirectUrl: "/pending-approval",
 });
 
 export const config = {
@@ -264,28 +249,41 @@ export const config = {
 
 | 옵션 | 타입 | 기본값 | 설명 |
 |------|------|--------|------|
-| `publicPaths` | `string[]` | `[]` | 인증 없이 접근 가능한 경로. `*`로 끝나면 prefix 매칭 (예: `"/api/public/*"`) |
-| `bypassPaths` | `string[]` | `[]` | proxy가 refresh도 하지 않고 바로 통과시킬 추가 경로. 기본 PWA 경로(`/sw.js`, `/manifest.webmanifest` 등)는 항상 bypass |
-| `apiPaths` | `string[]` | `["/api/*"]` | 보호 API 경로. 인증 실패 시 redirect 대신 JSON 응답을 반환한다. disable하려면 `[]` |
-| `clientId` | `string` | `undefined` | 설정 시 `approved_clients`에 포함 여부를 체크 |
+| `publicPaths` | `string[]` | `[]` | 로그인 없이 열어둘 경로. 익명이면 통과, 만료 세션이면 복구를 거친다. `*`로 끝나면 prefix 매칭 (예: `"/api/public/*"`) |
+| `bypassPaths` | `string[]` | `[]` | proxy가 아무 판단 없이 통과시킬 추가 경로. 기본 PWA 경로(`/sw.js`, `/manifest.webmanifest` 등)는 항상 bypass |
+| `apiPaths` | `string[]` | `["/api/*"]` | 보호 API 경로. 인증 실패 시 redirect 대신 401 JSON을 반환한다. disable하려면 `[]` |
 | `loginRedirectUrl` | `string \| (request: NextRequest) => string` | `undefined` | 미인증 시 Google 로그인 후 돌아올 URL. deep link 보존이 필요하면 `(request) => request.url` 사용. 미설정 시 `"/"` 로 redirect |
-| `unapprovedRedirectUrl` | `string \| (request: NextRequest) => string` | `undefined` | 로그인은 됐지만 `clientId` 미승인일 때 redirect할 URL. 미설정 시 auth-server `/error?code=FORBIDDEN`로 redirect (무한 loop 방지) |
-| `onAuthSuccess` | `(claims, request, response) => Promise<NextResponse> \| NextResponse` | `undefined` | 보호 경로에서 인증 성공 시 호출되는 콜백. DB 동기화, 헤더 주입 등 앱별 로직에 사용 |
+| `restorePath` | `string` | `"/auth/restore"` | `<SessionRestore />` 를 마운트한 경로. 프록시가 자동으로 통과시키므로 `publicPaths` 에 넣지 않아도 된다 |
 
 #### 동작 방식
 
-**Bypass 경로** (기본 PWA/정적 리소스 + `bypassPaths`):
-
-1. `/sw.js`, `/manifest.webmanifest`, `/manifest.json`, `/favicon.ico` 등은 인증/갱신 없이 항상 통과
-2. 가능하면 `matcher`에서도 제외해 proxy 실행 자체를 피하는 것을 권장
-
-**보호 경로** (`publicPaths`에 해당하지 않는 경로):
-
-1. `lemon_access_token` 쿠키가 있고 만료까지 60초 이상 남았으면 → JWKS 검증 → `onAuthSuccess` 호출 → 통과
-2. 로그인은 됐지만 `clientId` 미승인이면 `unapprovedRedirectUrl`로 redirect
-3. 만료 임박이거나 검증 실패 시 `lemon_refresh_token` + `device_id`로 자동 갱신 시도
-4. 갱신 성공 → 새 토큰 쿠키 설정 → `onAuthSuccess` 호출 → 통과
-5. 갱신 실패 → `loginRedirectUrl`을 `redirect_url`로 담아 로그인 페이지로 redirect
+요청은 위에서부터 순서대로 판정됩니다.
+
+1. `restorePath` → 통과 (여기서 복구 경로로 보내면 무한 루프)
+2. bypass 경로 (기본 PWA/정적 리소스 + `bypassPaths`) → 통과
+3. `lemon_access_token` 이 있고 만료까지 60초 이상 → 통과
+4. — 여기부터는 만료된 요청 —
+   `apiPaths` 매칭 → 공개 경로면 통과, 아니면 `401 { code: "UNAUTHORIZED" }`
+5. 비-GET 요청 (서버 액션 등) → 통과. 리다이렉트하면 액션 프로토콜이
+   깨지므로, DAL 이 거부하게 둡니다
+6. `lemon_refresh_token` 있음 → `restorePath?next=<원래 경로>` 로 redirect.
+   **공개 경로도 포함입니다**
+7. 공개 경로 → 통과 (익명 방문자)
+8. 나머지 → `loginRedirectUrl` 을 담아 로그인 페이지로 redirect
+
+공개 경로도 만료 세션이면 복구를 거치는 이유: 그냥 통과시키면 "로그아웃
+상태로 렌더됐다가 갱신 후 뒤집히는" 화면이 되고, 그걸 가리려는 우회 코드가
+앱마다 생깁니다. 복구를 거치면 처음부터 로그인 상태로 렌더됩니다.
+
+**프리페치 요청**: 다른 요청과 똑같이 처리합니다. 통과시키면 만료된 토큰으로
+페이지가 렌더되고 거기서 나온 redirect 가 라우터 캐시에 굳어, 어느 링크를 눌러도
+같은 곳으로 튀게 됩니다. 반면 프록시가 돌려주는 `restorePath` 리다이렉트는 굳어도
+해가 없습니다 — 복구 경로는 막다른 길이 아니라 세션을 되살리고 `next` 로
+되돌려 보내므로 목적지도 보존됩니다.
+
+`exp` 만 보고 **서명은 검증하지 않습니다.** 위조 토큰으로 이 검사는 통과할 수
+있으나 DAL 에서 걸립니다. 프록시의 판단은 "어느 화면으로 보낼까" 이지
+"권한이 있는가" 가 아닙니다. 권한 판단은 반드시 DAL 에서 하십시오.
 
 `loginRedirectUrl`은 고정 URL 문자열과 요청별 resolver 함수를 모두 지원합니다.
 
@@ -301,14 +299,33 @@ createAuthProxy({
 });
 ```
 
-**공개 경로** (`publicPaths`에 해당하는 경로):
+### 0.8.x → 0.9.0 마이그레이션
+
+갱신 주체가 `<SessionRestore />` 하나로 통일되고, 실패 처리가 서버로
+넘어갔습니다. **auth-server v2026.08.03.2 이상이 먼저 배포되어 있어야 합니다**
+— 죽은 토큰의 401 응답이 세션 쿠키를 지워주는 동작에 의존합니다.
+
+**1. `<AutoTokenRefresh />` 제거** — export 자체가 사라졌습니다. 루트
+레이아웃에서 마운트와 import 를 지웁니다. 공개 경로의 만료 세션은 이제
+프록시가 복구 경로로 보내 처리합니다.
 
-1. 토큰이 만료 임박이면 백그라운드로 갱신 (실패해도 통과)
-2. 인증 여부와 무관하게 항상 통과
+**2. `publicPaths` 에서 복구 경로 제거** — `restorePath` 는 프록시가 자동으로
+통과시킵니다. 남겨둬도 해는 없지만 필요 없습니다.
 
-**API 경로** (`apiPaths` 매칭, 기본 `/api/*`):
+**3. `refreshTokenFromCookie` 제거** — 서버사이드 갱신 진입점이 사라졌습니다.
+갱신은 브라우저(`<SessionRestore />`)만 합니다.
 
-보호 경로 중 `apiPaths`에 매칭되는 요청은 인증 실패 시 redirect 대신 JSON 응답을 반환합니다. fetch 호출이 OAuth HTML로 리다이렉트되어 계약이 깨지는 문제를 방지합니다.
+**4. `<SessionRestore failedRedirectUrl>` prop 제거** — 실패해도 `next` 로
+돌아갑니다. 죽은 토큰의 쿠키는 서버가 지워주므로, 이후 판단(로그인/익명)은
+프록시와 DAL 이 합니다.
+
+**5. 공개 페이지의 "복구 중" 우회 코드 제거** — 공개 경로도 만료 세션이면
+복구를 거친 뒤 처음부터 로그인 상태로 렌더되므로, refresh 쿠키 유무를 보고
+스피너를 띄우던 코드는 필요 없습니다.
+
+### API 경로
+
+보호 경로 중 `apiPaths`(기본 `/api/*`)에 매칭되는 요청은 인증 실패 시 redirect 대신 JSON 응답을 반환합니다. fetch 호출이 OAuth HTML로 리다이렉트되어 계약이 깨지는 문제를 방지합니다.
 
 | 상황 | 응답 |
 |------|------|
@@ -390,46 +407,44 @@ export function Nav() {
 }
 ```
 
-### `<AutoTokenRefresh>`
+### `<SessionRestore>`
 
-PWA 환경에서 service worker 캐시로 인해 proxy가 실행되지 않는 경우를 대비합니다.
-`AuthProvider`의 `user`가 null일 때만 토큰 갱신을 시도하고, 성공하면 `router.refresh()`로 서버 컴포넌트를 다시 렌더합니다.
+**토큰을 갱신하는 유일한 주체입니다.** 프록시가 만료된 세션을 이리로 보내고,
+갱신이 끝나면 `next` 파라미터가 가리키는 곳으로 **하드 네비게이션**
+(`window.location.replace`) 합니다. 소프트 네비는 루트 레이아웃과
+`AuthProvider` 를 다시 렌더하지 않아, 옛 세션 스냅샷이 남은 채 화면이
+어긋나기 때문입니다.
 
 ```tsx
-// app/layout.tsx
-import { getUser } from "@lemondouble/lemon-auth/server";
-import { AuthProvider, AutoTokenRefresh } from "@lemondouble/lemon-auth/client";
+// app/auth/restore/page.tsx
+import { Suspense } from "react";
+import { SessionRestore } from "@lemondouble/lemon-auth/client";
 
-export default async function RootLayout({ children }: { children: React.ReactNode }) {
-  const user = await getUser();
+export const dynamic = "force-dynamic";
+
+export default function RestorePage() {
   return (
-    <html lang="ko">
-      <body>
-        <AuthProvider user={user}>
-          <AutoTokenRefresh fallback={<p>세션 복원 중...</p>}>
-            <p>로그인이 필요합니다</p>
-          </AutoTokenRefresh>
-          {children}
-        </AuthProvider>
-      </body>
-    </html>
+    <Suspense fallback={null}>
+      <SessionRestore fallback={<p>세션 복원 중...</p>} />
+    </Suspense>
   );
 }
 ```
 
 | prop | 타입 | 필수 | 설명 |
 |------|------|------|------|
-| `fallback` | `React.ReactNode` | **필수** | 토큰 갱신 시도 중 렌더할 UI (스피너 등) |
-| `children` | `React.ReactNode` | 선택 | 갱신 실패 시 렌더할 UI (로그인 버튼 등) |
-
-**동작 방식:**
-
-| 상황 | user | AutoTokenRefresh |
-|------|------|-----------------|
-| 정상 요청 (proxy 실행됨) | 있음 | 아무것도 안 함 (skip) |
-| PWA 캐시 히트 + 갱신 시도 중 | 없음 | `fallback` 렌더 |
-| PWA 캐시 히트 + 유효한 `lemon_refresh_token` | 없음 | 갱신 → `router.refresh()` |
-| PWA 캐시 히트 + 만료된 `lemon_refresh_token` | 없음 | 갱신 실패 → `children` 렌더 |
+| `fallback` | `React.ReactNode` | **필수** | 갱신하는 동안 렌더할 UI |
+
+- 갱신 실패도 `next` 로 돌아갑니다. 죽은 토큰이면 서버가 401 응답에서 세션
+  쿠키를 지워 주므로, 이후 판단(로그인으로 보낼지, 익명으로 보여줄지)은
+  프록시와 DAL 이 합니다.
+- 서버에 연결하지 못하면(5xx · 네트워크 오류) 로그인으로 보내지 않고
+  "다시 시도" 버튼을 보여줍니다. 토큰이 살아 있을 수 있기 때문입니다.
+- 이 경로는 프록시가 자동으로 통과시키므로 `publicPaths` 에 넣지 않아도
+  됩니다.
+- `useSearchParams()` 를 쓰므로 `<Suspense>` 로 감싸야 빌드가 통과합니다.
+- `next` 는 같은 출처의 경로만 허용합니다. 열린 리다이렉트가 되지 않도록
+  `//evil.com` 같은 값은 `/` 로 떨어뜨립니다.
 
 ### `loginUrl(redirectUrl)`
 
@@ -491,7 +506,9 @@ profileUrl("https://myapp.lemondouble.com/settings")
 
 ### `refreshToken()`
 
-클라이언트에서 토큰 갱신을 수행합니다. 보통 proxy에서 자동으로 처리하므로 직접 호출할 일은 적습니다.
+클라이언트에서 토큰 갱신을 수행합니다. 갱신은 보통 `<SessionRestore />` 가
+맡으므로 직접 호출할 일은 적습니다. (승인 완료 후 새 `approved_clients` 를
+즉시 반영하고 싶을 때 정도)
 
 ```ts
 import { refreshToken } from "@lemondouble/lemon-auth/client";
@@ -544,7 +561,7 @@ interface UserProfile {
 
 새 Next.js 16 프로젝트에 인증을 추가하는 권장 예시입니다.
 
-### 1. proxy.ts — 토큰 자동 갱신
+### 1. proxy.ts — optimistic check
 
 ```ts
 import {
@@ -553,12 +570,15 @@ import {
 } from "@lemondouble/lemon-auth/proxy";
 
 export default createAuthProxy({
-  publicPaths: ["/", "/login", "/pending-approval", "/api/public/*"],
+  publicPaths: [
+    "/",
+    "/login",
+    "/pending-approval",
+    "/api/public/*",
+  ],
   bypassPaths: ["/workbox-*"],
   apiPaths: DEFAULT_API_PATHS,
-  clientId: process.env.CLIENT_ID,
   loginRedirectUrl: (request) => request.url,
-  unapprovedRedirectUrl: "/pending-approval",
 });
 
 export const config = {
@@ -569,56 +589,68 @@ export const config = {
 ```
 
 `loginRedirectUrl: (request) => request.url`은 로그인 후 사용자가 원래 요청한 path/query로 돌아오게 합니다.
-`apiPaths`에 매칭되는 보호 API는 인증 실패 시 redirect 대신 `401/403` JSON 응답을 반환합니다.
+`apiPaths`에 매칭되는 보호 API는 인증 실패 시 redirect 대신 `401` JSON 응답을 반환합니다.
 기본 PWA 파일(`/sw.js`, `/manifest.webmanifest` 등)은 항상 bypass되며, 앱에서 추가로 생성하는 workbox 파일은 `bypassPaths`에 넣을 수 있습니다.
+복구 경로(`/auth/restore`)는 프록시가 자동으로 통과시키므로 `publicPaths` 에 넣지 않습니다.
 
-`onAuthSuccess`를 사용하면 인증 성공 후 DB 동기화, 헤더 주입 등 앱별 로직을 끼워넣을 수 있습니다:
+사용자 DB 동기화 같은 작업은 **프록시가 아니라 DAL 에서** 하십시오. 프록시는
+프리페치를 포함해 모든 요청에서 돌기 때문에, 그 자리에서 DB 를 건드리면 화면
+하나 여는 데 쿼리가 여러 번 나갑니다.
 
 ```ts
-import {
-  createAuthProxy,
-  DEFAULT_API_PATHS,
-} from "@lemondouble/lemon-auth/proxy";
+// lib/dal.ts
+import { cache } from "react";
+import { getUser } from "@lemondouble/lemon-auth/server";
 import { upsertUser } from "@/lib/db";
 
-export default createAuthProxy({
-  publicPaths: ["/", "/login", "/pending-approval", "/api/public/*"],
-  bypassPaths: ["/workbox-*"],
-  apiPaths: DEFAULT_API_PATHS,
-  clientId: process.env.CLIENT_ID,
-  loginRedirectUrl: (request) => request.url,
-  unapprovedRedirectUrl: "/pending-approval",
-  onAuthSuccess: async (claims, request, response) => {
-    await upsertUser(claims);
-    response.headers.set("x-user-uid", claims.sub);
-    response.headers.set("x-user-nickname", encodeURIComponent(claims.nickname));
-    return response;
-  },
+export const getCurrentUser = cache(async () => {
+  const user = await getUser();
+  if (!user) return null;
+  await upsertUser(user);   // React cache() 덕에 요청당 한 번만 돈다
+  return user;
 });
 ```
 
-### 2. app/layout.tsx — AuthProvider + AutoTokenRefresh
+### 2. app/auth/restore/page.tsx — 세션 복구 착지점
+
+```tsx
+import { Suspense } from "react";
+import { SessionRestore } from "@lemondouble/lemon-auth/client";
+
+export const dynamic = "force-dynamic";
+
+export default function RestorePage() {
+  return (
+    <Suspense fallback={null}>
+      <SessionRestore fallback={<p>세션 복원 중...</p>} />
+    </Suspense>
+  );
+}
+```
+
+### 3. app/layout.tsx — AuthProvider
 
 ```tsx
 import { getUser } from "@lemondouble/lemon-auth/server";
-import { AuthProvider, AutoTokenRefresh } from "@lemondouble/lemon-auth/client";
+import { AuthProvider } from "@lemondouble/lemon-auth/client";
 
 export default async function RootLayout({ children }: { children: React.ReactNode }) {
   const user = await getUser();
   return (
     <html lang="ko">
       <body>
-        <AuthProvider user={user}>
-          <AutoTokenRefresh fallback={<p>세션 복원 중...</p>} />
-          {children}
-        </AuthProvider>
+        <AuthProvider user={user}>{children}</AuthProvider>
       </body>
     </html>
   );
 }
 ```
 
-### 3. app/page.tsx — 공개 페이지 (로그인 버튼)
+레이아웃은 `user` 를 **표시용**으로만 씁니다. 레이아웃은 소프트 네비에서
+다시 렌더되지 않으므로, 여기서 인증을 판단하면 낡은 스냅샷으로 판단하게
+됩니다. 게이트는 페이지의 DAL 호출이 맡습니다.
+
+### 4. app/page.tsx — 공개 페이지 (로그인 버튼)
 
 ```tsx
 import { getUser } from "@lemondouble/lemon-auth/server";
@@ -642,7 +674,7 @@ export function LoginButton() {
 }
 ```
 
-### 4. app/dashboard/page.tsx — 보호 페이지
+### 5. app/dashboard/page.tsx — 보호 페이지
 
 ```tsx
 import { requireAuth } from "@lemondouble/lemon-auth/server";
@@ -653,7 +685,7 @@ export default async function Dashboard() {
 }
 ```
 
-### 5. 로그아웃
+### 6. 로그아웃
 
 ```tsx
 "use client";

package/dist/client/index.d.ts

@@ -13,14 +13,36 @@ declare function AuthProvider({ user, children, }: {
 }): react_jsx_runtime.JSX.Element;
 declare function useAuth(): AuthContextValue;
 
-declare function AutoTokenRefresh({ children, fallback, }: {
-    children?: React.ReactNode;
+/**
+ * 토큰을 갱신하는 유일한 주체. 프록시가 만료된 세션을 이리로 보낸다.
+ *
+ * 갱신을 서버(미들웨어)가 아니라 브라우저가 하는 이유는 두 가지다.
+ *
+ *   1. 미들웨어는 요청마다 별도 인스턴스로 떠서 서로를 모른다. 프리페치가
+ *      깔리면 같은 refresh token 으로 갱신이 동시에 나가고, 회전 경쟁이 난다.
+ *      브라우저의 복구 경로는 한 번에 하나만 뜬다.
+ *   2. 브라우저 요청에는 진짜 UA 와 WAF 통과 쿠키가 실린다. 서버간 fetch 는
+ *      UA 가 런타임 기본값이라 봇 방어에 걸릴 수 있다.
+ *
+ * 끝나면 router 가 아니라 window.location 으로 next 에 간다. 소프트 네비는
+ * 루트 레이아웃(과 AuthProvider)을 다시 렌더하지 않으므로, 옛 세션 스냅샷이
+ * 남아 화면이 어긋나거나 라우터 캐시에 굳은 리다이렉트가 되살아난다.
+ *
+ * 실패해도 next 로 간다. 죽은 토큰이면 서버가 401 응답에서 세션 쿠키를
+ * 지워 주므로(auth-server v2026.08.03.2+), 이후 판단 — 로그인으로 보낼지,
+ * 익명으로 보여줄지 — 는 프록시와 DAL 이 알아서 한다.
+ */
+declare function SessionRestore({ fallback }: {
     fallback: React.ReactNode;
-}): string | number | bigint | boolean | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | null;
+}): string | number | bigint | boolean | Iterable<react.ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<react.ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
 
 declare function loginUrl(redirectUrl: string): string;
 declare function profileUrl(redirectUrl?: string): string;
+/**
+ * 로그아웃. 쿠키 삭제는 응답의 Set-Cookie 가 한다 — 세션 쿠키는 httpOnly
+ * 라서 JS 로는 지울 수 없다.
+ */
 declare function logout(): Promise<boolean>;
 declare function refreshToken(): Promise<boolean>;
 
-export { AuthProvider, AutoTokenRefresh, LemonUser, loginUrl, logout, profileUrl, refreshToken, useAuth };
+export { AuthProvider, LemonUser, SessionRestore, loginUrl, logout, profileUrl, refreshToken, useAuth };

package/dist/client/index.js

@@ -1,11 +1,8 @@
 "use client";
 import {
-  ACCESS_TOKEN_COOKIE,
-  DEVICE_ID_COOKIE,
   LOGIN_URL,
   LOGOUT_URL,
   PROFILE_PAGE_URL,
-  REFRESH_TOKEN_COOKIE,
   REFRESH_URL,
   isMockAuthEnabled
 } from "../chunk-OX5MDVSR.js";
@@ -27,16 +24,11 @@ function useAuth() {
   return useContext(AuthContext);
 }
 
-// src/client/auto-token-refresh.tsx
+// src/client/session-restore.tsx
 import { useEffect, useState } from "react";
-import { useRouter } from "next/navigation";
+import { useSearchParams } from "next/navigation";
 
 // src/client/url.ts
-var LOGOUT_COOKIE_NAMES = [
-  ACCESS_TOKEN_COOKIE,
-  REFRESH_TOKEN_COOKIE,
-  DEVICE_ID_COOKIE
-];
 function loginUrl(redirectUrl) {
   if (isMockAuthEnabled()) return redirectUrl;
   assertValidLoginRedirectUrl(redirectUrl);
@@ -50,10 +42,7 @@ function profileUrl(redirectUrl) {
   return PROFILE_PAGE_URL;
 }
 async function logout() {
-  if (isMockAuthEnabled()) {
-    expireAuthCookies();
-    return true;
-  }
+  if (isMockAuthEnabled()) return true;
   try {
     const res = await fetch(LOGOUT_URL, {
       method: "POST",
@@ -62,51 +51,24 @@ async function logout() {
     return res.ok;
   } catch {
     return false;
-  } finally {
-    expireAuthCookies();
   }
 }
-async function refreshToken() {
-  if (isMockAuthEnabled()) return true;
+async function refreshSession() {
+  if (isMockAuthEnabled()) return "ok";
   try {
     const res = await fetch(REFRESH_URL, {
       method: "POST",
       credentials: "include"
     });
-    return res.ok;
+    if (res.ok) return "ok";
+    if (res.status === 401 || res.status === 403) return "unauthorized";
+    return "unavailable";
   } catch {
-    return false;
-  }
-}
-function expireAuthCookies() {
-  if (typeof document === "undefined") return;
-  for (const name of LOGOUT_COOKIE_NAMES) {
-    for (const domain of getCookieDomains()) {
-      document.cookie = [
-        `${name}=`,
-        "Max-Age=0",
-        "Path=/",
-        "SameSite=Lax",
-        domain ? `Domain=${domain}` : ""
-      ].filter(Boolean).join("; ");
-    }
+    return "unavailable";
   }
 }
-function getCookieDomains() {
-  if (typeof window === "undefined") return [""];
-  const { hostname } = window.location;
-  if (!hostname || hostname === "localhost" || isIpAddress(hostname)) {
-    return [""];
-  }
-  const labels = hostname.split(".");
-  const domains = [""];
-  for (let i = 0; i < labels.length - 1; i += 1) {
-    domains.push(`.${labels.slice(i).join(".")}`);
-  }
-  return domains;
-}
-function isIpAddress(hostname) {
-  return /^[\d.]+$/.test(hostname) || hostname.includes(":");
+async function refreshToken() {
+  return await refreshSession() === "ok";
 }
 function assertValidLoginRedirectUrl(redirectUrl) {
   let url;
@@ -129,36 +91,56 @@ function isAllowedLoginRedirectHost(hostname) {
   return normalized === "lemondouble.com" || normalized.endsWith(".lemondouble.com");
 }
 
-// src/client/auto-token-refresh.tsx
-function AutoTokenRefresh({
-  children,
-  fallback
-}) {
-  const { isAuthenticated } = useAuth();
-  const router = useRouter();
-  const [status, setStatus] = useState("loading");
+// src/client/session-restore.tsx
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+function SessionRestore({ fallback }) {
+  const searchParams = useSearchParams();
+  const [unavailable, setUnavailable] = useState(false);
   useEffect(() => {
-    if (isAuthenticated) return;
     let ignore = false;
-    refreshToken().then((ok) => {
+    const next = safeNextPath(searchParams.get("next"));
+    refreshSession().then((result) => {
       if (ignore) return;
-      if (ok) {
-        router.refresh();
-      } else {
-        setStatus("failed");
+      if (result === "unavailable") {
+        setUnavailable(true);
+        return;
       }
+      window.location.replace(next);
     });
     return () => {
       ignore = true;
     };
-  }, [isAuthenticated, router]);
-  if (isAuthenticated) return null;
-  if (status === "loading") return fallback ?? null;
-  return children ?? null;
+  }, [searchParams]);
+  if (unavailable) {
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        style: {
+          minHeight: "100dvh",
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "center",
+          justifyContent: "center",
+          gap: 12
+        },
+        children: [
+          /* @__PURE__ */ jsx2("p", { children: "\uC778\uC99D \uC11C\uBC84\uC5D0 \uC5F0\uACB0\uD558\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4." }),
+          /* @__PURE__ */ jsx2("button", { type: "button", onClick: () => window.location.reload(), children: "\uB2E4\uC2DC \uC2DC\uB3C4" })
+        ]
+      }
+    );
+  }
+  return fallback;
+}
+function safeNextPath(next) {
+  if (!next) return "/";
+  if (!next.startsWith("/")) return "/";
+  if (next.startsWith("//")) return "/";
+  return next;
 }
 export {
   AuthProvider,
-  AutoTokenRefresh,
+  SessionRestore,
   loginUrl,
   logout,
   profileUrl,