@gaonjs/cli 0.42.3 → 0.43.0

package/dist/db/reset.js

@@ -10,7 +10,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { sql } from 'kysely';
-import { snapshotFromDb, MIGRATIONS_TABLE } from '@gaonjs/data';
+import { snapshotFromDb, orderTableDropsByFk, MIGRATIONS_TABLE } from '@gaonjs/data';
 import { resolveDbTarget } from './resolve.js';
 import { runDbMigrate } from './migrate.js';
 import { runDbSeedCommand } from '../db.js';
@@ -71,7 +71,8 @@ export async function runDbReset(opts) {
         // 현재 DB 스냅샷 — 지울 테이블 목록. dialect.introspect 는 이미
         // _gaon_migrations 를 제외하지만, reset 은 이력도 지워야 하므로 별도 처리.
         const snapshot = await snapshotFromDb(target.db, target.dialect);
-        const userTables = Object.keys(snapshot).sort();
+        // FK 역순(자식 먼저)으로 정렬해 mysql(CASCADE 없음) 다중 drop 이 FK 위반 없이 돌게 한다(F4 · 결정 275).
+        const userTables = orderTableDropsByFk(snapshot, Object.keys(snapshot).sort());
         // dry-run: 무엇을 지울지·만들지를 계산해 출력. 실제 파괴는 안 함.
         if (opts.dryRun) {
             const dropSqls = userTables.map((t) => target.dialect.dropTable(t));
@@ -93,15 +94,24 @@ export async function runDbReset(opts) {
             };
         }
         else {
-            // DROP ALL — 이력 테이블도 함께. 순서: 외래키 참조 대상이 나중에 지워지도록
-            // dialect.dropTable 이 CASCADE 를 붙인다(postgres). mysql 은 SET FOREIGN_KEY_CHECKS
-            // 우회가 필요하지만, 스키마 대상 테이블만 다루므로 대체로 안전.
-            for (const t of userTables) {
-                await sql.raw(target.dialect.dropTable(t)).execute(target.db);
-                droppedTables.push(t);
+            // DROP ALL — 이력 테이블도 함께. pg 는 dropTable 이 CASCADE, mysql 은 CASCADE 가 없어
+            // FK 역순 정렬(위 orderTableDropsByFk)로 안전하게 지운다. 순환 FK 방어로 mysql 은
+            // FOREIGN_KEY_CHECKS 를 잠시 끈다(F4 · 결정 275).
+            const isMysql = target.dialect.name === 'mysql';
+            if (isMysql)
+                await sql.raw('set foreign_key_checks = 0').execute(target.db);
+            try {
+                for (const t of userTables) {
+                    await sql.raw(target.dialect.dropTable(t)).execute(target.db);
+                    droppedTables.push(t);
+                }
+                // 이력 테이블 삭제 — 존재하지 않아도 에러 없게.
+                await sql.raw(`drop table if exists ${MIGRATIONS_TABLE}`).execute(target.db);
+            }
+            finally {
+                if (isMysql)
+                    await sql.raw('set foreign_key_checks = 1').execute(target.db);
             }
-            // 이력 테이블 삭제 — 존재하지 않아도 에러 없게.
-            await sql.raw(`drop table if exists ${MIGRATIONS_TABLE}`).execute(target.db);
         }
     }
     finally {

package/dist/db/resolve.js

@@ -128,6 +128,13 @@ export async function resolveDbTarget(opts) {
             `  등록된 키: ${known.length ? known.join(', ') : '(없음)'}\n` +
             `  → gaon.config.ts 의 db.${dbKey} 를 선언하고 다시 실행하세요.`);
     }
+    // 결정 279(§7.4): 문서형(mongodb) 커넥션은 마이그레이션이 없다 — SQL 전용 경로(diff/migrate/
+    // introspect)로 흘리지 않고 명확히 안내한다. 몽고 인덱스는 Mongoose 스키마 선언으로 관리한다.
+    if (connCfg.adapter === 'mongodb') {
+        throw new Error(`[gaon db] 커넥션 '${dbKey}' 은 문서형(mongodb)입니다 — 문서형은 마이그레이션이 없습니다(§7.4).\n` +
+            `  → 몽고 인덱스는 Mongoose 스키마 선언(index:true / schema.index())으로 관리합니다(dev 자동 ensureIndexes).\n` +
+            `  → gaon db diff/migrate 는 SQL 커넥션(postgres·mysql)에만 실행하세요.`);
+    }
     const db = createDb(connCfg);
     registerConnection(dbKey, db, connCfg.adapter);
     const dialect = dialectFor(connCfg.adapter);

package/dist/doctor/schema-relations.js

@@ -13,12 +13,16 @@
 // belongsTo 를 검출할 수 있다(resolve.ts scanTables 는 단일 dbKey 로 거르므로 부적합).
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import { scanSchemaDir, checkCrossConnectionRelations, checkRelationTargets, } from '@gaonjs/data';
+import { scanSchemaDir, checkCrossConnectionRelations, checkRelationTargets, checkPartitions, } from '@gaonjs/data';
 import { registerTsResolve } from '../tsResolve.js';
 /** TableDef 판별 — scanSchemaDir 이 준 모듈 네임스페이스에서 table() 산출만 고른다. */
 function isTableDef(v) {
     return (typeof v === 'object' &&
         v !== null &&
+        // 결정 279(§4.3·§6.2): 문서형 collection() 산출(__gaonKind)은 크로스커넥션 관계 로드에서
+        // 제외한다 — SQL↔문서형 belongsTo/hasMany 는 애초에 관계 그래프에 오르지 않는다(추가 코드
+        // 없이 격리 · generator.ts isTableDef 와 동일 판별).
+        !('__gaonKind' in v) &&
         'name' in v &&
         'defs' in v &&
         'db' in v &&
@@ -108,6 +112,7 @@ export async function checkSchemaRelations(cwd) {
     const diags = [
         ...checkCrossConnectionRelations(tables),
         ...checkRelationTargets(tables),
+        ...checkPartitions(tables), // 결정 277 — 파티션 키 컬럼 존재 검사
     ];
     const issues = diags.map((d) => toCheck(d, fileOf, ownerOf(d.message)));
     return { rule: 'schema-relations', issues };

package/dist/mcp/tools.js

@@ -201,6 +201,7 @@ export async function getSchemaTool(args, cwd) {
             index: t.constraints.index,
             check: t.constraints.check,
         },
+        partitionBy: t.partitionBy ? { strategy: t.partitionBy.strategy, columns: [...t.partitionBy.columns] } : undefined,
     }));
     const lines = [];
     if (tables.length === 0) {
@@ -231,10 +232,23 @@ export async function getSchemaTool(args, cwd) {
             const chk = t.constraints.check ?? [];
             if (uniq.length > 0)
                 lines.push(`  unique: ${uniq.map((u) => `[${u.join(', ')}]`).join(', ')}`);
+            // 인덱스 원소는 문자열 배열(btree) 또는 method/partial/표현식 객체(결정 273).
             if (idx.length > 0)
-                lines.push(`  index:  ${idx.map((u) => `[${u.join(', ')}]`).join(', ')}`);
+                lines.push(`  index:  ${idx
+                    .map((u) => {
+                    if (Array.isArray(u))
+                        return `[${u.join(', ')}]`;
+                    const o = u;
+                    const target = o.expr ?? `[${(o.cols ?? []).join(', ')}]`;
+                    const usingSfx = o.using ? ` using ${o.using}` : '';
+                    const whereSfx = o.where ? ` where ${o.where}` : '';
+                    return `${target}${usingSfx}${whereSfx}`;
+                })
+                    .join(', ')}`);
             if (chk.length > 0)
                 lines.push(`  check:  ${chk.map(([n]) => n).join(', ')}`);
+            if (t.partitionBy)
+                lines.push(`  partition: ${t.partitionBy.strategy} (${t.partitionBy.columns.join(', ')})`);
         }
         lines.push('');
         lines.push(`총 ${tables.length}개 테이블`);

package/dist/templates/project/AGENTS.md.tpl

@@ -137,7 +137,7 @@ Gaon 의 제1 설계 목표는 **"AI 가 개발을 가장 잘하는 프레임웍
 22. `page-layout-breakpoint` — 페이지 파일이 레이아웃 브레이크포인트(`sm:flex-row`·`md:grid-cols-2` 등)를 직접 사용(반응형은 UI 킷 블록이 책임 · `PageShell` 등으로 감싸라 · 킷에 없는 표현이면 그대로 둬도 됨 · 표시/타이포/여백 반응형은 오탐 방지로 제외) (결정 107 · 안내 경고)
 23. `link-button-nesting` — `<Link><Button>…</Button></Link>` 이중 감싸기(`<a><button>` 중첩 · HTML 비준수·접근성 결함 · 버튼 모양 링크는 `<Button href="…">` 한 표면을 쓰라 · Link 직계 자식 Button 만 검출) (결정 113 · 경고)
 24. `seal-security` — `@gaonjs/seal` 을 켠 앱에서 (a) `gaon.config.ts` 가 진짜 방어층(rate limit·보안 헤더·CORS)을 **명시적으로 껐을** 때 = 봉인을 켜고 방어를 끄는 역전 **경고**, (b) `main.ts` 가 seal 클라이언트를 배선(`@gaonjs/seal/client` 정적 import + `createGaonApp` sealClient)하지 않았을 때 = 봉인 문서를 브라우저가 못 열어 blank 가 되는 **에러**(`gaon doctor --fix --yes` 의 `seal-client-wiring` fixer 가 자동 배선). seal 은 서버 검증을 대체하지 않는다 (결정 121·124 · `agents/seal.md`)
-25. `schema-relations` — 커넥션을 가로지르는 belongsTo·역방향 관계(SQL 조인이 커넥션을 못 넘음)와 존재하지 않는 관계 대상 = **에러**(§4.5). data 패키지 검사(`checkCrossConnectionRelations`·`checkRelationTargets`)를 CLI 러너가 배선 — 배포 후 raw postgres 에러 대신 doctor 가 잡는다 (결정 134 · `agents/data.md`)
+25. `schema-relations` — 커넥션을 가로지르는 belongsTo·역방향 관계(SQL 조인이 커넥션을 못 넘음)와 존재하지 않는 관계 대상 = **에러**(§4.5). **파티션 키 컬럼이 실제 컬럼인지도 검사**(결정 277 · `checkPartitions` — 오타·유령 컬럼). data 패키지 검사(`checkCrossConnectionRelations`·`checkRelationTargets`·`checkPartitions`)를 CLI 러너가 배선 — 배포 후 raw postgres 에러 대신 doctor 가 잡는다 (결정 134·277 · `agents/data.md`)
 26. `no-import-meta-env` — `.vue`(SFC) `<script>` 에서 `import.meta.env` 직접 사용 = **에러**. SFC 는 nodenext 아래 CommonJS 출력으로 분류돼 vue-tsc 가 TS1470 로 거부한다(`gaon check` red). 클라 공개 환경변수는 `import { env } from 'gaonjs/vue'` 로 읽으라(VITE_* 접두 제거·타입드 · `.gaon/env.d.ts` 는 `.env` 스캔 생성) — 템플릿 프로즈·주석의 언급은 오탐 제외 (결정 198 · `agents/frontend.md` §9)
 27. `locale-parity` — `locales/` 의 로케일 간 키 부분 누락 = **경고**. 어떤 키가 특정 로케일에만 빠지면 `messages.d.ts`(기준 로케일 기준)는 컴파일을 통과하고, 런타임에 그 로케일 사용자는 fallback(대개 다른 언어) 번역을 조용히 본다. 검사가 로케일 간 키 diff 를 계산해 빠진 파일·키를 짚는다(`--json` 은 `detail.missing` 으로 구조화). 로케일이 0·1개면 무소음 (결정 216 · `agents/i18n.md`)
 

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

@@ -147,24 +147,71 @@ import 하면 순환 참조가 생기므로, 실제 연결은 부팅 시 프레
   — 단 레코드를 손으로 재구성하거나 JSON 왕복하면 마커가 사라지니 그럴 땐 hidden
   컬럼을 직접 넣지 않는다.
 - `.unique()` — 컬럼 레벨 UNIQUE 제약 (E-4).
-- `.index()` — 컬럼 레벨 인덱스 (E-4).
+- `.index()` — 컬럼 레벨 인덱스 (E-4). 옵션 객체로 method·partial 지정 (결정 273):
+  - `.index()` — 기본 인덱스. **jsonb 컬럼은 자동 gin**(유연 검색 `@>`·`?` 용 · The One Way), 그 외는 btree.
+  - `.index({ using: 'brin' })` — 시계열 정렬 컬럼(예: `createdAt`)에 관례로 BRIN.
+  - `.index({ where: "status = 'active'" })` — partial(부분) 인덱스.
+  - method 집합 = `btree | gin | brin | gist`. **jsonb→gin 자동은 컬럼 `.index()` 한 곳뿐** —
+    brin/gist 는 명시(과유도가 perpetual-diff 를 늘림). **`t.jsonb()` 도 `.index()` 를 가진다**(결정 273 신설).
 - `.check(expr)` — 컬럼 레벨 CHECK 제약 (E-4).
 
-**테이블 레벨 복합 제약** (E-4 §4.2):
+**테이블 레벨 복합 제약** (E-4 §4.2 · 인덱스 객체 확장 결정 273):
 
 ```ts
-export const posts = table('posts', {
-  slug: t.string().max(100),
-  ownerId: t.belongsTo('users'),
+export const logs = table('logs', {
+  userId: t.belongsTo('users'),
+  status: t.enum(['active', 'archived'] as const),
+  createdAt: t.datetime(),
+  meta: t.jsonb<Record<string, unknown>>().index(),   // 자동 gin
   ...t.timestamps(),
 }, {
-  db: 'main',                              // 커넥션 키 (§7)
-  unique: [['ownerId', 'slug']],           // 복합 unique
-  index: [['ownerId', 'createdAt']],       // 복합 index
-  check: [['positive_age', 'age > 0']],    // [name, expr]
+  db: 'main',                                          // 커넥션 키 (§7)
+  unique: [['userId', 'status']],                      // 복합 unique
+  index: [
+    ['userId', 'createdAt'],                           // 복합 btree(문자열 배열 = 기존과 동일)
+    { cols: ['meta'], using: 'gin' },                  // jsonb GIN
+    { cols: ['createdAt'], using: 'brin' },            // 시계열 BRIN
+    { cols: ['status'], where: "status = 'active'" },  // partial
+    { expr: "(meta->>'tenant')" },                     // 표현식 인덱스(이름 자동 · 해시)
+  ],
+  check: [['positive_age', 'age > 0']],                // [name, expr]
+})
+```
+
+- 인덱스 원소가 **문자열 배열**이면 기존과 100% 동일(btree). **객체**면 `cols`·`expr`·`using`·`where`·`name`.
+- 프레임웍이 만든 인덱스는 **`idx_` 접두**만 관리한다 — raw(수동 튜닝) 인덱스는 diff 가 건드리지
+  않으니(drop 계획 안 함), 손수 만든 특수 인덱스는 `idx_` 아닌 이름으로 둔다.
+- **MySQL/MariaDB(legacy §4.5) 커넥션은 gin/brin/gist·partial·표현식 인덱스가 없다** — 선언하면
+  `gaon db migrate` 가 **명확히 실패**한다(조용히 btree 로 떨구지 않음). 이런 인덱스는 main(postgres)에.
+
+**선언적 파티셔닝** (결정 277 · PostgreSQL · 대용량 로그/이벤트/감사):
+
+```ts
+export const logs = table('logs', {
+  id: t.id(),
+  createdAt: t.datetime(),
+  meta: t.jsonb<Record<string, unknown>>().index(),      // 자동 gin
+}, {
+  partitionBy: { strategy: 'range', columns: ['createdAt'] },  // 부모만 선언
 })
 ```
 
+- 전략은 `range | list | hash`. **부모 테이블만 선언**한다 — 파티션 키는 PK 에 자동 편입된다
+  (복합 PK `(id, createdAt)`). 개별 **자식 파티션은 스키마 밖**(시간에 따라 증식)이라 헬퍼로 관리한다:
+  ```ts
+  // domain/schedule.ts — 크론 잡으로 명시 실행(자동 마법 없음)
+  import { rollMonthlyPartitions } from 'gaonjs/data'
+  await rollMonthlyPartitions(db, { table: 'logs', ahead: 1, keep: 6 })
+  // ahead=다가올 개월 미리 생성 · keep=6 이면 6개월 지난 파티션 파기(keep 없으면 파기 안 함)
+  ```
+  저수준 헬퍼: `createRangePartition`·`createListPartition`·`createHashPartition`·`createDefaultPartition`·
+  `dropPartition`·`listPartitions`. **retention(오래된 파티션 파기)은 절대 자동으로 하지 않는다** —
+  `keep` 을 명시하고 그 잡을 실행할 때만 지운다(결정 39 자동 DROP 금지 정신).
+- MySQL/MariaDB 커넥션은 선언적 파티셔닝을 지원하지 않는다(migrate 시 fail-loud).
+
+**`t.timestamps()` 와 `update()`** (결정 276): `update()` 는 `updatedAt` 을 **자동으로 현재 시각으로
+갱신**한다(patch 에 `updatedAt` 을 직접 주면 그 값을 존중). 값 변경 없이 시각만 올리려면 `touch()`.
+
 ### 4. 체이닝 전체 (`packages/data/src/model.ts`)
 
 체이닝 표면은 아래 표가 **전부**다. 표에 없는 메서드
@@ -398,6 +445,73 @@ export const PlaceOrder = service(async (input: { userId: string; total: number
 - **왜 `afterCommit`** — main 이 롤백되면 analytics 기록도 일어나지 않아야 한다.
   `afterCommit` 은 커밋이 성공한 경우에만 콜백을 돈다(§9 · `agents/async.md`).
 
+### 7.1 문서형 컬렉션 — `collection()` (v1.1 · `@gaonjs/adapter-mongo` · 결정 278~282)
+
+SQL `model()`(Kysely) 옆에 문서형 동사 `collection()` 을 **Mongoose** 위에 둔다.
+로그·이벤트·감사·분석처럼 **문서·유연 스키마·대량 append** 용도다. **`model()` 은
+SQL 전용 · `collection()` 은 문서형** — 한 동사가 두 세계를 처리하지 않는다(The One Way).
+
+문서형은 **opt-in 설치**다(SQL 전용 프로젝트는 mongoose 를 받지 않는다):
+
+```bash
+npm i @gaonjs/adapter-mongo mongoose
+```
+
+```ts
+// domain/schema/auditLog.ts — mongoSchema() 는 진짜 Mongoose Schema 를 반환한다.
+import { collection, mongoSchema } from 'gaonjs/data'
+
+const auditLogSchema = mongoSchema({
+  actorId: { type: String, required: true, index: true },
+  action:  { type: String, required: true },
+  ip:      { type: String, hidden: true },   // 직렬화 경계 제외 (SQL .hidden() 과 동일 의미)
+}, { timestamps: true })
+
+// 순수 Mongoose 관례 — Gaon 이 메서드 DSL 을 재발명하지 않는다.
+auditLogSchema.statics.recent = function (limit: number) {
+  return this.find().sort({ createdAt: -1 }).limit(limit).lean()
+}
+
+// db: 'logs' — 몽고 커넥션 바인딩 (SQL 의 { db: 'legacy' } 와 대칭)
+export const AuditLog = collection('audit_logs', auditLogSchema, { db: 'logs' })
+```
+
+```ts
+// gaon.config.ts — 문서형 커넥션은 adapter: 'mongodb' 로 SQL 과 나란히 선언한다.
+export default defineConfig({
+  db: {
+    main: { adapter: 'postgres', url: env('DATABASE_URL') },
+    logs: { adapter: 'mongodb',  url: env('MONGO_URL') },
+  },
+})
+```
+
+**정본 규칙**:
+- **`hidden` 은 SQL 과 같은 의미** — "서버는 읽고 직렬화만 제외". `select:false` 를
+  쓰지 않는다. render props 로 흘릴 땐 **`.lean()`** 을 쓴다(정본 경로) — `_id`(ObjectId)는
+  응답 경계에서 자동으로 string 이 된다(결정 282 · 결정 37 문서형 대응).
+- **몽고 쓰기를 SQL `service()` tx 안에서 하지 말 것** — 몽고는 v1 에서 트랜잭션이
+  없어, tx 안 몽고 쓰기는 `MongoCrossConnectionWriteError` 로 **막힌다**(조용한 부분
+  커밋 방지 · 결정 281). "커밋 후 로그" 는 `afterCommit` 으로 잇는다(§7 크로스커넥션과 동일 규율):
+  ```ts
+  export const SignUp = service(async (input) => {
+    const user = await Users.create(input)                 // main(SQL) 트랜잭션
+    afterCommit(() => AuditLog.create({ actorId: String(user.id), action: 'signup' })) // 커밋 뒤 몽고 쓰기
+    return user
+  })
+  ```
+- **SQL ↔ 문서형 관계 금지** — `belongsTo`/`hasMany` 는 SQL 전용이다. 몽고 컬렉션끼리의
+  참조는 Mongoose `ref`/`populate` 로 사용자가 직접 한다(Gaon doctor 가 강제하지 않음).
+- **인덱스 = Mongoose 스키마 선언**(`index: true` / `schema.index()`) — dev 는 자동
+  `ensureIndexes`. 몽고는 마이그레이션이 없다(`gaon db diff/migrate` 는 mongo 를 건너뛴다).
+
+**알려진 함정**:
+- `aggregate` 결과는 임의 projection(그룹·계산)이라 `hidden` 마커를 심지 **않는다** —
+  SQL `Post.query()`(Kysely 원본) raw 탈출구가 hidden 을 우회하는 것과 동형. 문서를
+  안전하게 렌더에 흘리려면 `find()/findOne().lean()` 을 쓴다.
+- 인스턴스 `document.save()` 는 크로스커넥션 가드 밖이다 — 정본 쓰기는 static
+  `create/update/delete`(가드 대상). tx 안에서 쓸 일이면 `afterCommit` 으로 미룬다.
+
 ### 8. 모델 정의 (`model()`) (`packages/data/src/model.ts`)
 
 `model()` 은 스키마(§1)를 Kysely 위의 실행 가능한 API 로 감싼다 —
@@ -895,4 +1009,8 @@ await Post.upsert({ id, title, body })                // onConflict 생략 = 기
 | 결정 221 | 크로스 커넥션 트랜잭션 런타임 가드 — tx 안 다른 커넥션 **쓰기**(INSERT/UPDATE/DELETE) throw · **읽기는 예외** · 중첩 서비스/afterCommit/tx:false 는 자기 경계로 통과(§5 · 규칙 9) |
 | 결정 253 | hidden 마커를 **열거 가능한 심볼**로 부여 — `{ ...row }` spread·`Object.assign` 을 넘어 보존돼 우회 유출(S1) 봉합(§1) |
 | 결정 265 | 조인 시 자기 테이블 컬럼 자동 한정 — `where`/`whereAny`/`orderBy` 가 자기 테이블로 한정돼 ambiguous column 방지(§4 join) |
+| 결정 278 | 문서형 동사 `collection()`(Mongoose) — SQL `model()` 과 분리 · `mongoSchema()` 얇은 래퍼(판별 태그+hidden 전개) · `@gaonjs/adapter-mongo`(mongoose optional peer)(§7.1) |
+| 결정 279 | 문서형 커넥션 `adapter: 'mongodb'`(config `db` 맵) · `isTableDef` 가 collection 제외(tables.d.ts·doctor) · `gaon db` mongo 마이그 fail-loud(§7.1) |
+| 결정 281 | 몽고 쓰기를 SQL `service()` tx 안에서 하면 `MongoCrossConnectionWriteError` 로 막힘 — "커밋 후 로그" 는 `afterCommit`(§7.1 · 결정 221 동형) |
+| 결정 282 | ObjectId(`_id` 포함) → string 직렬화 정규화(응답 경계 · 결정 37 문서형 대응 · `.lean()` 권장)(§7.1) |
 | E-4 | 컬럼 타입·수식어·체이닝 확장 · `Post.query()` 정정 · Serialized 명명 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.42.3",
+  "version": "0.43.0",
   "description": "Gaon CLI — 스캐폴딩·제너레이터·마이그레이션·dev/serve/work/hub·doctor·check (bin: gaon)",
   "type": "module",
   "license": "MIT",
@@ -28,12 +28,12 @@
     "typescript": "^5.9.0",
     "vite": "^7.0.0",
     "@gaonjs/async": "0.15.3",
-    "@gaonjs/config": "0.18.1",
+    "@gaonjs/config": "0.19.0",
+    "@gaonjs/data": "0.21.0",
     "@gaonjs/core": "0.2.4",
-    "@gaonjs/data": "0.17.3",
     "@gaonjs/i18n": "0.2.4",
-    "@gaonjs/mail": "0.3.3",
-    "@gaonjs/web": "0.20.5"
+    "@gaonjs/web": "0.21.0",
+    "@gaonjs/mail": "0.3.3"
   },
   "scripts": {
     "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"require('fs').cpSync('src/templates','dist/templates',{recursive:true})\""

package/dist/doctor/shared-composable-purity.d.ts

@@ -1,8 +0,0 @@
-import type { DoctorCheck, RuleReport } from './types.js';
-/**
- * 단일 shared 컴포저블 소스를 검사해 순수성 위반 목록을 낸다
- * (단위 테스트 진입점).
- */
-export declare function inspectSharedComposable(file: string, source: string, cwd: string): DoctorCheck[];
-/** shared/composables/ 를 훑어 순수성 위반을 모두 낸다. */
-export declare function checkSharedComposablePurity(cwd: string): Promise<RuleReport>;

package/dist/doctor/shared-composable-purity.js

@@ -1,164 +0,0 @@
-// @gaonjs/cli · doctor · shared 컴포저블 순수성 검사 (M9-E 확장 · errata E-5 §2.2)
-//
-// shared/composables/ 는 shared 컴포넌트의 "props 로만" 규칙과 정확히
-// 같은 구도를 따른다. 라우트를 몰라야 하고(api·pageProps 금지) · domain
-// 은 타입으로만 참조해야 한다. 필요한 데이터·호출 함수는 인자로 받는다.
-// 정본 근거: errata E-5 §2.2 (컴포저블·레이아웃 관례 · 결정 25).
-//
-// 검사 대상:
-//  1) 프레임웍 모듈(gaonjs · gaonjs/vue · @gaonjs/vue · @gaonjs/web) 에서
-//     'api' · 'pageProps' 를 value import 하면 error.
-//     - type-only 는 무해(구조 참조뿐 · 라우트 지식 필요 없음).
-//  2) domain 을 value import 하면 error.
-//     - type-only 는 허용(모델 Row 타입 등 · 순수 타입 참조).
-//
-// 방법: shared/composables/*.ts 를 TS AST 로 파싱해 import 선언만 훑는다.
-// 상대 import 는 실 파일까지 해석하지 않고 경로 접두사(domain/) 로 판정 —
-// 이 검사는 순수성 게이트라 정확도보다 재현성이 우선(false positive 는
-// 오히려 안전).
-import { readdir, readFile } from 'node:fs/promises';
-import { join, relative, resolve, dirname } from 'node:path';
-import ts from 'typescript';
-/** 라우트 지식을 담은 심볼 — shared 는 참조할 수 없다. */
-const FORBIDDEN_FRAMEWORK_NAMES = new Set(['api', 'pageProps']);
-/**
- * 프레임웍 모듈 패턴. 문서 표기(gaon/vue)는 실 패키지 이름의 짧은
- * 별칭이며, 실 배포본은 gaonjs 파사드 subpath 와 @gaonjs 스코프를 쓴다.
- * 하나만 잡으면 우회가 쉬우므로 알려진 표기 3종을 모두 매치한다.
- */
-const FRAMEWORK_MODULE_PATTERNS = [
-    /^gaonjs$/,
-    /^gaonjs\/vue$/,
-    /^@gaonjs\/vue$/,
-    /^@gaonjs\/web$/,
-];
-/** import 선언에서 이름과 type-only 플래그를 추출한다. */
-function collectImportedNames(node) {
-    const out = [];
-    const clause = node.importClause;
-    if (!clause)
-        return out;
-    const clauseTypeOnly = clause.isTypeOnly;
-    if (clause.name)
-        out.push({ name: clause.name.text, typeOnly: clauseTypeOnly });
-    const bindings = clause.namedBindings;
-    if (bindings) {
-        if (ts.isNamespaceImport(bindings)) {
-            out.push({ name: bindings.name.text, typeOnly: clauseTypeOnly });
-        }
-        else if (ts.isNamedImports(bindings)) {
-            for (const el of bindings.elements) {
-                out.push({ name: el.name.text, typeOnly: clauseTypeOnly || el.isTypeOnly });
-            }
-        }
-    }
-    return out;
-}
-function isRelativeSpecifier(s) {
-    return s.startsWith('./') || s.startsWith('../');
-}
-function matchesFrameworkModule(spec) {
-    return FRAMEWORK_MODULE_PATTERNS.some((re) => re.test(spec));
-}
-/**
- * 단일 shared 컴포저블 소스를 검사해 순수성 위반 목록을 낸다
- * (단위 테스트 진입점).
- */
-export function inspectSharedComposable(file, source, cwd) {
-    const issues = [];
-    const rel = relative(cwd, file);
-    const sf = ts.createSourceFile(file, source, ts.ScriptTarget.ES2022, true);
-    const baseDir = dirname(file);
-    const visit = (node) => {
-        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-            const spec = node.moduleSpecifier.text;
-            const { line } = sf.getLineAndCharacterOfPosition(node.getStart(sf));
-            const names = collectImportedNames(node);
-            // 1) 프레임웍의 api/pageProps 를 value import → error
-            if (matchesFrameworkModule(spec)) {
-                for (const n of names) {
-                    if (n.typeOnly)
-                        continue; // type-only 는 라우트 실행 지식이 아님
-                    if (!FORBIDDEN_FRAMEWORK_NAMES.has(n.name))
-                        continue;
-                    issues.push({
-                        rule: 'shared-composable-purity',
-                        level: 'error',
-                        file: rel,
-                        line: line + 1,
-                        message: `${rel} (line ${line + 1})\n` +
-                            `  '${spec}' 의 '${n.name}' import 발견 · shared 는 라우트를 몰라야 함\n` +
-                            `→ 옵션: apps/<앱>/composables/ 로 옮기거나 · ${n.name} 호출을 인자로 받도록 바꾸라`,
-                        detail: {
-                            kind: 'framework-api',
-                            module: spec,
-                            name: n.name,
-                        },
-                    });
-                }
-            }
-            // 2) domain value import → error (type-only 는 허용)
-            if (isRelativeSpecifier(spec)) {
-                const abs = resolve(baseDir, spec);
-                const parts = relative(cwd, abs).split(/[\\/]/).filter(Boolean);
-                if (parts[0] === 'domain') {
-                    const valueNames = names.filter((n) => !n.typeOnly);
-                    if (valueNames.length > 0) {
-                        issues.push({
-                            rule: 'shared-composable-purity',
-                            level: 'error',
-                            file: rel,
-                            line: line + 1,
-                            message: `${rel} (line ${line + 1})\n` +
-                                `  domain 값 import 발견 · shared 컴포저블은 domain 을 타입으로만 참조해야 함\n` +
-                                `→ 'import type { ... } from ...' 형태로 바꾸거나 · 필요한 값은 인자로 받도록 바꾸라`,
-                            detail: {
-                                kind: 'domain-value',
-                                module: spec,
-                                names: valueNames.map((n) => n.name),
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
-    return issues;
-}
-/** shared/composables/ 를 훑어 순수성 위반을 모두 낸다. */
-export async function checkSharedComposablePurity(cwd) {
-    const composablesDir = join(cwd, 'shared', 'composables');
-    const files = [];
-    await collectTsFiles(composablesDir, files);
-    const issues = [];
-    for (const file of files) {
-        const src = await readFile(file, 'utf8');
-        issues.push(...inspectSharedComposable(file, src, cwd));
-    }
-    return { rule: 'shared-composable-purity', issues };
-}
-async function collectTsFiles(root, out) {
-    let entries;
-    try {
-        entries = (await readdir(root, { withFileTypes: true }));
-    }
-    catch {
-        return;
-    }
-    for (const e of entries) {
-        const name = e.name;
-        if (name === 'node_modules' || name === 'dist' || name === '.gaon')
-            continue;
-        const full = join(root, name);
-        if (e.isDirectory())
-            await collectTsFiles(full, out);
-        else if (e.isFile() &&
-            name.endsWith('.ts') &&
-            !name.endsWith('.d.ts') &&
-            !name.endsWith('.test.ts')) {
-            out.push(full);
-        }
-    }
-}