@gaonjs/cli 0.5.0 → 0.10.1

package/dist/templates/project/agents/web.md.tpl

@@ -0,0 +1,177 @@
+# agents/web.md — 웹 레이어 (라우팅 · 컨트롤러 · params · JSON 액션 · 인증)
+
+> 골격: **정본 규칙 → 정본 예시 → 알려진 함정 → 관련 결정 번호** (결정 40 · 2층 구조).
+> 루트 `AGENTS.md` 는 코어 요약만 담는다 — 시그니처·규칙 상세의 정본은 이 파일이다.
+> 대상 패키지: `@gaonjs/web` (파사드 import 는 `gaonjs/web`).
+
+## 정본 규칙
+
+### 1. JSON 액션 — 반환값이 곧 응답 (errata E-3 §3.1)
+
+컨트롤러 액션이 `this.render(...)` 나 `this.redirect(...)` 대신
+**평범한 객체/배열을 반환하면 그것이 곧 JSON 응답**이다. 별도
+데코레이터·설정·헬퍼 호출이 없다 (E-3 §3.1 원문).
+
+```ts
+// apps/web/controllers/posts.ts
+import { controller } from 'gaonjs/web'                // 파사드 · 함수형 API
+import { Post } from '../../../domain/models/Post.js'  // 앱→도메인 (rule 5)
+
+export default controller({
+  async index() {
+    return this.render('Posts/Index', { posts: await Post.latest().limit(20).all() })
+  },
+
+  // JSON 액션 — 객체를 반환하면 JSON 응답
+  async search() {
+    const { q } = this.params(Post.searchForm)          // 검증 실패 시 자동 422 JSON
+    return { results: await Post.published().search(q).limit(10).all() }
+  },
+})
+```
+
+- **import 관례** — 프레임웍 심볼은 파사드 `gaonjs/*` 에서 (`gaonjs/web`·
+  `gaonjs/data`·`gaonjs/vue`·`gaonjs/async` 등), 도메인 모델은 상대경로
+  `../../../domain/models/<Pascal>.js` 로 참조한다. `@gaonjs/*` (스코프
+  이름) 은 내부 패키지 이름 — 앱 코드에서 직접 import 하지 않는다.
+  `@inertiajs/vue3` 는 어댑터 내부 의존 — 앱에서 직접 안 쓴다.
+- **`this.render` 인자** = `<PageFolder>/<Page>` (PascalCase 폴더 · Vue
+  파일명과 정합) — 예: `'Posts/Index'` → `apps/<app>/pages/Posts/Index.vue`.
+- **리소스 부재 = `this.notFound()`** — 조회 결과가 없으면 404 를 손으로 만들지
+  말고 `this.notFound()` 로 마감한다(`requireAuth()` 와 동형). `never` 를 반환해
+  이 뒤로 값이 존재하는 것으로 좁혀지므로, `render` 반환 타입(타입 브리지)도 그대로
+  유지된다. 메시지는 선택: `this.notFound('post 없음')`.
+
+  ```ts
+  async show() {
+    const post = await Post.find(this.params(Post.showForm).id)
+    if (!post) return this.notFound()   // 404 · 이 뒤로 post 는 non-null
+    return this.render('Posts/Show', { post })
+  }
+  ```
+
+### 2. 응답 규칙 — 한 액션은 한 종류 응답만
+
+- **한 액션은 한 종류 응답만 낸다** (render 또는 JSON 또는 redirect —
+  조건 분기 혼용 금지). `gaon doctor` 의 **response-mixing** 검사가
+  혼용을 잡는다.
+- 검증은 페이지 액션과 동일하게 `this.params(스키마)` — 실패 시
+  422 JSON.
+- 인증·세션은 같은 앱의 세션 쿠키를 그대로 쓴다. CSRF·rate limit 등
+  보안 기본값도 그대로 적용된다 (`agents/security.md` · 끄는 것은
+  명시적 설정으로만).
+
+### 3. `this.params` 통합 입력 · 안전 규칙 (errata E-3 §5 · 결정 24)
+
+`this.params` 는 라우트 파라미터·query·body(업로드 파일 포함)를
+하나로 합쳐서 주는 Rails 식 통합 입력이다. 안전을 위해 아래 세 규칙이
+반드시 함께 적용된다.
+
+**출처 우선순위 — 고정, 설정 불가:**
+
+- **라우트 파라미터 > body > query** 순서로 병합 (E-3 §5.1 원문).
+- 라우트 파라미터가 절대 덮어써지지 않는 것이 핵심 — `/posts/:id` 의
+  `id` 를 공격자가 body 의 `id: 999` 로 바꿔치기해서 권한 검사를
+  우회하는 파라미터 오염 공격을 원천 차단한다.
+- 이 우선순위는 문서화된 고정 규칙이며 **설정으로 바꿀 수 없다**.
+
+**중복 키:**
+
+- `?tag=a&tag=b` 처럼 같은 출처에서 키가 중복되면: 스키마의 해당
+  필드가 배열 타입이면 배열로 수집, 아니면 **마지막 값**을 쓴다
+  (E-3 §5.2 원문).
+
+**출처 명시 탈출구 — `this.body()` / `this.query()`:**
+
+- 출처 자체가 의미를 갖는 드문 경우(웹훅 수신처럼 반드시 body에서만
+  와야 하는 데이터, 서명 검증 대상 등)에만 쓴다.
+- 기본 경로는 여전히 `this.params` 하나(The One Way) — 스캐폴드·문서·
+  기본 예시는 `this.params` 만 쓴다 (E-3 §5.3 원문).
+
+### 4. 데이터 경로 판단 — 루트 판단표가 정본
+
+데이터가 필요할 때는 루트 `AGENTS.md` 의 데이터 경로 4종 판단표를 따른다
+(Inertia partial reload · 채널/프레즌스 · JSON 액션 + `api()` · 별도 API 앱 + JWT).
+**Inertia = SPA + 서버 라우팅**이지 SSR 이 아니다. 로그인·회원가입도 컨트롤러
+`this.render('auth/Login')` + Vue 페이지 `Inertia.post()` → 서버
+redirect 로 처리한다 — 전체 페이지 리로드도, 별도 REST 엔드포인트도
+없다. REST + `fetch()` 는 **API 앱(JWT) 전용**.
+
+### 5. 비밀번호 해싱 — `hashPassword` · `verifyPassword` (`gaonjs/web`)
+
+회원가입·로그인에서 비밀번호를 다룰 때는 **직접 crypto/bcrypt 를 import 하거나
+base64·해시를 손으로 짜지 말고** `gaonjs/web` 의 헬퍼를 쓴다(The One Way · §7 인증).
+bcrypt(cost 10)로 해싱하며 상수시간 비교를 제공한다.
+
+```ts
+import { hashPassword, verifyPassword } from 'gaonjs/web'
+
+// 가입 — 서비스에서 평문을 해싱해 hidden 컬럼(passwordDigest)에 저장.
+const passwordDigest = await hashPassword(plain)          // Promise<string>
+const user = await User.create({ name, email, passwordDigest })
+
+// 로그인 — 저장된 다이제스트와 평문을 비교(상수시간).
+const ok = await verifyPassword(plain, user.passwordDigest) // Promise<boolean>
+```
+
+- **시그니처** — `hashPassword(plain: string): Promise<string>` ·
+  `verifyPassword(plain: string, digest: string): Promise<boolean>`. 둘 다 async.
+- **기본값** — bcrypt cost 10(보안/지연 균형점). 순수 JS(`bcryptjs`)라 네이티브
+  빌드 없이 어느 환경에서나 설치가 확실하다.
+- **저장 위치** — 결과는 스키마의 hidden 컬럼(`passwordDigest: t.string().hidden()`)
+  에 담는다 — 응답 경계에서 타입·런타임 양쪽으로 페이지 노출이 막힌다.
+- 회원 생성 로직은 컨트롤러가 아니라 **서비스**(`agents/data.md` §9 · registerUser)에
+  둔다 — `const user = await RegisterUser.call({ name, email, password })`.
+
+### 6. 인증·세션 (v0.15 §7 · M5)
+
+- 세션 쿠키가 기본, JWT 는 **API 앱 전용 옵션** (v0.11 확정).
+- 세션은 앱별 완전 분리 (Fastify 캡슐화 스코프): 쿠키 이름(`<app>_sid`) ·
+  서명 secret · Redis 키 prefix · 쿠키 path 가 앱 단위로 갇힌다.
+- 스캐폴드는 `gaon g auth` — 로그인/회원가입 컨트롤러·페이지·라우트 일습.
+- 로그인 필요 액션은 `this.requireAuth()` 관례 (notFound 와 동형 — never 좁힘).
+
+## 정본 예시
+
+```ts
+// apps/web/controllers/registration.ts — 회원 가입 (E-3 · Inertia SPA)
+import { controller } from 'gaonjs/web'
+import { RegisterUser } from '../../../domain/services/registerUser.js'
+import { SendWelcomeMail } from '../../../domain/jobs/sendWelcomeMail.js'
+
+export default controller({
+  async new() {
+    return this.render('Auth/Register', {})
+  },
+  async create() {
+    const user = await RegisterUser.call(this.params(RegisterUser.form))
+    await SendWelcomeMail.later(user.id)      // 잡 발행 위치는 결정 32 — 서비스 afterCommit 도 정합
+    return this.redirect('/dashboard')
+  },
+})
+```
+
+## 알려진 함정
+
+- **render/JSON/redirect 를 한 액션에서 조건 혼용하면 doctor
+  response-mixing 위반** — 액션을 나눈다.
+- **`fetch()` 로 로그인 폼 구현 금지** — 세션 앱 폼은 `Inertia.post()`.
+  REST + fetch 는 API 앱(JWT) 전용.
+- **컨트롤러에 비즈니스 로직 인라인 금지** (§5.3 One Way) — 여러 모델·
+  트랜잭션·외부 API 가 얽히면 `domain/services/`.
+- **컨트롤러에서 메일·외부 발송 직접 호출 금지** — 잡 발행만
+  (`agents/async.md`). nodemailer·resend 등 SDK 직접 import 는 함정.
+- **bcrypt·crypto 직접 import 금지** — `hashPassword`/`verifyPassword`.
+- **`@gaonjs/*` 스코프 직접 import 금지** — 파사드 `gaonjs/*` 만.
+- **bigint PK 를 render props 로 흘릴 때는 `String(p.id)` 정규화**
+  (결정 37 · 상세는 `agents/frontend.md`).
+
+## 관련 결정 번호
+
+| 결정 | 내용 |
+|---|---|
+| 결정 23 (E-3) | 앱 내 JSON 액션 — 반환값 = 응답 |
+| 결정 24 (E-3 §5) | `this.params` 안전 규칙 (라우트 > body > query · 중복 키 · body/query 탈출구) |
+| 결정 32 | 잡 발행 위치 자유 (컨트롤러·서비스·리스너 — `agents/async.md`) |
+| 결정 37 | bigint PK 컨트롤러 `String()` 정규화 (`agents/frontend.md`) |
+| E-1 | 파사드 = `gaonjs` · CLI = `gaon` |

package/dist/templates/project/apps/web/index.html.tpl

@@ -0,0 +1,18 @@
+<!doctype html>
+<html lang="ko">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{{PROJECT_NAME}}</title>
+  </head>
+  <body>
+    <!--
+      Vite 개발 서버가 이 index.html 을 서빙한다(dev). 운영 빌드는
+      vite build 가 이 파일을 진입점 삼아 프로덕션 번들을 만든다.
+      Fastify(gaonjs/web) 는 초기 SPA 응답 셸에서 아래와 같은 구조의
+      <div id="app" data-page="..."> 를 내려보낸다 — 개발과 운영이 같은 셸.
+    -->
+    <div id="app"></div>
+    <script type="module" src="/main.ts"></script>
+  </body>
+</html>

package/dist/templates/project/apps/web/main.ts.tpl

@@ -0,0 +1,24 @@
+// apps/web/main.ts — 프론트엔드 진입 (v0.16 §6.4 · M3 최소 웹 레이어).
+//
+// 브라우저 부팅 흐름:
+//   1) index.html 이 이 파일을 <script type="module"> 로 로드한다.
+//   2) createGaonApp 이 Inertia SPA 를 마운트한다.
+//   3) 서버 응답의 data-page 를 어댑터가 읽어 첫 페이지를 그린다.
+//
+// 자동 import 금지(E-5 §2.4) — 페이지·레이아웃 지도는 아래처럼 명시적으로
+// import.meta.glob 으로 만든다. 심볼 출처가 코드에 그대로 보인다.
+import { createGaonApp } from 'gaonjs/vue'
+
+// 페이지는 지연 로드(코드 스플리팅) — 큰 앱에서도 첫 페이지 로딩이 빠르다.
+// eager 로 바꿔도 되지만, One Way 의 기본은 지연 로드다.
+const pages = import.meta.glob('./pages/**/*.vue')
+
+// 레이아웃은 eager — 소수·최초 진입에도 필요하므로 굳이 지연 로드하지 않는다.
+// layouts/Default.vue 가 있으면 모든 페이지에 자동 적용된다(errata E-5 §2.3).
+const layouts = import.meta.glob('./layouts/*.vue', { eager: true })
+
+void createGaonApp({
+  pages,
+  layouts,
+  title: (t) => (t ? `${t} · {{PROJECT_NAME}}` : '{{PROJECT_NAME}}'),
+})

package/dist/templates/project/package.json.tpl

@@ -16,11 +16,14 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "gaonjs": "{{GAONJS_VERSION}}"
+    "gaonjs": "{{GAONJS_VERSION}}",
+    "@inertiajs/vue3": "^3.6.0",
+    "vue": "^3.5.0"
   },
   "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.0",
     "typescript": "^5.9.0",
-    "vue": "^3.5.0",
+    "vite": "^7.0.0",
     "vue-tsc": "^3.3.0",
     "vitest": "^3.0.0"
   }

package/dist/templates/project/vite.config.ts.tpl

@@ -0,0 +1,23 @@
+// vite.config.ts — 프론트엔드 빌드/개발 서버 설정 (v0.16 §6.4).
+//
+// The One Way: gaon dev 가 Vite 를 middlewareMode 로 붙여 Fastify 한 포트로
+// 서빙한다(§CLAUDE.md 6 · 이 파일의 server 옵션은 그때 재정의된다). vite
+// build 는 이 파일을 그대로 사용한다.
+//
+// 앱이 하나 이상이면 각 앱마다 vite.config.ts 를 두는 것이 아니라, 이 루트
+// 파일 하나가 root 를 apps/<앱> 으로 잡고 여러 번 실행된다(gaon dev 가 앱별
+// Vite 서버를 띄운다). 관례가 곧 배치.
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+export default defineConfig({
+  // 기본 앱은 apps/web · gaon dev 가 다른 앱에 대해 root 를 재정의한다.
+  root: 'apps/web',
+  plugins: [vue()],
+  build: {
+    outDir: '../../dist/web',
+    emptyOutDir: true,
+    // Inertia SPA 는 index.html 하나가 진입 · 라우팅은 서버 몫이다.
+    rollupOptions: {},
+  },
+})

package/dist/tsResolve.js

@@ -3,7 +3,7 @@
  *
  * 생성기(tables·routes)는 사용자 스키마·컨트롤러 .ts 를 런타임 동적
  * import 해 구조를 읽는다. TS-for-ESM 관례상 상대 import 는 `.js` 로
- * 쓰지만(`import { Post } from '../models/post.js'`), 개발 중 소스는
+ * 쓰지만(`import { Post } from '../models/Post.js'`), 개발 중 소스는
  * `.ts` 다 — Node 는 `.js`→`.ts` 재매핑을 하지 않아 그대로면 모듈을
  * 못 찾는다(vitest 는 Vite 가 재작성해 문제 없음, 실 gaon dev/check 만
  * 해당). 이 훅이 `.js` 가 없고 형제 `.ts` 가 있으면 `.ts` 로 넘긴다.

package/dist/work.d.ts

@@ -1,10 +1,10 @@
 export interface WorkCommandOptions {
     readonly json?: boolean;
-    /** NATS 접속지. 생략 시 GAON_NATS_URL, 그다음 기본(4222). */
+    /** NATS 접속지. 생략 시 NATS_URL(그다음 하위호환 GAON_NATS_URL), 기본(4222). */
     readonly natsUrl?: string;
     /** 도메인 루트(domain/ 의 부모). 기본 cwd. */
     readonly root?: string;
-    /** 아웃박스 릴레이용 DB URL. 생략 시 GAON_DATABASE_URL, 없으면 릴레이 미기동. */
+    /** 아웃박스 릴레이용 DB URL. 생략 시 DATABASE_URL(그다음 GAON_DATABASE_URL), 없으면 릴레이 미기동. */
     readonly databaseUrl?: string;
     /** 큐 기본 동시성. */
     readonly concurrency?: number;

package/dist/work.js

@@ -68,7 +68,9 @@ export async function runWorkCommand(opts = {}) {
     };
     const nats = await connectNats({ servers: opts.natsUrl, name: `work@${id}` });
     let db;
-    const dbUrl = opts.databaseUrl ?? process.env.GAON_DATABASE_URL;
+    // 스캐폴드 .env 관례(DATABASE_URL)를 정본으로 · GAON_DATABASE_URL 은 하위호환.
+    // serve(config 경유 DATABASE_URL)와 work 가 같은 env 를 보게 한다.
+    const dbUrl = opts.databaseUrl ?? process.env.DATABASE_URL ?? process.env.GAON_DATABASE_URL;
     if (dbUrl)
         db = createDb(dbConfigFromUrl(dbUrl));
     const domain = await loadDomain(root);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.5.0",
+  "version": "0.10.1",
   "description": "Gaon CLI 구현: 제너레이터·스캐폴딩·로드맵 출력 (M1 스텁)",
   "type": "module",
   "license": "MIT",
@@ -23,16 +23,18 @@
     "dist",
     "README.md"
   ],
-  "dependencies": {
-    "typescript": "^5.9.0",
-    "@gaonjs/async": "0.2.2",
-    "@gaonjs/config": "0.1.0",
-    "@gaonjs/core": "0.1.4",
-    "@gaonjs/mail": "0.1.0",
-    "@gaonjs/web": "0.3.0",
-    "@gaonjs/data": "0.3.0"
-  },
   "scripts": {
     "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"require('fs').cpSync('src/templates','dist/templates',{recursive:true})\""
+  },
+  "dependencies": {
+    "@gaonjs/async": "workspace:*",
+    "@gaonjs/config": "workspace:*",
+    "@gaonjs/core": "workspace:*",
+    "@gaonjs/data": "workspace:*",
+    "@gaonjs/web": "workspace:*",
+    "@gaonjs/mail": "workspace:*",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "typescript": "^5.9.0",
+    "vite": "^7.0.0"
   }
-}
+}

package/dist/__fixtures__/db-minimal/domain/schema/widgets.d.ts

@@ -1,12 +0,0 @@
-import { type RowOf } from '@gaonjs/data';
-export declare const m9dWidgets: import("@gaonjs/data").TableDef<"m9d_widgets", {
-    id: import("@gaonjs/data").BigintCol<{
-        hasDefault: true;
-    }>;
-    name: import("@gaonjs/data").StringCol<{}>;
-}>;
-declare module '@gaonjs/data' {
-    interface GaonTables {
-        m9d_widgets: RowOf<typeof m9dWidgets>;
-    }
-}

package/dist/__fixtures__/db-minimal/domain/schema/widgets.js

@@ -1,7 +0,0 @@
-// db 통합 테스트 픽스처 — main 커넥션의 유일한 테이블.
-// 이름은 m9d_widgets (M8 seed 픽스처의 widgets 와 GaonTables 병합 충돌 회피).
-import { table, t } from '@gaonjs/data';
-export const m9dWidgets = table('m9d_widgets', {
-    id: t.id(),
-    name: t.string().max(30),
-});

package/dist/__fixtures__/db-minimal/gaon.config.d.ts

@@ -1,2 +0,0 @@
-declare const _default: import("@gaonjs/config").GaonConfig;
-export default _default;

package/dist/__fixtures__/db-minimal/gaon.config.js

@@ -1,11 +0,0 @@
-// db 통합 테스트 픽스처 — main 커넥션만 있는 최소 gaon.config.ts.
-// url 은 GAON_TEST_PG_URL 우선 · 로컬 default 는 packages/data/compose.yaml 정합.
-import { defineConfig } from '@gaonjs/config';
-export default defineConfig({
-    db: {
-        main: {
-            adapter: 'postgres',
-            url: process.env.GAON_TEST_PG_URL ?? 'postgres://gaon:gaon@127.0.0.1:5433/gaon_test',
-        },
-    },
-});

package/dist/check.d.ts

@@ -1,29 +0,0 @@
-import { type DevLayout } from './dev.js';
-export interface TypecheckResult {
-    readonly ok: boolean;
-    readonly output: string;
-    /** 실행한 체커 이름(vue-tsc | tsc | none). */
-    readonly checker: string;
-}
-export interface CheckDeps {
-    readonly layout: DevLayout;
-    regenerateTables(schemaDir: string, out: string): Promise<unknown>;
-    regenerateRoutes(appDir: string, out: string): Promise<unknown>;
-    typecheck(): Promise<TypecheckResult>;
-}
-export interface CheckResult {
-    readonly ok: boolean;
-    readonly regenerated: {
-        readonly tables: boolean;
-        readonly routes: string[];
-    };
-    readonly typecheck: TypecheckResult;
-}
-/** .gaon 재생성 → 타입 체크. 재생성이 검사보다 먼저다(§13.4-5). */
-export declare function runCheck(deps: CheckDeps): Promise<CheckResult>;
-export interface CheckCommandOptions {
-    readonly cwd?: string;
-    readonly json?: boolean;
-}
-/** `gaon check` 진입점. */
-export declare function runCheckCommand(opts?: CheckCommandOptions): Promise<number>;

package/dist/check.js

@@ -1,92 +0,0 @@
-/**
- * @gaonjs/cli · `gaon check` — 검사 전 .gaon 재생성 (M3, §13.4-5)
- *
- * 개발 서버(gaon dev)가 떠 있지 않은 CI·AI 에이전트 환경에서도 타입
- * 체인이 항상 최신으로 검증되게, 타입 검사 **전에** .gaon(tables·routes)
- * 을 먼저 재생성한 뒤 tsc/vue-tsc 를 돌린다.
- *
- * 오케스트레이션(runCheck)은 주입으로 순수하게 유지하고, 진입점이 cwd
- * 관례로 실제 재생성기·타입 체커를 엮는다(dev.ts 와 동일 패턴).
- */
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { spawn } from 'node:child_process';
-import { generateTablesDts } from '@gaonjs/data';
-import { generateRoutesDts } from '@gaonjs/web';
-import { resolveDevLayout } from './dev.js';
-import { registerTsResolve } from './tsResolve.js';
-/** .gaon 재생성 → 타입 체크. 재생성이 검사보다 먼저다(§13.4-5). */
-export async function runCheck(deps) {
-    const { layout } = deps;
-    const routes = [];
-    if (layout.schemaDir)
-        await deps.regenerateTables(layout.schemaDir, layout.tablesOut);
-    for (const app of layout.apps) {
-        await deps.regenerateRoutes(app.appDir, app.routesOut);
-        routes.push(app.name);
-    }
-    const typecheck = await deps.typecheck();
-    return {
-        ok: typecheck.ok,
-        regenerated: { tables: !!layout.schemaDir, routes },
-        typecheck,
-    };
-}
-/** 프로젝트에 맞는 타입 체커를 골라 실행한다. .vue 가 있으면 vue-tsc. */
-function makeProjectTypecheck(cwd) {
-    return () => new Promise((resolve) => {
-        const tsconfig = join(cwd, 'tsconfig.json');
-        if (!existsSync(tsconfig)) {
-            resolve({
-                ok: false,
-                checker: 'none',
-                output: `[gaon check] tsconfig.json 이 없습니다: ${tsconfig}\n` +
-                    `→ 프로젝트 루트에 tsconfig.json 을 만들고 다시 실행하세요.`,
-            });
-            return;
-        }
-        const vueTsc = join(cwd, 'node_modules', '.bin', 'vue-tsc');
-        const useVue = existsSync(vueTsc);
-        const checker = useVue ? 'vue-tsc' : 'tsc';
-        const cmd = useVue ? vueTsc : process.execPath;
-        const args = useVue
-            ? ['--noEmit', '-p', tsconfig]
-            : [join(cwd, 'node_modules', 'typescript', 'bin', 'tsc'), '--noEmit', '-p', tsconfig];
-        const child = spawn(cmd, args, { cwd });
-        let output = '';
-        child.stdout.on('data', (b) => (output += b.toString()));
-        child.stderr.on('data', (b) => (output += b.toString()));
-        child.on('error', (e) => resolve({ ok: false, checker, output: String(e) }));
-        child.on('close', (code) => resolve({ ok: code === 0, checker, output }));
-    });
-}
-/** `gaon check` 진입점. */
-export async function runCheckCommand(opts = {}) {
-    const cwd = opts.cwd ?? process.cwd();
-    registerTsResolve(); // 사용자 .ts 의 `.js` 상대 import 를 런타임에 해석
-    const deps = {
-        layout: resolveDevLayout(cwd),
-        regenerateTables: generateTablesDts,
-        regenerateRoutes: generateRoutesDts,
-        typecheck: makeProjectTypecheck(cwd),
-    };
-    const result = await runCheck(deps);
-    if (opts.json) {
-        process.stdout.write(JSON.stringify(result) + '\n');
-    }
-    else {
-        const r = result.regenerated;
-        const gen = [r.tables ? 'tables.d.ts' : null, ...r.routes.map((a) => `${a}/routes.d.ts`)]
-            .filter(Boolean)
-            .join(', ');
-        process.stdout.write(`  재생성: ${gen || '(대상 없음)'}\n`);
-        if (result.ok) {
-            process.stdout.write(`  ✓ 타입 검사 통과 (${result.typecheck.checker})\n`);
-        }
-        else {
-            process.stdout.write(`  ✗ 타입 검사 실패 (${result.typecheck.checker})\n`);
-            process.stdout.write(result.typecheck.output);
-        }
-    }
-    return result.ok ? 0 : 1;
-}