@gaonjs/cli 0.52.0 → 0.56.0

package/dist/commands/check.d.ts

@@ -40,6 +40,8 @@ export interface CheckRegen {
     readonly tables: boolean;
     /** routes.d.ts 를 재생성한 앱 이름. */
     readonly apps: readonly string[];
+    /** messages.d.ts(i18n 카탈로그 키 유니온)를 재생성했는가 — 결정 414(축 보고 누락 봉합). */
+    readonly messages?: boolean;
     /** 실패 시 에러 + 수리 안내. done/skipped 는 undefined. */
     readonly output?: string;
 }

package/dist/commands/check.js

@@ -32,6 +32,8 @@ import { generateTablesDts } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
 import { computeDoctorResult } from '../doctor.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
+import { analyzeProjectI18n, resolveLocalesDir } from '../i18n-config.js';
+import { loadLocales } from '@gaonjs/i18n';
 import { registerTsResolve } from '../tsResolve.js';
 import { listFrontendApps, verifyAppDist } from '../dev/build.js';
 import { generateMessagesDts } from '../messages-gen.js';
@@ -239,9 +241,41 @@ async function runDoctorStep(cwd) {
  * 실패를 내지 않게 한다. --only 여부와 무관하게 항상 먼저 돈다 —
  * typecheck·vue-tsc·build 가 모두 .gaon 을 소비하기 때문.
  */
+/**
+ * 결정 413: 결정 353(부팅 fail-loud)의 정적 미러 — i18n 을 켰는데 카탈로그가 비었거나
+ * fallbackLng/supportedLngs 가 지목한 파일이 없으면 부팅이 죽는다. 같은 사유·같은 수리
+ * 안내를 check 단계에서 먼저 낸다. 정적으로 못 읽은 키는 건너뛴다(결정 412 경고가 별도로 알림).
+ */
+function verifyI18nCatalogs(cwd) {
+    const cfg = analyzeProjectI18n(cwd);
+    if (!cfg.declared)
+        return undefined;
+    const dir = cfg.dir ?? 'locales';
+    const abs = resolveLocalesDir(cwd, cfg.dir);
+    const resources = existsSync(abs) ? loadLocales(abs) : {};
+    if (Object.keys(resources).length === 0) {
+        return (`i18n 이 설정됐지만 로케일 카탈로그가 비어 있습니다: ${abs}\n` +
+            `  → ${dir}/${cfg.fallbackLng ?? '<fallbackLng>'}.json 을 만들거나(최소 fallbackLng 카탈로그),\n` +
+            `  → gaon.config.ts 의 i18n.dir 이 실제 카탈로그 폴더를 가리키는지 확인하세요.\n` +
+            `  (이 상태로는 gaon serve 가 부팅에서 실패합니다 — 결정 353)`);
+    }
+    const wanted = [...(cfg.fallbackLng ? [cfg.fallbackLng] : []), ...(cfg.supportedLngs ?? [])];
+    const missing = wanted.filter((lng, i, arr) => arr.indexOf(lng) === i && !resources[lng]);
+    if (missing.length > 0) {
+        return (`i18n 설정이 지목한 로케일의 카탈로그 파일이 없습니다: ${missing.join(', ')}\n` +
+            `  → ${dir}/ 에 ${missing.map((l) => `${l}.json`).join(' · ')} 을 추가하거나,\n` +
+            `  → gaon.config.ts 의 fallbackLng/supportedLngs 에서 해당 로케일을 제거하세요.\n` +
+            `  (이 상태로는 gaon serve 가 부팅에서 실패합니다 — 결정 353)`);
+    }
+    return undefined;
+}
 async function regenerateGaon(cwd) {
     const layout = resolveDevLayout(cwd);
     if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
+        // 카탈로그가 통째로 없어도 config 가 i18n 을 켰으면 부팅이 죽는다 — 그 경우만 잡는다.
+        const problem = verifyI18nCatalogs(cwd);
+        if (problem)
+            return { status: 'failed', tables: false, apps: [], output: problem };
         return { status: 'skipped', tables: false, apps: [] };
     }
     // 생성기는 사용자 스키마·컨트롤러 .ts 를 동적 import 한다. TS-for-ESM
@@ -255,7 +289,15 @@ async function regenerateGaon(cwd) {
             regenerateMessages: generateMessagesDts,
             regenerateEnv: generateEnvDts,
         });
-        return { status: 'done', tables: result.tables, apps: result.apps };
+        // 결정 413: 부팅(결정 353)이 throw 하는 조건을 **정적으로 미리** 본다 — check 는
+        // AI 자가검증의 정본 경로인데, 통과해 놓고 `gaon serve` 가 죽으면 자가검증이
+        // 부팅 가능성을 담보하지 못한다(i18n 한정 구멍). 재료(dir·fallbackLng·supportedLngs)는
+        // 이미 정적으로 있다.
+        const i18nProblem = verifyI18nCatalogs(cwd);
+        if (i18nProblem) {
+            return { status: 'failed', tables: result.tables, apps: result.apps, messages: result.messages, output: i18nProblem };
+        }
+        return { status: 'done', tables: result.tables, apps: result.apps, messages: result.messages };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/dist/commands/db.js

@@ -79,6 +79,15 @@ export async function runDbCommand(subcommand, opts = {}) {
                 emit(r.text, r.json);
                 return r.exitCode;
             }
+            // 결정 367: seed 는 커넥션별 반복이 아니라 **1회 실행**이다 — domain/seed.ts 는
+            // 프로젝트 단일 시드라 키당 재실행하면 중복 삽입이고, 패스마다 단일 커넥션만
+            // 등록해 타 커넥션 모델이 '미등록' throw 로 순회가 항상 exit 1 이었다.
+            // runDbSeedCommand 가 선언된 전 SQL 커넥션을 등록하고 한 번 실행한다.
+            if (subcommand === 'seed') {
+                const r = await runDbSeedCommand({ root: cwd, json, configPath });
+                emit(r.text, r.json);
+                return r.exitCode;
+            }
             return runAcrossConnections(subcommand, keys, runOne, emit, json, mongoKeys);
         }
         // 단일 커넥션 경로(--db <키> · reset · env-only 폴백) — 종전 동작 그대로.

package/dist/commands/gen.d.ts

@@ -13,6 +13,8 @@ export interface GenResult {
     readonly apps: readonly string[];
     /** env.d.ts 를 재생성했는가(프론트 앱 존재 · 결정 198). */
     readonly env?: boolean;
+    /** messages.d.ts 를 재생성했는가(locales/ 존재 · 결정 158). 결정 414: 재생성만 하고 보고에서 빠져 있었다. */
+    readonly messages?: boolean;
     /** 실패 시 에러 + 수리 안내. */
     readonly error?: string;
 }

package/dist/commands/gen.js

@@ -48,7 +48,7 @@ export async function runGenCommand(opts = {}) {
     let result;
     try {
         const r = await regenerateProjectGaon(cwd);
-        result = { ok: true, skipped: r.skipped, tables: r.tables, apps: r.apps, env: r.env };
+        result = { ok: true, skipped: r.skipped, tables: r.tables, apps: r.apps, env: r.env, messages: r.messages };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -77,6 +77,8 @@ export async function runGenCommand(opts = {}) {
         for (const app of result.apps) {
             parts.push(`apps/${app}/.gaon/routes.d.ts`, `apps/${app}/.gaon/routes.manifest.ts`);
         }
+        if (result.messages)
+            parts.push('.gaon/messages.d.ts');
         if (result.env)
             parts.push('.gaon/env.d.ts');
         process.stdout.write(`  ✓ gaon gen — ${parts.join(', ')}\n`);

package/dist/commands/new.js

@@ -44,6 +44,19 @@ export function validateProjectName(name) {
             `    대문자·언더스코어(_)는 인프라 기동·버킷 생성에서 실패합니다.\n` +
             `  → 예: gaon new my-app · gaon new demo`);
     }
+    // 결정 409: 결정 315 가 남긴 같은 클래스의 잔여 두 갈래 — 버킷명은 **영숫자로 끝나야**
+    // 하고 **3~63자**여야 한다. 종전 정규식은 'my-app-'·'ab' 를 통과시켜 생성은 성공하고
+    // `gaon dev` 의 버킷 생성(mc mb)에서 뒤늦게 깨졌다.
+    if (name.endsWith('-')) {
+        throw new Error(`프로젝트 이름은 하이픈(-)으로 끝날 수 없습니다: ${name}\n` +
+            `  → 스토리지 버킷명은 영문/숫자로 끝나야 해 'mc mb' 가 실패합니다.\n` +
+            `  → 예: gaon new ${name.replace(/-+$/, '')}`);
+    }
+    if (name.length < 3 || name.length > 63) {
+        throw new Error(`프로젝트 이름은 3~63자여야 합니다(현재 ${name.length}자): ${name}\n` +
+            `  → 이름이 스토리지 버킷명으로 그대로 쓰이고, 버킷명 길이 제한이 3~63자입니다.\n` +
+            `  → 예: gaon new my-app`);
+    }
 }
 /**
  * 파사드(gaonjs) 패키지의 실 버전을 찾는다 — package.json 을 위로 훑는다.

package/dist/commands/test.js

@@ -94,8 +94,19 @@ async function provisionTestDatabases(cwd, json, onOutput) {
     if (dbs.length === 0)
         return true;
     const prepared = [];
+    // 결정 279·292: 문서형(mongodb)은 SQL 프로비저닝(CREATE DATABASE + 마이그레이션)이 없다 —
+    // 순회에서 건너뛰고 보고에만 남긴다. 이 skip 이 없으면 SQL 전용 deriveTestDatabaseConfig/
+    // ensureTestDatabaseExists 가 몽고 커넥션에 pg/mysql 드라이버로 붙으려다 throw 해,
+    // 몽고 커넥션이 하나라도 있는 프로젝트는 `gaon test` 가 테스트 실행 전에 즉사했다
+    // (testkit·`gaon db` 는 이미 건너뛰는데 CLI test 만 빠진 비대칭). 테스트 레인의 몽고
+    // 커넥션 자체는 connectTestDatabase(@gaonjs/config testkit)가 등록한다.
+    const skippedMongo = [];
     try {
         for (const [key, cfg] of dbs) {
+            if (cfg.adapter === 'mongodb') {
+                skippedMongo.push(key);
+                continue;
+            }
             const testCfg = deriveTestDatabaseConfig(cfg);
             await ensureTestDatabaseExists(testCfg);
             const res = await runDbMigrate({
@@ -130,10 +141,23 @@ async function provisionTestDatabases(cwd, json, onOutput) {
     finally {
         await destroyAllConnections();
     }
-    if (json)
-        writeOut(JSON.stringify({ kind: 'provisioned', dbs: prepared }) + '\n');
-    else
-        writeOut(`  gaon test · 테스트 DB 준비 완료 (${prepared.join(', ')}) — <db>_test\n`);
+    if (json) {
+        writeOut(JSON.stringify({
+            kind: 'provisioned',
+            dbs: prepared,
+            skipped: skippedMongo.map((db) => ({ db, adapter: 'mongodb', reason: 'documental-no-migration' })),
+        }) + '\n');
+    }
+    else {
+        // SQL 커넥션이 하나도 없으면(문서형 전용 프로젝트) "준비 완료 ()" 대신 건너뜀만 알린다.
+        if (prepared.length > 0) {
+            writeOut(`  gaon test · 테스트 DB 준비 완료 (${prepared.join(', ')}) — <db>_test\n`);
+        }
+        if (skippedMongo.length > 0) {
+            writeOut(`  gaon test · 문서형(mongodb) 커넥션 건너뜀: ${skippedMongo.join(', ')} — 문서형은 마이그레이션이 없습니다(§7.4).\n` +
+                `    → 테스트 레인의 몽고 커넥션은 test/setup.ts 의 connectTestDatabase() 가 <db>_test 로 등록합니다(결정 279).\n`);
+        }
+    }
     return true;
 }
 /**

package/dist/db/journal.d.ts

@@ -23,8 +23,11 @@ export declare function journalExists(db: Kysely<any>, adapter?: AdapterName): P
  * _gaon_migrations 를 만든다(존재하면 no-op). id/kind/applied_at/db_key/
  * statements/summary/down_sql — text·varchar·timestamp·integer 는 postgres·
  * mysql 공통 지원 타입. kind 기본값 'schema' 는 구버전 스키마 호환용.
+ * 결정 380: mysql 의 down_sql 은 **mediumtext**(16MB) — TEXT(64KB)는 큰 배치의
+ * down SQL(JSON 배열)이 조용히 잘려 저장 파손 위험이었다. 기존(legacy) 테이블은
+ * data_type 확인 후 한 번만 MODIFY 로 승격한다(매 실행 재빌드 방지). pg text 는 무제한.
  */
-export declare function ensureJournal(db: Kysely<any>): Promise<void>;
+export declare function ensureJournal(db: Kysely<any>, adapter?: AdapterName): Promise<void>;
 export interface RecordArgs {
     readonly id: string;
     readonly kind: MigrationKind;

package/dist/db/journal.js

@@ -41,26 +41,59 @@ export async function journalExists(db, adapter = 'postgres') {
  * _gaon_migrations 를 만든다(존재하면 no-op). id/kind/applied_at/db_key/
  * statements/summary/down_sql — text·varchar·timestamp·integer 는 postgres·
  * mysql 공통 지원 타입. kind 기본값 'schema' 는 구버전 스키마 호환용.
+ * 결정 380: mysql 의 down_sql 은 **mediumtext**(16MB) — TEXT(64KB)는 큰 배치의
+ * down SQL(JSON 배열)이 조용히 잘려 저장 파손 위험이었다. 기존(legacy) 테이블은
+ * data_type 확인 후 한 번만 MODIFY 로 승격한다(매 실행 재빌드 방지). pg text 는 무제한.
  */
-export async function ensureJournal(db) {
+export async function ensureJournal(db, adapter = 'postgres') {
+    const downType = adapter === 'mysql' ? 'mediumtext' : 'text';
     await sql
         .raw(`create table if not exists ${MIGRATIONS_TABLE} (` +
         ` id varchar(255) not null primary key,` +
         ` kind varchar(16) not null default 'schema',` +
-        ` applied_at timestamp not null,` +
+        ` applied_at timestamp(6) not null,` +
         ` db_key varchar(64) not null,` +
         ` statements integer not null,` +
         ` summary text not null,` +
-        ` down_sql text` +
+        ` down_sql ${downType}` +
         `)`)
         .execute(db);
+    if (adapter === 'mysql') {
+        // 결정 380: legacy 테이블 승격 — down_sql text→mediumtext(64KB 절단 방지) ·
+        // applied_at 초 해상 timestamp→timestamp(6)(ms 단조 증가가 저장에서 뭉개지지 않게).
+        // 둘 다 상태 확인 후 한 번만 MODIFY(매 실행 테이블 재빌드 방지).
+        const cur = await sql `
+      select column_name as c, data_type as t, datetime_precision as p
+      from information_schema.columns
+      where table_schema = database() and table_name = ${MIGRATIONS_TABLE}
+        and column_name in ('down_sql', 'applied_at')
+    `.execute(db);
+        for (const row of cur.rows) {
+            if (row.c === 'down_sql' && row.t.toLowerCase() === 'text') {
+                await sql.raw(`alter table ${MIGRATIONS_TABLE} modify down_sql mediumtext`).execute(db);
+            }
+            if (row.c === 'applied_at' && Number(row.p ?? 0) === 0) {
+                await sql.raw(`alter table ${MIGRATIONS_TABLE} modify applied_at timestamp(6) not null`).execute(db);
+            }
+        }
+    }
+}
+// 결정 380: 프로세스 내 단조 증가 applied_at — 같은 migrate 실행의 파일 리플레이·schema
+// 배치가 같은 ms 에 기록되면 롤백 대상 선정(`order by applied_at desc, id desc`)이 서로
+// 다른 id 체계(파일명 vs `<epochMs>-<n>`)의 **사전순**으로 갈려 최신이 아닌 항목을 되돌릴
+// 수 있었다. 동률이면 1ms 씩 밀어 순서를 시각에 각인한다(동시 다중 migrate 는 원래 미지원).
+let lastAppliedAtMs = 0;
+function nextAppliedAt() {
+    const now = Date.now();
+    lastAppliedAtMs = now > lastAppliedAtMs ? now : lastAppliedAtMs + 1;
+    return new Date(lastAppliedAtMs);
 }
 /** 이력 한 행을 남긴다. 호출자가 트랜잭션(trx)을 넘기면 그 안에서 실행된다. */
 export async function recordEntry(db, e) {
     await sql `
     insert into ${sql.ref(MIGRATIONS_TABLE)}
       (id, kind, applied_at, db_key, statements, summary, down_sql)
-    values (${e.id}, ${e.kind}, ${new Date()}, ${e.dbKey}, ${e.statements}, ${e.summary}, ${e.downSql})
+    values (${e.id}, ${e.kind}, ${nextAppliedAt()}, ${e.dbKey}, ${e.statements}, ${e.summary}, ${e.downSql})
   `.execute(db);
 }
 /** 가장 최근 적용된 이력(롤백 대상). 원장 미존재 시 undefined. */

package/dist/db/migrate.js

@@ -12,8 +12,7 @@
 //
 // 트랜잭션: postgres 는 트랜잭셔널 DDL 이라 각 단계가 원자적. mysql/mariadb 는
 // DDL 이 autocommit 이라 순차 실행하고 이력만 남긴다(§4.5 방언 차이).
-import { sql } from 'kysely';
-import { computeMigration, renderUp, renderDown, summarizeOp, DEFERRED_DROP_KINDS } from '@gaonjs/data';
+import { applyStatements, computeMigration, renderUp, renderDown, summarizeOp, partitionDeferredOps } from '@gaonjs/data';
 import { resolveDbTarget } from './resolve.js';
 import { ensureJournal, journalExists, recordEntry } from './journal.js';
 import { listMigrationFiles, replayPending, rollbackLast } from './replay.js';
@@ -62,12 +61,15 @@ export async function runDbMigrate(opts) {
         // 자동 적용하지 않는다** — replay 가 만든/외부 객체·수동 추가한 제약을 보호한다. 제거는
         // 손작성 마이그로 하고, 'gaon db diff' 가 계속 보여준다(조용히 넘어가지 않는다). ADD·SET
         // (unique·index·check·default 추가)은 자동 적용해 "조용한 no-op"(결정 220 배경)을 없앤다.
+        // 결정 366: 단 **재생성 쌍**(같은 이름 dropIndex→addIndex / dropCheck→addCheck — 인덱스
+        // method 변경·enum 값 변경)의 drop 반쪽은 defer 하지 않는다 — kind 만 보고 걸러내면
+        // add 반쪽이 기존 객체 위에 실행돼 "already exists" 로 migrate 가 매번 죽었다.
         const full = await computeMigration(target.db, target.tables, target.dialect);
-        const droppedTables = full.ops
+        const { apply: schemaOps, deferred } = partitionDeferredOps(full.ops);
+        const droppedTables = deferred
             .filter((o) => o.kind === 'dropTable')
             .map((o) => o.name);
-        const deferredDrops = full.ops.filter((o) => o.kind !== 'dropTable' && DEFERRED_DROP_KINDS.has(o.kind));
-        const schemaOps = full.ops.filter((o) => !DEFERRED_DROP_KINDS.has(o.kind));
+        const deferredDrops = deferred.filter((o) => o.kind !== 'dropTable');
         const plan = {
             ops: schemaOps,
             up: renderUp(schemaOps, target.dialect),
@@ -123,16 +125,14 @@ export async function runDbMigrate(opts) {
                 `    → 기존 DB 를 이어 쓰고 있었다면, 먼저 'gaon db diff' 로 계획을 확인하세요.`
             : '';
         // 3) schema-diff apply — up 을 순차 적용하고 이력 한 행(kind='schema')을 남긴다.
-        await ensureJournal(target.db);
+        await ensureJournal(target.db, target.adapter);
         const id = batchId(plan.up.length);
         const summary = JSON.stringify(ops);
         const downSql = JSON.stringify(plan.down);
         const applySchema = async (db) => {
-            for (const stmt of plan.up) {
-                if (stmt.trim().startsWith('--'))
-                    continue;
-                await sql.raw(stmt).execute(db);
-            }
+            // 결정 374: raw 실행 대신 applyStatements 경유 — 비호환 타입 변경(F5 · 결정 275)의
+            // 수리 안내(enrichAlterError · USING 절 예시)가 정본 CLI 경로에서도 나온다.
+            await applyStatements(db, [...plan.up]);
             await recordEntry(db, {
                 id,
                 kind: 'schema',

package/dist/db/replay.js

@@ -71,7 +71,7 @@ export async function replayPending(opts) {
     if (opts.dryRun || pending.length === 0) {
         return { applied: [], pending, all };
     }
-    await ensureJournal(opts.db);
+    await ensureJournal(opts.db, opts.adapter);
     const applied = [];
     for (const file of pending) {
         const mig = await loadMigration(opts.cwd, file);

package/dist/db/resolve.d.ts

@@ -1,4 +1,4 @@
-import { type ConnectionConfig, type TableDef } from '@gaonjs/data';
+import { type ConnectionConfig, type SqlConnectionConfig, type TableDef } from '@gaonjs/data';
 import type { Kysely } from 'kysely';
 import { type Dialect, type AdapterName } from '@gaonjs/data';
 export interface ResolveDbOptions {
@@ -48,4 +48,14 @@ export interface ConnectionKeysByKind {
  * config 선언이 없으면(env-only) SQL ['main'] 폴백 — listConnectionKeys 와 정합.
  */
 export declare function listConnectionKeysByKind(cwd: string, configPath?: string): Promise<ConnectionKeysByKind>;
+/**
+ * 결정 367: 선언된 **전 SQL 커넥션**의 설정 목록 — `gaon db seed` 가 시드 실행 전에
+ * 전부 등록하는 데 쓴다(시드는 커넥션을 몰라도 된다 · §10.1 — 모델이 자기 커넥션에
+ * 자동 바인딩). config 선언이 없으면(env-only) GAON_DATABASE_URL 기반 main 하나.
+ * 문서형(mongodb)은 제외(§7.4 — gaon db 는 SQL 축).
+ */
+export declare function listSqlConnectionConfigs(cwd: string, configPath?: string): Promise<Array<{
+    key: string;
+    cfg: SqlConnectionConfig;
+}>>;
 export declare function resolveDbTarget(opts: ResolveDbOptions): Promise<ResolvedDbTarget>;

package/dist/db/resolve.js

@@ -119,6 +119,23 @@ export async function listConnectionKeysByKind(cwd, configPath) {
     }
     return { sql, mongo };
 }
+/**
+ * 결정 367: 선언된 **전 SQL 커넥션**의 설정 목록 — `gaon db seed` 가 시드 실행 전에
+ * 전부 등록하는 데 쓴다(시드는 커넥션을 몰라도 된다 · §10.1 — 모델이 자기 커넥션에
+ * 자동 바인딩). config 선언이 없으면(env-only) GAON_DATABASE_URL 기반 main 하나.
+ * 문서형(mongodb)은 제외(§7.4 — gaon db 는 SQL 축).
+ */
+export async function listSqlConnectionConfigs(cwd, configPath) {
+    const { config } = await loadDbConfig(resolvePath(cwd), configPath);
+    const entries = Object.entries(config.db ?? {});
+    if (entries.length === 0) {
+        const url = env.optional('GAON_DATABASE_URL');
+        return url ? [{ key: 'main', cfg: dbConfigFromUrl(url) }] : [];
+    }
+    return entries
+        .filter(([, cfg]) => cfg?.adapter !== 'mongodb')
+        .map(([key, cfg]) => ({ key, cfg: cfg }));
+}
 export async function resolveDbTarget(opts) {
     const cwd = resolvePath(opts.cwd);
     // 사용자가 --config <path> 를 준 경우 그 경로에서 default export 를 로드한다.
@@ -153,9 +170,14 @@ export async function resolveDbTarget(opts) {
     // 결정 279(§7.4): 문서형(mongodb) 커넥션은 마이그레이션이 없다 — SQL 전용 경로(diff/migrate/
     // introspect)로 흘리지 않고 명확히 안내한다. 몽고 인덱스는 Mongoose 스키마 선언으로 관리한다.
     if (connCfg.adapter === 'mongodb') {
+        // 결정 384: 안내문을 실동작(결정 333·365)으로 정정 — 이전 문구("autoIndex 기본값이
+        // 부팅 시 보장 · dev·prod 공통")는 운영 autoIndex=false 이후 거짓 안내였다.
         throw new Error(`[gaon db] 커넥션 '${dbKey}' 은 문서형(mongodb)입니다 — 문서형은 마이그레이션이 없습니다(§7.4).\n` +
-            `  → 몽고 인덱스는 Mongoose 스키마 선언(index:true / schema.index())으로 관리합니다(mongoose autoIndex 기본값이 부팅 시 보장).\n` +
-            `  → gaon db diff/migrate 는 SQL 커넥션(postgres·mysql)에만 실행하세요(키 생략 시 순회가 문서형을 자동으로 건너뜁니다 · 결정 292).`);
+            `  → 몽고 인덱스는 Mongoose 스키마 선언(index:true / schema.index())으로 관리합니다 — dev·test 는 autoIndex 가\n` +
+            `    첫 사용 시 만들고, 운영(NODE_ENV=production)은 autoIndex 기본 false 라 배포 절차에서 syncMongoIndexes() 로\n` +
+            `    명시 동기화합니다(결정 333·365).\n` +
+            `  → gaon db 서브커맨드(diff/migrate/status/seed/reset)는 SQL 커넥션(postgres·mysql) 전용입니다 —\n` +
+            `    키 생략 시 순회가 문서형을 자동으로 건너뜁니다(결정 292).`);
     }
     const db = createDb(connCfg);
     registerConnection(dbKey, db, connCfg.adapter);

package/dist/db/status.js

@@ -2,7 +2,7 @@
 //
 // db/migrations/*.ts 각각의 적용/미적용과, 스키마↔DB 사이에 아직 반영 안 된
 // 변경(schema drift) 수를 함께 보여준다. 아무것도 실행하지 않는다.
-import { computeMigration, summarizeOp, DEFERRED_DROP_KINDS } from '@gaonjs/data';
+import { computeMigration, summarizeOp, partitionDeferredOps } from '@gaonjs/data';
 import { resolveDbTarget } from './resolve.js';
 import { appliedFileMigrations } from './journal.js';
 import { describeDeferred } from './migrate.js';
@@ -21,14 +21,17 @@ export async function runDbStatus(opts) {
         // migrate 는 스키마에 없는 테이블을 자동 DROP 하지 않으므로(결정 39 · §4.8)
         // dropTable 은 drift 로 세지 않는다 — 별도로 참고 정보(extraTables)로만 보고.
         const plan = await computeMigration(target.db, target.tables, target.dialect);
-        const extraTables = plan.ops
-            .filter((o) => o.kind === 'dropTable')
-            .map((o) => o.name);
         // 결정 326: deferred aux drop(제약·인덱스·기본값 제거)도 migrate 가 자동 적용하지
         // 않는다(결정 220) — drift 로 세면 "'gaon db migrate' 로 반영하세요" 가 영원히 안
         // 지워지는 거짓 안내가 된다. dropTable 과 같은 축의 참고 항목으로 분리한다.
-        const deferredDrops = plan.ops.filter((o) => o.kind !== 'dropTable' && DEFERRED_DROP_KINDS.has(o.kind));
-        const schemaChanges = plan.ops.length - extraTables.length - deferredDrops.length;
+        // 결정 366: 재생성 쌍(인덱스 method·enum 값 변경)의 drop 반쪽은 migrate 가 자동
+        // 적용하므로 deferred 가 아니라 drift(schemaChanges)로 계상한다 — migrate 와 한 판정.
+        const { apply, deferred } = partitionDeferredOps(plan.ops);
+        const extraTables = deferred
+            .filter((o) => o.kind === 'dropTable')
+            .map((o) => o.name);
+        const deferredDrops = deferred.filter((o) => o.kind !== 'dropTable');
+        const schemaChanges = apply.length;
         const lines = [];
         if (migrations.length === 0) {
             lines.push(`  [${opts.dbKey}] 마이그레이션 파일 없음 (db/migrations/).`);

package/dist/db.js

@@ -11,7 +11,7 @@ import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { createDb, registerConnection, destroyAllConnections, isSeedDef, } from '@gaonjs/data';
 import { registerTsResolve } from './tsResolve.js';
-import { resolveDbTarget } from './db/resolve.js';
+import { resolveDbTarget, listSqlConnectionConfigs } from './db/resolve.js';
 import { registerInProjectData, isSplitDataInstance } from './db/projectData.js';
 /** DB URL 에서 어댑터를 추정한다(gaon work 와 동일 규칙). */
 function dbConfigFromUrl(url) {
@@ -77,15 +77,36 @@ export async function runDbSeedCommand(opts = {}) {
         throw new Error(`[gaon db seed] 커넥션 '${dbKey}' 에 url 이 없어 시드를 실행할 수 없습니다.\n` +
             `  → gaon.config.ts 의 db.${dbKey} 에 url 을 두거나 .env 의 GAON_DATABASE_URL 을 설정하세요.`);
     }
-    const projData = await registerInProjectData(root, dbKey, { adapter: target.adapter, url: target.url, poolMax: 1 });
+    // 결정 367: 시드는 커넥션을 몰라도 된다(§10.1 — 모델이 자기 커넥션에 자동 바인딩).
+    // dbKey 하나만 등록하면 ≥2 SQL 커넥션 프로젝트의 시드가 타 커넥션 모델의 '미등록'
+    // throw 로 항상 실패했다(그리고 그 에러가 결정 156 오진 안내로 이어졌다) — 선언된
+    // **전 SQL 커넥션**을 등록하고 시드는 1회만 실행한다. url 없는 보조 커넥션은 연결
+    // 불가라 건너뛴다(그 커넥션 모델을 시드가 쓰면 미등록 에러가 원인을 가리킨다).
+    const others = (await listSqlConnectionConfigs(root, opts.configPath)).filter((c) => c.key !== dbKey && ('url' in c.cfg ? c.cfg.url : true));
+    const registered = [dbKey];
+    const projHandles = [];
+    const primaryHandle = await registerInProjectData(root, dbKey, { adapter: target.adapter, url: target.url, poolMax: 1 });
+    if (primaryHandle)
+        projHandles.push(primaryHandle);
+    for (const { key, cfg } of others) {
+        registerConnection(key, createDb(cfg), cfg.adapter);
+        const h = await registerInProjectData(root, key, { ...cfg, poolMax: 1 });
+        if (h)
+            projHandles.push(h);
+        registered.push(key);
+    }
     try {
         const def = await loadSeed(root);
         await runSeed(def, root);
-        return { exitCode: 0, ...SEED_OK };
+        return {
+            exitCode: 0,
+            text: `${SEED_OK.text} (커넥션: ${registered.join(', ')})`,
+            json: { command: 'seed', ok: true, connections: registered },
+        };
     }
     finally {
-        if (projData)
-            await projData.close();
+        for (const h of projHandles)
+            await h.close();
         await target.close();
     }
 }

package/dist/dev.js

@@ -13,7 +13,7 @@
  */
 import { readdirSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { analyzeProjectI18n } from './i18n-config.js';
+import { analyzeProjectI18n, resolveLocalesDir } from './i18n-config.js';
 /** locales/*.json 변경(메시지 카탈로그) — messages.d.ts 재생성 트리거. */
 const isMessagesChange = (f) => !f.includes('.gaon') && f.endsWith('.json');
 const isSchemaChange = (f) => f.endsWith('.ts') && !f.endsWith('.d.ts') && !f.endsWith('.test.ts') && !f.includes('.gaon');
@@ -148,7 +148,7 @@ export function resolveDevLayout(cwd) {
     // 결정 352: 카탈로그 위치·기준 로케일은 gaon.config.ts 의 i18n 블록을 따른다
     // (정적 분석 · 하드코딩 'locales' 는 dir 커스텀 프로젝트에서 타입 축을 무소음으로 껐다).
     const i18nCfg = analyzeProjectI18n(root);
-    const localesDirPath = join(root, i18nCfg.dir ?? 'locales');
+    const localesDirPath = resolveLocalesDir(root, i18nCfg.dir);
     return {
         schemaDir: existsSync(schemaDirPath) ? schemaDirPath : undefined,
         tablesOut: join(root, '.gaon', 'tables.d.ts'),

package/dist/doctor/auth-wiring.js

@@ -12,6 +12,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { stripComments, stripCommentsAndStrings } from './source-scan.js';
+import { jwtSecretEnvFor } from '../generate.js';
 // 결정 140(12차 W1): 판정 전 주석/문자열을 지운다. `// session:` 주석이나 문자열
 // 안의 우연한 일치가 배선으로 오탐되면 보안 검사(세션·CSRF)가 통째로 skip 된다.
 /** 컨트롤러 소스가 인증 표면을 쓰는지 판정한다(단위 테스트 진입점). */
@@ -57,10 +58,12 @@ export async function checkAuthWiring(cwd) {
                 file: authFiles[0],
                 message: `인증 배선 누락: apps/${app} 컨트롤러(${authFiles.join(', ')})가 requireAuth/this.auth 를 쓰는데 ` +
                     `${acRel} 에 auth 배선이 없습니다. 이대로면 로그인해도 currentUser 가 항상 null 입니다(결정 59).\n` +
-                    `→ apps/${app}/app.config.ts 의 defineAppConfig({...}) 에 다음을 추가하세요:\n` +
+                    `→ apps/${app}/app.config.ts 의 defineAppConfig({...}) 에 다음을 추가하세요(세션 앱 · 정본):\n` +
                     `   session: { secret: process.env.SESSION_SECRET ?? '32자 이상 비밀' },\n` +
                     `   auth: { loadUser, loginRedirect: '/session/new' }  // import { loadUser } from './auth.js'\n` +
-                    `→ loadUser 가 없으면 \`gaon g auth --app ${app}\` 스캐폴드가 apps/${app}/auth.ts 에 만들어 줍니다.`,
+                    `→ API(JWT) 앱이라면 세션 대신 토큰 배선입니다(결정 337·338 — 세션·loginRedirect 없음):\n` +
+                    `   auth: { strategy: 'jwt', secret: process.env.${jwtSecretEnvFor(app)} ?? '32자 이상 dev 비밀', loadUser }\n` +
+                    `→ loadUser 가 없으면 \`gaon g auth --app ${app}\`(세션) 또는 \`gaon g auth --jwt --app ${app}\`(JWT) 스캐폴드가 apps/${app}/auth.ts 에 만들어 줍니다.`,
                 detail: { app, controllers: authFiles },
             });
         }

package/dist/doctor/channel-collision.d.ts

@@ -0,0 +1,9 @@
+import type { RuleReport } from './types.js';
+/**
+ * 소스가 default 를 다른 모듈에서 그대로 재수출만 하는지 판정하고 그 모듈 지정자를 낸다.
+ * `export { default } from '...'` · `export { default as default } from '...'` ·
+ * `export * from '...'` 를 인정한다(주석 제외 후 판정).
+ */
+export declare function reexportSpecifier(source: string): string | undefined;
+/** apps/ 를 훑어 앱간 동명 채널을 낸다. */
+export declare function checkChannelCollision(cwd: string): Promise<RuleReport>;