@gaonjs/cli 0.32.0 → 0.34.0

package/dist/dev/frontend-build.js

@@ -1,5 +1,5 @@
 /**
- * @gaonjs/cli · dev/frontend-build — 프론트 번들 watch 빌드 (결정 67 · M9-C)
+ * @gaonjs/cli · dev/frontend-build — 멀티 앱 프론트 번들 watch 빌드 (결정 67 · 결정 146)
  *
  * `gaon dev` 는 서버(serve)를 재시작 방식으로 띄운다(§dev.ts). 프론트 번들은
  * serve 가 dist/<앱>/index.html 을 매 요청 읽어 문서 셸에 이어 붙이므로
@@ -7,50 +7,55 @@
  * watch 모드로 함께 돌린다. 진짜 HMR(모듈 교체)은 v1 어댑터 범위 밖이라(§6.4)
  * "저장 → 재빌드 → 새로고침" 루프를 제공한다.
  *
- * fail-open: apps/web/index.html·vite 가 없으면 조용히 건너뛴다(프론트 없는
- * API 전용 프로젝트도 gaon dev 가 동작해야 한다). vite 실행 실패는 통합
- * 콘솔에 알리되 dev 전체를 막지 않는다.
+ * 결정 146(12차 W2): apps/* 를 순회해 **앱마다** watch 빌드한다(root=apps/<앱>·
+ * outDir=dist/<앱>·base=/<앱>/). 예전엔 apps/web 하나만 감시해 둘째 앱(admin)의
+ * dist 가 dev 에서 갱신되지 않았다. 프로그램적 build(configFile 명시)로 vue 플러그인
+ * 누락 함정을 피한다.
+ *
+ * fail-open: 프론트 진입(index.html)·vite 가 없으면 조용히 건너뛴다(프론트 없는
+ * API 전용 프로젝트도 gaon dev 가 동작해야 한다). vite 실패는 통합 콘솔에 알리되
+ * dev 전체를 막지 않는다.
  */
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-/** 프로젝트에 프론트 진입 HTML(apps/web/index.html)이 있는가. */
-function hasFrontend(cwd) {
-    return existsSync(join(cwd, 'apps', 'web', 'index.html'));
-}
-/** cwd 의 로컬 vite bin 을 찾는다(없으면 undefined — 건너뜀). */
-function resolveViteBin(cwd) {
-    const bin = join(cwd, 'node_modules', '.bin', 'vite');
-    return existsSync(bin) ? bin : undefined;
-}
+import { resolve } from 'node:path';
+import { appBase, buildApp, listFrontendApps } from './build.js';
 /**
- * vite build --watch 를 띄운다. 프론트가 없거나 vite 가 없으면 아무 것도 하지
- * 않고 no-op 핸들을 돌려준다(dev 는 계속 진행).
+ * apps/* 를 순회해 앱마다 vite watch 빌드를 띄운다. 프론트가 없거나 vite 가 없으면
+ * 아무 것도 하지 않고 no-op 핸들을 돌려준다(dev 는 계속 진행 · fail-open).
  */
 export function startFrontendBuild(opts) {
     const cwd = resolve(opts.cwd);
-    if (!hasFrontend(cwd)) {
-        opts.onLog('프론트 진입 HTML(apps/web/index.html)이 없어 vite 빌드를 건너뜁니다.', 'info');
-        return { close() { } };
-    }
-    const bin = resolveViteBin(cwd);
-    if (!bin) {
-        opts.onLog('vite 를 찾지 못해 프론트 watch 빌드를 건너뜁니다 → pnpm add -D vite @vitejs/plugin-vue', 'warn');
-        return { close() { } };
-    }
-    const child = spawn(bin, ['build', '--watch'], {
-        cwd,
-        stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env },
+    const watchers = [];
+    let closed = false;
+    void (async () => {
+        const apps = await listFrontendApps(cwd);
+        if (apps.length === 0) {
+            opts.onLog('프론트 진입 HTML(apps/<앱>/index.html)이 없어 vite watch 빌드를 건너뜁니다.', 'info');
+            return;
+        }
+        for (const app of apps) {
+            if (closed)
+                break;
+            opts.onLog(`▶ vite build --watch — apps/${app} → dist/${app} (base=${appBase(app)})`, 'info');
+            try {
+                const handle = await buildApp(cwd, app, { watch: true, onLog: opts.onLog });
+                if (closed) {
+                    await handle.close();
+                    break;
+                }
+                watchers.push(handle);
+            }
+            catch (err) {
+                opts.onLog(`vite watch 빌드를 건너뜁니다(apps/${app}): ${err instanceof Error ? err.message : String(err)}`, 'warn');
+            }
+        }
+    })().catch((err) => {
+        opts.onLog(`프론트 watch 빌드 오류: ${err instanceof Error ? err.message : String(err)}`, 'error');
     });
-    child.stdout?.on('data', (b) => opts.onLog(b.toString().trimEnd(), 'info'));
-    child.stderr?.on('data', (b) => opts.onLog(b.toString().trimEnd(), 'error'));
-    child.on('error', (err) => opts.onLog(`vite 실행 실패: ${err.message}`, 'error'));
-    opts.onLog('▶ vite build --watch — 프론트 번들 감시 (dist/web)', 'info');
     return {
         close() {
-            if (child.exitCode === null && child.signalCode === null)
-                child.kill('SIGTERM');
+            closed = true;
+            for (const w of watchers)
+                void w.close();
         },
     };
 }

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/doctor/async-offload.d.ts

@@ -1,5 +1,7 @@
 import type { RuleReport } from './types.js';
-/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정). */
+/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정).
+ *  결정 140(12차 W1): jwt 판정을 usesJwtStrategy 한 곳으로 통일 — 주석의
+ *  `// strategy: 'jwt'` 오탐이 offload 검사를 잘못 끄지 않도록. */
 export declare function isApiApp(appConfigSource: string): boolean;
 /** 파일이 메일 SDK 를 직접 import 하는가(단위 테스트 진입점). */
 export declare function importsMailSdk(source: string): boolean;

package/dist/doctor/async-offload.js

@@ -28,6 +28,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import ts from 'typescript';
+import { usesJwtStrategy } from './auth-wiring.js';
 // ── 검출 시그니처 ─────────────────────────────────────────────────────
 /** 메일 SDK 모듈 import (컨트롤러 = 잡 발행만 · async.md 함정 · async-flow forbidden 동일 집합). */
 const MAIL_SDK_IMPORT = /import\s+[\s\S]*?\bfrom\s+['"](?:nodemailer|resend|@sendgrid\/mail|mailgun[.\-/][^'"]*|mailgun)['"]/;
@@ -44,9 +45,11 @@ const EXTERNAL_HTTP = [
     // axios('https://...') · axios.get('https://...') · axios({ url: 'https://...' })
     /\baxios\s*(?:\.\s*(?:get|post|put|patch|delete|request|head)\s*)?\(\s*(?:\{[\s\S]*?\burl\s*:\s*)?[`'"]https?:\/\/(?!localhost|127\.0\.0\.1)/i,
 ];
-/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정). */
+/** app.config 소스가 JWT/API 앱인가 (외부 HTTP arm 제외 대상 · csrf-wiring 과 동일 판정).
+ *  결정 140(12차 W1): jwt 판정을 usesJwtStrategy 한 곳으로 통일 — 주석의
+ *  `// strategy: 'jwt'` 오탐이 offload 검사를 잘못 끄지 않도록. */
 export function isApiApp(appConfigSource) {
-    return /strategy\s*:\s*['"]jwt['"]/.test(appConfigSource);
+    return usesJwtStrategy(appConfigSource);
 }
 /** 파일이 메일 SDK 를 직접 import 하는가(단위 테스트 진입점). */
 export function importsMailSdk(source) {

package/dist/doctor/auth-wiring.d.ts

@@ -1,9 +1,11 @@
 import type { RuleReport } from './types.js';
 /** 컨트롤러 소스가 인증 표면을 쓰는지 판정한다(단위 테스트 진입점). */
 export declare function usesAuthSurface(source: string): boolean;
-/** app.config.ts 소스에 auth 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 auth 배선이 있는지(주석/문자열 제외 후 판정). */
 export declare function hasAuthWiring(source: string): boolean;
-/** app.config.ts 소스에 session 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 session 배선이 있는지(주석/문자열 제외 후 판정). */
 export declare function hasSessionWiring(source: string): boolean;
+/** app.config.ts 소스가 JWT 전략(strategy:'jwt')인지(주석 제외 후 판정 · 문자열 내용 보존). */
+export declare function usesJwtStrategy(source: string): boolean;
 /** apps/ 를 훑어 인증 배선 누락을 낸다. */
 export declare function checkAuthWiring(cwd: string): Promise<RuleReport>;

package/dist/doctor/auth-wiring.js

@@ -11,17 +11,24 @@
 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';
+// 결정 140(12차 W1): 판정 전 주석/문자열을 지운다. `// session:` 주석이나 문자열
+// 안의 우연한 일치가 배선으로 오탐되면 보안 검사(세션·CSRF)가 통째로 skip 된다.
 /** 컨트롤러 소스가 인증 표면을 쓰는지 판정한다(단위 테스트 진입점). */
 export function usesAuthSurface(source) {
-    return /this\.requireAuth\s*\(|this\.auth\.login\s*\(|this\.currentUser\b/.test(source);
+    return /this\.requireAuth\s*\(|this\.auth\.login\s*\(|this\.currentUser\b/.test(stripCommentsAndStrings(source));
 }
-/** app.config.ts 소스에 auth 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 auth 배선이 있는지(주석/문자열 제외 후 판정). */
 export function hasAuthWiring(source) {
-    return /\bauth\s*:/.test(source);
+    return /\bauth\s*:/.test(stripCommentsAndStrings(source));
 }
-/** app.config.ts 소스에 session 배선이 있는지(얕은 텍스트 판정). */
+/** app.config.ts 소스에 session 배선이 있는지(주석/문자열 제외 후 판정). */
 export function hasSessionWiring(source) {
-    return /\bsession\s*:/.test(source);
+    return /\bsession\s*:/.test(stripCommentsAndStrings(source));
+}
+/** app.config.ts 소스가 JWT 전략(strategy:'jwt')인지(주석 제외 후 판정 · 문자열 내용 보존). */
+export function usesJwtStrategy(source) {
+    return /strategy\s*:\s*['"]jwt['"]/.test(stripComments(source));
 }
 /** apps/ 를 훑어 인증 배선 누락을 낸다. */
 export async function checkAuthWiring(cwd) {
@@ -42,7 +49,7 @@ export async function checkAuthWiring(cwd) {
         const acPath = join(appsDir, app, 'app.config.ts');
         const acRel = relative(cwd, acPath);
         const acSource = existsSync(acPath) ? await readFile(acPath, 'utf8') : undefined;
-        const jwt = acSource != null && /strategy\s*:\s*['"]jwt['"]/.test(acSource);
+        const jwt = acSource != null && usesJwtStrategy(acSource);
         if (acSource == null || !hasAuthWiring(acSource)) {
             issues.push({
                 rule: 'auth-wiring',

package/dist/doctor/csrf-wiring.d.ts

@@ -1,5 +1,7 @@
 import type { RuleReport } from './types.js';
-/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점). */
+/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점).
+ *  결정 140(12차 W1): 주석/문자열 안의 우연한 일치가 CSRF 검사를 왜곡하지 않도록
+ *  판정 전 정규화한다(여는 따옴표 구분자는 보존되어 라우트 매칭은 유지). */
 export declare function hasStateChangingRoutes(routesSource: string): boolean;
 /** apps/ 를 훑어 CSRF/세션 미배선(비-GET 라우트 + session 없음)을 경고로 낸다. */
 export declare function checkCsrfWiring(cwd: string): Promise<RuleReport>;

package/dist/doctor/csrf-wiring.js

@@ -14,14 +14,18 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import { hasSessionWiring } from './auth-wiring.js';
-/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점). */
+import { hasSessionWiring, usesJwtStrategy } from './auth-wiring.js';
+import { stripCommentsAndStrings } from './source-scan.js';
+/** routes.ts 소스에 상태 변경(비-GET) 라우트가 있는지 판정한다(단위 테스트 진입점).
+ *  결정 140(12차 W1): 주석/문자열 안의 우연한 일치가 CSRF 검사를 왜곡하지 않도록
+ *  판정 전 정규화한다(여는 따옴표 구분자는 보존되어 라우트 매칭은 유지). */
 export function hasStateChangingRoutes(routesSource) {
+    const src = stripCommentsAndStrings(routesSource);
     // r.post('/x', ...) · r.put/patch/delete — 메서드 + 경로 문자열.
-    if (/\.\s*(post|put|patch|delete)\s*\(\s*['"]/.test(routesSource))
+    if (/\.\s*(post|put|patch|delete)\s*\(\s*['"]/.test(src))
         return true;
     // resource(s)('posts') — 리소스 라우트는 create/update/destroy(POST/PUT/DELETE)를 만든다.
-    if (/\.\s*resources?\s*\(\s*['"]/.test(routesSource))
+    if (/\.\s*resources?\s*\(\s*['"]/.test(src))
         return true;
     return false;
 }
@@ -40,7 +44,7 @@ export async function checkCsrfWiring(cwd) {
         const acRel = relative(cwd, acPath);
         const acSource = existsSync(acPath) ? await readFile(acPath, 'utf8') : undefined;
         // JWT/API 앱은 토큰 인증 — CSRF 대상 아님(제외).
-        const jwt = acSource != null && /strategy\s*:\s*['"]jwt['"]/.test(acSource);
+        const jwt = acSource != null && usesJwtStrategy(acSource);
         if (jwt)
             continue;
         if (acSource != null && hasSessionWiring(acSource))

package/dist/doctor/seal-security.js

@@ -10,10 +10,13 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
+import { stripComments, stripCommentsAndStrings } from './source-scan.js';
+// 결정 140(12차 W1): 판정 전 주석/문자열을 지운다 — 주석의 `seal: {` 나 문자열 안의
+// 우연한 일치가 검사를 왜곡하지 않도록.
 /** app.config.ts 소스에 seal 토글(true 또는 { … })이 켜져 있는지 판정한다(단위 테스트 진입점). */
 export function hasSealEnabled(appConfigSource) {
     // seal: true · seal: { except: [...] } — false/생략은 제외.
-    return /\bseal\s*:\s*(true|\{)/.test(appConfigSource);
+    return /\bseal\s*:\s*(true|\{)/.test(stripCommentsAndStrings(appConfigSource));
 }
 /**
  * 결정 121(§3.1): seal 앱의 main.ts 가 seal 클라이언트를 배선했는지 판정한다(단위 테스트 진입점).
@@ -22,19 +25,22 @@ export function hasSealEnabled(appConfigSource) {
  * (seal-browser-e2e 로 실측). import + sealClient 전달을 둘 다 확인한다.
  */
 export function hasSealClientWired(mainSource) {
-    const imported = /import[^\n]*@gaonjs\/seal\/client/.test(mainSource);
+    // import 경로 문자열을 봐야 하므로 문자열 내용은 보존(주석만 제거).
+    const src = stripComments(mainSource);
+    const imported = /import[^\n]*@gaonjs\/seal\/client/.test(src);
     // createGaonApp(...) 호출 안에 sealClient 가 실제로 전달됐는지(멀티라인 객체 허용).
-    const passed = /createGaonApp\s*\([\s\S]*\bsealClient\b/.test(mainSource);
+    const passed = /createGaonApp\s*\([\s\S]*\bsealClient\b/.test(src);
     return imported && passed;
 }
 /** gaon.config.ts 소스에서 명시적으로 꺼진 보안 방어층 이름을 뽑는다(rateLimit·securityHeaders·cors). */
 export function disabledDefenses(gaonConfigSource) {
+    const src = stripCommentsAndStrings(gaonConfigSource);
     const off = [];
-    if (/\brateLimit\s*:\s*false/.test(gaonConfigSource))
+    if (/\brateLimit\s*:\s*false/.test(src))
         off.push('rateLimit');
-    if (/\bsecurityHeaders\s*:\s*false/.test(gaonConfigSource))
+    if (/\bsecurityHeaders\s*:\s*false/.test(src))
         off.push('securityHeaders');
-    if (/\bcors\s*:\s*false/.test(gaonConfigSource))
+    if (/\bcors\s*:\s*false/.test(src))
         off.push('cors');
     return off;
 }

package/dist/doctor/source-scan.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 주석을 지운 소스를 돌려준다(문자열·코드는 보존 · 라인 번호 유지).
+ * 문자열 **내용**을 봐야 하는 탐지기(예: `strategy: 'jwt'` · import 경로)에 쓴다.
+ */
+export declare function stripComments(source: string): string;
+/**
+ * 주석 + 문자열/템플릿 리터럴 내용을 지운 소스를 돌려준다(구분자·라인 보존).
+ * 프로퍼티 키·키워드만 보는 탐지기(예: `session:` · `auth:` · `rateLimit: false`)에
+ * 쓴다 — 주석도 문자열도 키를 위장하지 못한다.
+ */
+export declare function stripCommentsAndStrings(source: string): string;

package/dist/doctor/source-scan.js

@@ -0,0 +1,70 @@
+// @gaonjs/cli · doctor · 소스 정규화 유틸 (12차 W1 · 결정 140)
+//
+// 탐지기가 정규식으로 소스를 볼 때 **주석·문자열 안의 우연한 일치**를 배선으로
+// 오탐하지 않도록, TS 스캐너로 토큰을 훑어 주석/문자열을 안전하게 지운다.
+//
+// 왜 스캐너인가(regex 스트립이 아니라): 보안 탐지기(auth·csrf·seal)는 오탐이
+// 검사 skip = 취약점 노출로 이어진다(12차 W1 · gaon g app 스캐폴드의 주석
+// `//   session: { ... }` 가 hasSessionWiring 을 만족시켜 CSRF/세션 검사를
+// 통째로 건너뛴 P0). regex 기반 주석 스트립은 문자열 안의 `//` 를 잘못 지우는
+// 등 경계에서 새므로, 정확한 토큰 경계가 필요한 보안 탐지기는 스캐너로 지운다.
+// (connections.ts·schema-relations.ts 가 이미 TS AST 를 쓰는 것과 같은 결.)
+//
+// 라인/컬럼(개행)은 보존한다 — 탐지기가 라인 번호를 그대로 보고할 수 있게.
+import ts from 'typescript';
+function isCommentKind(k) {
+    return k === ts.SyntaxKind.SingleLineCommentTrivia || k === ts.SyntaxKind.MultiLineCommentTrivia;
+}
+function isStringKind(k) {
+    return (k === ts.SyntaxKind.StringLiteral ||
+        k === ts.SyntaxKind.NoSubstitutionTemplateLiteral ||
+        k === ts.SyntaxKind.TemplateHead ||
+        k === ts.SyntaxKind.TemplateMiddle ||
+        k === ts.SyntaxKind.TemplateTail);
+}
+/** 개행만 남기고 나머지 문자는 공백으로 — 라인 번호를 보존한다. */
+function blankKeepLines(text) {
+    return text.replace(/[^\n]/g, ' ');
+}
+/**
+ * 문자열/템플릿 토큰의 **내용**만 비우고 구분자(따옴표·백틱·`${`·`}`)는 남긴다.
+ * `'jwt'` → `'   '` · `''` → `''`. 프로퍼티 키·구분자에 걸린 탐지기(예: 라우트
+ * `.post('...')` 의 여는 따옴표)는 여전히 매칭되지만, 문자열 내용이 키를 위장하는
+ * 오탐은 막는다. 개행은 보존한다.
+ */
+function blankStringContent(text) {
+    if (text.length <= 2)
+        return text;
+    return text[0] + blankKeepLines(text.slice(1, -1)) + text[text.length - 1];
+}
+function scanTransform(source, strings) {
+    // skipTrivia=false 로 주석·공백까지 토큰으로 받아 원문을 무손실 재구성한다.
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, 
+    /* skipTrivia */ false, ts.LanguageVariant.Standard, source);
+    let out = '';
+    for (let token = scanner.scan(); token !== ts.SyntaxKind.EndOfFileToken; token = scanner.scan()) {
+        const text = scanner.getTokenText();
+        if (isCommentKind(token))
+            out += blankKeepLines(text);
+        else if (strings && isStringKind(token))
+            out += blankStringContent(text);
+        else
+            out += text;
+    }
+    return out;
+}
+/**
+ * 주석을 지운 소스를 돌려준다(문자열·코드는 보존 · 라인 번호 유지).
+ * 문자열 **내용**을 봐야 하는 탐지기(예: `strategy: 'jwt'` · import 경로)에 쓴다.
+ */
+export function stripComments(source) {
+    return scanTransform(source, /* strings */ false);
+}
+/**
+ * 주석 + 문자열/템플릿 리터럴 내용을 지운 소스를 돌려준다(구분자·라인 보존).
+ * 프로퍼티 키·키워드만 보는 탐지기(예: `session:` · `auth:` · `rateLimit: false`)에
+ * 쓴다 — 주석도 문자열도 키를 위장하지 못한다.
+ */
+export function stripCommentsAndStrings(source) {
+    return scanTransform(source, /* strings */ true);
+}

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,14 @@ export interface ScaffoldResult {
     /** 손 수리가 필요한 지점 — 수리 안내 문장(§7.5.3)을 그대로 담는다. */
     readonly warnings: 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 만 추가하면 완성된다). 반환:
@@ -28,13 +35,15 @@ export declare function patchRoutes(existing: string): string | null;
  *  · defineAppConfig 객체 리터럴을 못 찾으면 null (안전 · 상위에서 경고 폴백).
  * 성공 시 loadUser import 도 함께 보장한다.
  */
-export declare function patchAppConfigAddAuth(existing: string): string | null;
+export declare function patchAppConfigAddAuth(existing: string, app?: string): string | null;
 /** 스캐폴드를 디스크에 쓴다. 기존 파일은 덮어쓰지 않고 skip 한다. routes.ts 는 패치. */
 export declare function writeAuthScaffold(cwd: string, opts?: AuthScaffoldOptions): ScaffoldResult;
 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;