@gaonjs/cli 0.33.0 → 0.35.0

package/dist/commands/check.d.ts

@@ -4,7 +4,16 @@ export interface CheckCommandOptions {
     readonly json?: boolean;
     /** 지정 시 그 검사 하나만 실행. 나머지는 스킵. */
     readonly only?: CheckStep;
-    /** true 면 doctor 도 포함. 기본 false. */
+    /**
+     * 결정 157: doctor 는 이제 **기본 포함**이다(CI 가 check 하나만 돌려도 규칙 5 등
+     * doctor 규칙 위반을 잡는다). `noDoctor:true`(CLI `--no-doctor`)로 순수 typecheck/
+     * vue-tsc/build 만 돌린다.
+     */
+    readonly noDoctor?: boolean;
+    /**
+     * @deprecated 결정 157: doctor 가 기본이 돼 의미 없음(무시). `--include-doctor` 는
+     * 하위 호환 no-op — doctor 를 빼려면 `noDoctor`/`--no-doctor` 를 쓴다.
+     */
     readonly includeDoctor?: boolean;
 }
 export type CheckStepStatus = 'passed' | 'failed' | 'skipped';

package/dist/commands/check.js

@@ -7,16 +7,16 @@
  * (`node_modules/.bin/tsc --noEmit` · `node_modules/.bin/vue-tsc --noEmit`
  * · `pnpm -r build` → `npm run build`).
  *
- * The One Way — 하나의 명령이 3(선택 4) 검사를 순서대로 돌린다:
+ * The One Way — 하나의 명령이 4 검사를 순서대로 돌린다(결정 157 · doctor 기본 포함):
  *   1) typecheck (pnpm typecheck 또는 tsc --noEmit)
  *   2) vue-tsc   (pnpm vue-tsc 또는 vue-tsc --noEmit)
  *   3) build     (pnpm build)
- *   (4) doctor   (--include-doctor 시 · 코어 재사용)
+ *   4) doctor    (기본 포함 · 규칙 5 등 doctor 규칙 · --no-doctor 로 뺌 · 코어 재사용)
  *
  * 옵션 최소:
  *   --json                     자동화 · 각 검사의 passed/failed/skipped
  *   --only <name>              단일 검사만
- *   --include-doctor           check 안에서 doctor 도 · 기본 off
+ *   --no-doctor                doctor 를 빼고 typecheck/vue-tsc/build 만 (결정 157)
  *
  * exit code: 검사가 하나라도 실패하면 1, 그 외 0. 미리 검사할 대상이
  * 하나도 없으면(예: 스크립트도 없고 바이너리도 없음) 스킵으로 리포트 —
@@ -34,6 +34,7 @@ import { runDoctorCommand } from '../doctor.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
 import { registerTsResolve } from '../tsResolve.js';
 import { listFrontendApps, verifyAppDist } from '../dev/build.js';
+import { generateMessagesDts } from '../messages-gen.js';
 /**
  * 프로젝트 스크립트 존재 여부. pnpm/npm 어느 쪽이든 `scripts.<name>` 을
  * 정의해 두면 우선 사용한다.
@@ -233,7 +234,7 @@ async function runDoctorStep(cwd) {
  */
 async function regenerateGaon(cwd) {
     const layout = resolveDevLayout(cwd);
-    if (!layout.schemaDir && layout.apps.length === 0) {
+    if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
         return { status: 'skipped', tables: false, apps: [] };
     }
     // 생성기는 사용자 스키마·컨트롤러 .ts 를 동적 import 한다. TS-for-ESM
@@ -244,6 +245,7 @@ async function regenerateGaon(cwd) {
         const result = await regenerateGaonOnce(layout, {
             regenerateTables: generateTablesDts,
             regenerateRoutes: generateRoutesDts,
+            regenerateMessages: generateMessagesDts,
         });
         return { status: 'done', tables: result.tables, apps: result.apps };
     }
@@ -269,7 +271,9 @@ export async function runCheckCommand(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
     const json = opts.json ?? false;
     const only = opts.only;
-    const includeDoctor = opts.includeDoctor ?? false;
+    // 결정 157: doctor 는 기본 포함(규칙 5 등 doctor 규칙이 check 만 도는 CI 에서 새지 않게).
+    // --no-doctor 로만 뺀다. --include-doctor(구)는 이제 no-op(기본이 된 동작).
+    const runDoctor = !opts.noDoctor;
     // 규칙 3 — 검사는 최신 타입 브리지 위에서만 신뢰할 수 있다. 재생성이
     // 실패하면 stale .gaon 으로 검사하지 않고 즉시 중단한다.
     const regen = await regenerateGaon(cwd);
@@ -277,7 +281,7 @@ export async function runCheckCommand(opts = {}) {
         ? []
         : only
             ? [only]
-            : ['typecheck', 'vue-tsc', 'build', ...(includeDoctor ? ['doctor'] : [])];
+            : ['typecheck', 'vue-tsc', 'build', ...(runDoctor ? ['doctor'] : [])];
     const results = [];
     for (const step of steps) {
         if (step === 'doctor') {

package/dist/commands/dev.js

@@ -26,6 +26,7 @@ import { registerTsResolve } from '../tsResolve.js';
 import { startDev, resolveDevLayout } from '../dev.js';
 import { generateTablesDts, watchDir } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
+import { generateMessagesDts } from '../messages-gen.js';
 import { createDevConsole } from '../dev/console.js';
 import { ensureInfra, composeDown } from '../dev/docker.js';
 import { startTscWatchers, killChild } from '../dev/tsc.js';
@@ -86,6 +87,7 @@ async function startGaonRegen(args) {
         layout,
         regenerateTables: generateTablesDts,
         regenerateRoutes: generateRoutesDts,
+        regenerateMessages: generateMessagesDts,
         watch: watchDir,
         log: (e) => {
             if (e.kind === 'ready') {

package/dist/commands/gen.js

@@ -15,6 +15,7 @@
  */
 import { generateTablesDts } from '@gaonjs/data';
 import { generateRoutesDts } from '@gaonjs/web';
+import { generateMessagesDts } from '../messages-gen.js';
 import { regenerateGaonOnce, resolveDevLayout } from '../dev.js';
 import { registerTsResolve } from '../tsResolve.js';
 /**
@@ -24,13 +25,14 @@ import { registerTsResolve } from '../tsResolve.js';
  */
 export async function regenerateProjectGaon(cwd) {
     const layout = resolveDevLayout(cwd);
-    if (!layout.schemaDir && layout.apps.length === 0) {
-        return { tables: false, apps: [], skipped: true };
+    if (!layout.schemaDir && layout.apps.length === 0 && !layout.localesDir) {
+        return { tables: false, apps: [], messages: false, skipped: true };
     }
     registerTsResolve();
     const result = await regenerateGaonOnce(layout, {
         regenerateTables: generateTablesDts,
         regenerateRoutes: generateRoutesDts,
+        regenerateMessages: generateMessagesDts,
     });
     return { ...result, skipped: false };
 }

package/dist/db/projectData.d.ts

@@ -0,0 +1,14 @@
+import type { ConnectionConfig } from '@gaonjs/data';
+/** 프로젝트(projDir) 관점에서 @gaonjs/data 가 해상되는 경로. 미설치면 null. */
+export declare function resolveProjectDataPath(projDir: string): string | null;
+/** 프로젝트 @gaonjs/data 가 CLI 것과 **다른 인스턴스**인가(전역 설치 이중 로드 신호). */
+export declare function isSplitDataInstance(projDir: string): boolean;
+/**
+ * 프로젝트의 @gaonjs/data 인스턴스가 CLI 것과 다르면(전역 설치) 그 인스턴스에 커넥션을
+ * 등록해 모델 레이어가 같은 레지스트리를 보게 한다. 같은 인스턴스(로컬)면 resolveDbTarget
+ * 이 이미 등록했으므로 **no-op(null 반환)** — 로컬 경로 무회귀. 반환 핸들의 close() 는
+ * 프로젝트 인스턴스 커넥션을 정리한다(다른 인스턴스일 때만).
+ */
+export declare function registerInProjectData(projDir: string, dbKey: string, connCfg: ConnectionConfig): Promise<{
+    close(): Promise<void>;
+} | null>;

package/dist/db/projectData.js

@@ -0,0 +1,51 @@
+// @gaonjs/cli · 프로젝트 로컬 @gaonjs/data 해상 (결정 156 · 전역-로컬 레지스트리 분열 근본 수정)
+//
+// 전역 설치 CLI(`npm i -g gaonjs`)는 자기 번들의 @gaonjs/data 를 로드하고, 프로젝트의
+// domain 코드(seed 가 실행하는 모델)는 **프로젝트 node_modules** 의 @gaonjs/data 를
+// 로드한다(tsResolve 훅이 bare 지정자를 안 건드림 · dual package hazard). 두 인스턴스는
+// 커넥션 레지스트리가 갈려, resolveDbTarget 이 CLI 인스턴스에 등록한 커넥션을 모델
+// 레이어(프로젝트 인스턴스)가 못 봐서 seed 가 "커넥션 'main' 미등록" 으로 죽었다.
+// db migrate/diff/status 는 모델을 안 거쳐 이 분열을 가렸다(13차 실측).
+//
+// 근본 수정: seed 처럼 **프로젝트 모델 레이어를 거치는** 명령은, 프로젝트 인스턴스의
+// @gaonjs/data 에도 커넥션을 등록해 모델과 **단일 레지스트리**를 공유한다. 로컬 설치
+// (CLI·프로젝트가 같은 @gaonjs/data)면 두 경로가 같은 모듈이라 no-op — migrate/diff/
+// status 를 비롯한 로컬 경로는 무회귀다.
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { join, resolve as resolvePath } from 'node:path';
+/** CLI 자신이 로드한 @gaonjs/data 의 해상 경로. */
+function cliDataPath() {
+    return createRequire(import.meta.url).resolve('@gaonjs/data');
+}
+/** 프로젝트(projDir) 관점에서 @gaonjs/data 가 해상되는 경로. 미설치면 null. */
+export function resolveProjectDataPath(projDir) {
+    try {
+        // projDir/package.json 기준으로 해상 — 프로젝트 node_modules 의 @gaonjs/data.
+        const req = createRequire(join(resolvePath(projDir), 'package.json'));
+        return req.resolve('@gaonjs/data');
+    }
+    catch {
+        return null;
+    }
+}
+/** 프로젝트 @gaonjs/data 가 CLI 것과 **다른 인스턴스**인가(전역 설치 이중 로드 신호). */
+export function isSplitDataInstance(projDir) {
+    const projPath = resolveProjectDataPath(projDir);
+    return projPath !== null && projPath !== cliDataPath();
+}
+/**
+ * 프로젝트의 @gaonjs/data 인스턴스가 CLI 것과 다르면(전역 설치) 그 인스턴스에 커넥션을
+ * 등록해 모델 레이어가 같은 레지스트리를 보게 한다. 같은 인스턴스(로컬)면 resolveDbTarget
+ * 이 이미 등록했으므로 **no-op(null 반환)** — 로컬 경로 무회귀. 반환 핸들의 close() 는
+ * 프로젝트 인스턴스 커넥션을 정리한다(다른 인스턴스일 때만).
+ */
+export async function registerInProjectData(projDir, dbKey, connCfg) {
+    const projPath = resolveProjectDataPath(projDir);
+    if (!projPath || projPath === cliDataPath())
+        return null; // 로컬 설치 = 단일 인스턴스 · no-op
+    const mod = (await import(pathToFileURL(projPath).href));
+    const db = mod.createDb(connCfg);
+    mod.registerConnection(dbKey, db, connCfg.adapter);
+    return { close: () => mod.destroyAllConnections() };
+}

package/dist/db.js

@@ -12,6 +12,7 @@ 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 { registerInProjectData, isSplitDataInstance } from './db/projectData.js';
 /** DB URL 에서 어댑터를 추정한다(gaon work 와 동일 규칙). */
 function dbConfigFromUrl(url) {
     if (url.startsWith('mysql://') || url.startsWith('mariadb://')) {
@@ -52,24 +53,59 @@ export async function runDbSeedCommand(opts = {}) {
     if (opts.databaseUrl) {
         const cfg = dbConfigFromUrl(opts.databaseUrl);
         registerConnection(dbKey, createDb(cfg), cfg.adapter);
+        // 결정 156: 전역 설치면 프로젝트 인스턴스에도 등록(모델과 단일 레지스트리 공유).
+        const projData = await registerInProjectData(root, dbKey, cfg);
         try {
             const def = await loadSeed(root);
-            await def.run();
+            await runSeed(def, root);
             return { exitCode: 0, ...SEED_OK };
         }
         finally {
+            if (projData)
+                await projData.close();
             await destroyAllConnections();
         }
     }
     // 그 외 — migrate 와 같은 해석 경로: gaon.config.ts db.<키> → GAON_DATABASE_URL.
     // config 도 env 도 없으면 resolveDbTarget 이 수리 안내 에러를 던진다(§7.5.3).
     const target = await resolveDbTarget({ cwd: root, dbKey, configPath: opts.configPath });
+    // 결정 156: seed 는 모델 레이어를 거친다 — 전역 설치(CLI≠프로젝트 @gaonjs/data)면
+    // 프로젝트 인스턴스에도 커넥션을 등록해 "main 미등록" 분열을 근본에서 없앤다. 로컬
+    // 설치(단일 인스턴스)면 no-op. url 없는 config 는 seed 대상이 아니라 안내한다.
+    if (!target.url) {
+        await target.close();
+        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 });
     try {
         const def = await loadSeed(root);
-        await def.run();
+        await runSeed(def, root);
         return { exitCode: 0, ...SEED_OK };
     }
     finally {
+        if (projData)
+            await projData.close();
         await target.close();
     }
 }
+/**
+ * 시드를 실행하되, "커넥션 미등록" 계열 실패는 전역-로컬 @gaonjs/data 분열로 진단해
+ * 실제 수리(로컬 실행)로 안내한다(결정 156 · §7.5.3 — 이미 등록된 커넥션을 또 선언하라던
+ * 오진 제거).
+ */
+async function runSeed(def, root) {
+    try {
+        await def.run();
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (/등록되지 않았|not registered|미등록/.test(msg) && isSplitDataInstance(root)) {
+            throw new Error(`[gaon db seed] 시드 실행 중 커넥션을 찾지 못했습니다 — 전역 설치 CLI 와 프로젝트가\n` +
+                `@gaonjs/data 를 각각 로드해 커넥션 레지스트리가 갈렸습니다(dual package hazard).\n` +
+                `  → 프로젝트 로컬로 실행하세요: npx gaon db seed (또는 package.json 스크립트로 실행)\n` +
+                `  (원본: ${msg})`);
+        }
+        throw err;
+    }
+}

package/dist/dev.d.ts

@@ -11,11 +11,17 @@ export interface DevLayout {
     /** .gaon/tables.d.ts */
     readonly tablesOut: string;
     readonly apps: readonly DevApp[];
+    /** locales/ (없으면 undefined — messages 축 생략 · 결정 158 · W2). */
+    readonly localesDir?: string;
+    /** .gaon/messages.d.ts */
+    readonly messagesOut: string;
 }
 export interface DevDeps {
     readonly layout: DevLayout;
     regenerateTables(schemaDir: string, out: string): Promise<unknown>;
     regenerateRoutes(appDir: string, out: string): Promise<unknown>;
+    /** locales/ → .gaon/messages.d.ts (결정 158 · W2). i18n 축을 쓰는 호출자만 준다. */
+    regenerateMessages?(localesDir: string, out: string): unknown;
     watch(dir: string, opts: WatchOptions): WatchHandle;
     log(event: DevEvent): void;
     onError(err: Error): void;
@@ -26,7 +32,7 @@ export type DevEvent = {
     readonly apps: string[];
 } | {
     readonly kind: 'regen';
-    readonly target: 'tables' | 'routes';
+    readonly target: 'tables' | 'routes' | 'messages';
     readonly app?: string;
 } | {
     readonly kind: 'stopped';
@@ -44,12 +50,16 @@ export declare function startDev(deps: DevDeps): Promise<DevHandle>;
 export interface RegenDeps {
     regenerateTables(schemaDir: string, out: string): Promise<unknown>;
     regenerateRoutes(appDir: string, out: string): Promise<unknown>;
+    /** locales/ → .gaon/messages.d.ts (결정 158 · W2). i18n 축을 쓰는 호출자만 준다. */
+    regenerateMessages?(localesDir: string, out: string): unknown;
 }
 export interface RegenResult {
     /** tables.d.ts 를 재생성했는가(domain/schema 존재 시에만). */
     readonly tables: boolean;
     /** routes.d.ts 를 재생성한 앱 이름. */
     readonly apps: readonly string[];
+    /** messages.d.ts 를 재생성했는가(locales/ 존재 · 결정 158 · W2). */
+    readonly messages: boolean;
 }
 /**
  * 워처 없이 .gaon 타입 브리지를 1회 전체 재생성한다. `gaon check` 처럼

package/dist/dev.js

@@ -13,6 +13,8 @@
  */
 import { readdirSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
+/** 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');
 const isRoutesChange = (f) => !f.includes('.gaon') &&
     f.endsWith('.ts') &&
@@ -35,6 +37,11 @@ export async function startDev(deps) {
         await deps.regenerateRoutes(app.appDir, app.routesOut);
         deps.log({ kind: 'regen', target: 'routes', app: app.name });
     }
+    // 결정 158(W2): locales/ → messages.d.ts.
+    if (layout.localesDir && deps.regenerateMessages) {
+        await deps.regenerateMessages(layout.localesDir, layout.messagesOut);
+        deps.log({ kind: 'regen', target: 'messages' });
+    }
     // 2) 스키마 워치 → tables.d.ts 재생성.
     if (layout.schemaDir) {
         const schemaDir = layout.schemaDir;
@@ -58,6 +65,19 @@ export async function startDev(deps) {
             onError: deps.onError,
         }));
     }
+    // 4) locales 워치 → messages.d.ts 재생성(결정 158 · W2).
+    if (layout.localesDir && deps.regenerateMessages) {
+        const localesDir = layout.localesDir;
+        const regenerateMessages = deps.regenerateMessages;
+        handles.push(deps.watch(localesDir, {
+            filter: isMessagesChange,
+            onChange: async () => {
+                await regenerateMessages(localesDir, layout.messagesOut);
+                deps.log({ kind: 'regen', target: 'messages' });
+            },
+            onError: deps.onError,
+        }));
+    }
     deps.log({ kind: 'ready', schema: !!layout.schemaDir, apps: layout.apps.map((a) => a.name) });
     return {
         close() {
@@ -80,7 +100,12 @@ export async function regenerateGaonOnce(layout, deps) {
     for (const app of layout.apps) {
         await deps.regenerateRoutes(app.appDir, app.routesOut);
     }
-    return { tables: !!layout.schemaDir, apps: layout.apps.map((a) => a.name) };
+    // 결정 158(W2): locales/ 가 있으면 messages.d.ts 도 재생성한다(i18n 키 타입 브리지).
+    let messages = false;
+    if (layout.localesDir && deps.regenerateMessages) {
+        messages = (await deps.regenerateMessages(layout.localesDir, layout.messagesOut)) === true;
+    }
+    return { tables: !!layout.schemaDir, apps: layout.apps.map((a) => a.name), messages };
 }
 /** cwd 관례로 프로젝트 레이아웃을 해석한다(존재하는 것만 포함). */
 export function resolveDevLayout(cwd) {
@@ -102,10 +127,13 @@ export function resolveDevLayout(cwd) {
             });
         }
     }
+    const localesDirPath = join(root, 'locales');
     return {
         schemaDir: existsSync(schemaDirPath) ? schemaDirPath : undefined,
         tablesOut: join(root, '.gaon', 'tables.d.ts'),
         apps: apps.sort((a, b) => a.name.localeCompare(b.name)),
+        localesDir: existsSync(localesDirPath) ? localesDirPath : undefined,
+        messagesOut: join(root, '.gaon', 'messages.d.ts'),
     };
 }
 // runDevCommand · DevCommandOptions 는 M9-C 에서 commands/dev.ts 로 이동.

package/dist/generate.d.ts

@@ -1,6 +1,12 @@
 export interface AuthScaffoldOptions {
     /** 대상 앱(apps/<app>). 기본 'web'. */
     readonly app?: string;
+    /**
+     * 결정 155: 공개 회원가입(registration)을 깔지 여부. 기본은 **앱명 기반 시큐어**
+     * — web 은 공개 가입 O, 비-web(admin 등)은 공개 가입 X + 역할 게이트(authorize).
+     * `--public` 로 비-web 앱도 공개 가입을 opt-in 한다(공개 비-web 앱용 탈출구).
+     */
+    readonly public?: boolean;
 }
 /** 생성할 파일 하나 — 경로는 프로젝트 루트 기준. */
 export interface ScaffoldFile {
@@ -14,13 +20,27 @@ export interface ScaffoldResult {
     /** 손 수리가 필요한 지점 — 수리 안내 문장(§7.5.3)을 그대로 담는다. */
     readonly warnings: string[];
 }
-/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다. */
+/**
+ * 결정 155·142: `g auth --app <앱>` 이 앱별 세션 secret 환경변수를 .env·.env.example
+ * 에도 시드한다. web 은 SESSION_SECRET 이 프로젝트 스캐폴드(.env.example.tpl)에 이미
+ * 있어 no-op 이지만, 비-web 앱(admin 등)은 이 키가 어디에도 없어 app.config 의
+ * `process.env.ADMIN_SESSION_SECRET ?? '공개 고정 dev secret'` 이 조용히 폴백으로
+ * 돌아 세션 위조 표면이 된다. env 파일에 키를 심어 사용자가 설정해야 함을 드러낸다
+ * (앱별 세션 완전 분리를 env 층까지 확장).
+ *
+ * 이미 그 키가 있으면 건드리지 않는다(멱등). 파일이 없으면 만들지 않는다 — 스캐폴드가
+ * .env 를 새로 만드는 관례가 없어(사용자가 cp .env.example .env), 존재하는 파일만 패치한다.
+ * 반환: 실제로 키를 추가한 상대 경로들.
+ */
+export declare function patchEnvFiles(root: string, app: string): string[];
+/** 인증 스캐폴드가 생성하는 파일 목록(라우트 제외). 템플릿을 읽어 렌더링한다.
+ *  결정 155: 공개 가입 여부(includePublic)로 registration·Signup·dashboard 변형을 가른다. */
 export declare function authScaffoldFiles(opts?: AuthScaffoldOptions): ScaffoldFile[];
 /**
  * 기존 routes.ts 에 세션·회원가입 리소스를 끼워 넣는다. 이미 있으면 null.
  * `routes((r) => {` 콜백 여는 지점 뒤에 두 줄을 삽입한다.
  */
-export declare function patchRoutes(existing: string): string | null;
+export declare function patchRoutes(existing: string, includePublic?: boolean): string | null;
 /**
  * 기존 app.config.ts 에 auth 배선을 끼워 넣는다 (결정 93 · gaon new 기본 web 앱은
  * 세션만 배선돼 있어 g auth 는 auth 만 추가하면 완성된다). 반환:
@@ -35,6 +55,8 @@ export interface GenerateAuthOptions {
     readonly cwd?: string;
     readonly app?: string;
     readonly json?: boolean;
+    /** 결정 155: 비-web 앱도 공개 회원가입을 opt-in(공개 비-web 앱용 탈출구). */
+    readonly public?: boolean;
 }
 /** `gaon g auth` 진입점. 스캐폴드를 쓰고 결과를 사람/JSON 으로 출력한다. */
 export declare function runGenerateAuthCommand(opts?: GenerateAuthOptions): number;