@gaonjs/cli 0.37.1 → 0.38.0

package/dist/commands/dev.d.ts

@@ -5,9 +5,16 @@
  *   1) Docker Compose  — pg · redis · nats · mailpit · minio 자동 up -d
  *   2) .gaon 워처       — tables.d.ts · routes.d.ts 재생성 (기존 M3)
  *   3) serve 자식       — 실 웹 서버(Fastify) · 소스 변경 시 재시작
- *   4) tsc / vue-tsc    — --watch 모드 · 타입 에러 즉시 리포트
- *   5) restart 워처     — apps/ · domain/ · packages/ 변경 → serve 재시작
- *   6) 통합 콘솔        — [source] 태그·색상별 · JSON 모드 지원
+ *   4) work 자식        — 워커(잡·리스너·아웃박스·스케줄) · 소스 변경 시 재시작 (결정 211)
+ *   5) hub 자식         — 실시간 허브(프레즌스 권위·중계) (결정 211)
+ *   6) tsc / vue-tsc    — --watch 모드 · 타입 에러 즉시 리포트
+ *   7) restart 워처     — apps/ · domain/ · packages/ 변경 → serve·work 재시작
+ *   8) 통합 콘솔        — [source] 태그·색상별 · JSON 모드 지원
+ *
+ * 운영 프로세스 3종(serve·work·hub · §7)을 dev 에서 모두 내장 기동한다
+ * (Rails-like all-in-one · 결정 211). 이전에는 serve 만 떠 잡·이벤트·아웃박스·
+ * 크론이 dev 에서 조용히 처리되지 않았다(work 부재) — work.ts·hub.ts 주석이
+ * 이미 "dev 가 내장 실행" 이라 명시했으나 실제로는 미배선이던 드리프트를 닫는다.
  *
  * The One Way: `gaon dev` 하나로 전부 · 옵션은 개별 debug 용만 노출.
  * fail-closed: Docker 없으면 명확 안내(§7.5.3), 목업 대체 절대 X (§9).
@@ -38,6 +45,10 @@ export interface DevCommandOptions {
     readonly noDocker?: boolean;
     /** 프론트 watch 빌드(vite build --watch) 끄기(개별 debug). */
     readonly noVite?: boolean;
+    /** 워커(work) 자동 기동 끄기(개별 debug · 결정 211). 기본 기동. */
+    readonly noWork?: boolean;
+    /** 실시간 허브(hub) 자동 기동 끄기(개별 debug · 결정 211). 기본 기동. */
+    readonly noHub?: boolean;
     /** 통합 콘솔 타임스탬프 표시. */
     readonly timestamp?: boolean;
     /** 시그널(테스트 주입 · 기본 process). */

package/dist/commands/dev.js

@@ -5,9 +5,16 @@
  *   1) Docker Compose  — pg · redis · nats · mailpit · minio 자동 up -d
  *   2) .gaon 워처       — tables.d.ts · routes.d.ts 재생성 (기존 M3)
  *   3) serve 자식       — 실 웹 서버(Fastify) · 소스 변경 시 재시작
- *   4) tsc / vue-tsc    — --watch 모드 · 타입 에러 즉시 리포트
- *   5) restart 워처     — apps/ · domain/ · packages/ 변경 → serve 재시작
- *   6) 통합 콘솔        — [source] 태그·색상별 · JSON 모드 지원
+ *   4) work 자식        — 워커(잡·리스너·아웃박스·스케줄) · 소스 변경 시 재시작 (결정 211)
+ *   5) hub 자식         — 실시간 허브(프레즌스 권위·중계) (결정 211)
+ *   6) tsc / vue-tsc    — --watch 모드 · 타입 에러 즉시 리포트
+ *   7) restart 워처     — apps/ · domain/ · packages/ 변경 → serve·work 재시작
+ *   8) 통합 콘솔        — [source] 태그·색상별 · JSON 모드 지원
+ *
+ * 운영 프로세스 3종(serve·work·hub · §7)을 dev 에서 모두 내장 기동한다
+ * (Rails-like all-in-one · 결정 211). 이전에는 serve 만 떠 잡·이벤트·아웃박스·
+ * 크론이 dev 에서 조용히 처리되지 않았다(work 부재) — work.ts·hub.ts 주석이
+ * 이미 "dev 가 내장 실행" 이라 명시했으나 실제로는 미배선이던 드리프트를 닫는다.
  *
  * The One Way: `gaon dev` 하나로 전부 · 옵션은 개별 debug 용만 노출.
  * fail-closed: Docker 없으면 명확 안내(§7.5.3), 목업 대체 절대 X (§9).
@@ -33,6 +40,12 @@ import { ensureInfra, composeDown } from '../dev/docker.js';
 import { startTscWatchers, killChild } from '../dev/tsc.js';
 import { startRestartWatcher } from '../dev/watcher.js';
 import { startFrontendBuild } from '../dev/frontend-build.js';
+/**
+ * dev 워커의 기본 큐 동시성(결정 211). 운영 기본은 1(보수적)이나 dev 는
+ * 잡을 병렬 처리해 반복을 빠르게 하고 동시성 속성(분산 락 등)을 단일
+ * 워커에서도 관측하게 한다. 사용자가 GAON_WORKER_CONCURRENCY 를 주면 존중.
+ */
+const DEV_WORKER_CONCURRENCY = 4;
 /**
  * gaon 셀프 경로를 찾는다. 부모가 gaon 으로 실행됐다면 argv[1] 이
  * gaonjs/dist/cli.js (또는 개발 시 packages/gaonjs/src/cli.ts). 자식
@@ -78,6 +91,26 @@ function spawnServe(args) {
     child.on('exit', (code, signal) => args.onExit(code, signal));
     return child;
 }
+/**
+ * 운영 프로세스(work·hub)를 하나 띄운다(결정 211). serve 와 동일하게 셀프 CLI
+ * 진입점을 재사용해 사용자 환경에서 강제 폴백 없이 같은 gaon 을 다시 부른다.
+ * stdout/stderr 을 통합 콘솔의 해당 소스 태그로 파이프한다.
+ */
+function spawnProcess(args) {
+    const { node, args: nodeArgs } = resolveSelfCliEntry();
+    const cmdArgs = [args.kind];
+    if (args.json)
+        cmdArgs.push('--json');
+    const child = spawn(node, [...nodeArgs, ...cmdArgs], {
+        cwd: args.cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, ...args.extraEnv },
+    });
+    child.stdout?.on('data', (b) => args.console.pipe(args.kind, b, 'info'));
+    child.stderr?.on('data', (b) => args.console.pipe(args.kind, b, 'error'));
+    child.on('exit', (code, signal) => args.onExit(code, signal));
+    return child;
+}
 /**
  * .gaon 재생성 파이프라인(M3)을 띄운다. 로그는 통합 콘솔로 흘리고,
  * 이 모듈은 층분리를 위해 startDev 를 그대로 재사용한다.
@@ -211,6 +244,69 @@ export async function runDevCommand(opts = {}) {
         });
     };
     serveChild = startServe();
+    // ── 4') work 자식(잡·리스너·아웃박스·스케줄 · 결정 211) ─────────────
+    //   work 는 도메인(잡·리스너·스케줄)을 로드하므로 serve 와 같은 파일 변경에
+    //   재시작한다. NATS 부재(예: --no-docker + 외부 NATS 없음)면 연결 실패로
+    //   종료하는데, 이는 dev 를 죽이지 않고 안내만 남긴다(fail-soft).
+    let workChild;
+    const abnormalHint = (kind) => `${kind} 자식이 비정상 종료 — NATS 가 떴는지 확인하세요(compose 재사용 또는 --no-${kind} 로 끌 수 있음).`;
+    const startWork = () => {
+        consoleOut.log('work', '▶ work 자식 프로세스 spawn');
+        return spawnProcess({
+            kind: 'work',
+            cwd,
+            json,
+            console: consoleOut,
+            // dev 워커는 잡을 병렬 처리한다(기본 1 → DEV_WORKER_CONCURRENCY). 헤드오브라인
+            // 블로킹을 없애 개발 반복을 빠르게 하고, 분산 락(중첩 방지) 같은 동시성 속성이
+            // 단일 dev 워커에서도 관측되게 한다. 사용자가 GAON_WORKER_CONCURRENCY 를 이미
+            // 주면 그 값을 존중한다(override 하지 않음).
+            extraEnv: process.env.GAON_WORKER_CONCURRENCY == null || process.env.GAON_WORKER_CONCURRENCY === ''
+                ? { GAON_WORKER_CONCURRENCY: String(DEV_WORKER_CONCURRENCY) }
+                : undefined,
+            onExit: (code, signal) => {
+                if (shuttingDown)
+                    return;
+                if (restartInFlight)
+                    return;
+                if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT')
+                    return;
+                consoleOut.log('work', abnormalHint('work'), 'warn');
+            },
+        });
+    };
+    if (opts.noWork !== true) {
+        workChild = startWork();
+    }
+    else {
+        consoleOut.log('work', '--no-work · 워커 자동 기동 비활성화');
+    }
+    // ── 4'') hub 자식(실시간 프레즌스 권위·중계 · 결정 211) ─────────────
+    //   hub 는 사용자 도메인 코드를 로드하지 않는(인프라 라우팅) 프로세스라
+    //   파일 변경에 재시작하지 않는다 — 시작 시 한 번 띄우고 종료 때만 내린다.
+    let hubChild;
+    const startHub = () => {
+        consoleOut.log('hub', '▶ hub 자식 프로세스 spawn');
+        return spawnProcess({
+            kind: 'hub',
+            cwd,
+            json,
+            console: consoleOut,
+            onExit: (code, signal) => {
+                if (shuttingDown)
+                    return;
+                if (code === 0 || signal === 'SIGTERM' || signal === 'SIGINT')
+                    return;
+                consoleOut.log('hub', abnormalHint('hub'), 'warn');
+            },
+        });
+    };
+    if (opts.noHub !== true) {
+        hubChild = startHub();
+    }
+    else {
+        consoleOut.log('hub', '--no-hub · 허브 자동 기동 비활성화');
+    }
     const restartServe = async (changed) => {
         if (shuttingDown)
             return;
@@ -221,12 +317,20 @@ export async function runDevCommand(opts = {}) {
         consoleOut.log('watcher', `↻ 재시작 — ${summary}`);
         restartInFlight = (async () => {
             try {
+                // serve·work 를 함께 재시작한다(둘 다 도메인/앱 코드를 로드).
+                const killers = [];
                 if (serveChild && serveChild.exitCode === null && serveChild.signalCode === null) {
-                    await killChild(serveChild, 3000);
+                    killers.push(killChild(serveChild, 3000));
                 }
+                if (workChild && workChild.exitCode === null && workChild.signalCode === null) {
+                    killers.push(killChild(workChild, 3000));
+                }
+                await Promise.all(killers);
                 if (shuttingDown)
                     return;
                 serveChild = startServe();
+                if (opts.noWork !== true)
+                    workChild = startWork();
             }
             finally {
                 restartInFlight = undefined;
@@ -246,7 +350,8 @@ export async function runDevCommand(opts = {}) {
             ? `▶ 재시작 워치 — ${restartWatcher.roots.map((r) => shortenPath(r, cwd)).join(', ')}`
             : `▶ 재시작 워치 — 감시 대상 없음(apps/ · domain/ 등 확인)`);
     }
-    consoleOut.log('dev', `준비 완료 — 부팅 ${Date.now() - startedAt}ms (Ctrl+C 로 종료)`);
+    const procs = ['serve', opts.noWork !== true && 'work', opts.noHub !== true && 'hub'].filter(Boolean).join(' · ');
+    consoleOut.log('dev', `준비 완료 — 부팅 ${Date.now() - startedAt}ms · 프로세스 ${procs} (Ctrl+C 로 종료)`);
     // ── 6) SIGINT/SIGTERM → graceful ────────────────────────────────
     await new Promise((resolvePromise) => {
         const stop = () => {
@@ -258,11 +363,15 @@ export async function runDevCommand(opts = {}) {
             consoleOut.log('dev', '종료 신호 수신 — 정리 중...');
             void (async () => {
                 try {
-                    // 순서: 재시작 워처 → serve → tsc → .gaon 워처 → Docker(옵션)
+                    // 순서: 재시작 워처 → serve·work·hub → tsc → .gaon 워처 → Docker(옵션)
                     restartWatcher?.close();
-                    if (serveChild) {
-                        await killChild(serveChild, 5000);
-                    }
+                    // serve·work·hub 는 서로 독립이라 병렬로 내린다. work 은 graceful
+                    // drain(진행 중 잡 대기)에 시간이 더 걸릴 수 있어 상한을 넉넉히 준다.
+                    await Promise.all([
+                        serveChild ? killChild(serveChild, 5000) : Promise.resolve(),
+                        workChild ? killChild(workChild, 8000) : Promise.resolve(),
+                        hubChild ? killChild(hubChild, 5000) : Promise.resolve(),
+                    ]);
                     if (tsc) {
                         await tsc.stop();
                     }

package/dist/dev/console.d.ts

@@ -13,7 +13,7 @@
  * 정책상 chalk 는 쓰지 않는다 — 필요한 코드만 직접 쓴다.
  */
 /** 콘솔이 구분하는 로그 소스. */
-export type DevSource = 'dev' | 'docker' | 'serve' | 'watcher' | 'tsc' | 'vue-tsc' | 'vite';
+export type DevSource = 'dev' | 'docker' | 'serve' | 'work' | 'hub' | 'watcher' | 'tsc' | 'vue-tsc' | 'vite';
 /** 로그 레벨 — human 은 색상 강조, json 은 필드로 실린다. */
 export type DevLevel = 'info' | 'warn' | 'error';
 export interface DevConsoleOptions {

package/dist/dev/console.js

@@ -23,6 +23,8 @@ const SOURCE_COLOR = {
     dev: '\x1b[35m', // magenta — 오케스트레이터
     docker: '\x1b[34m', // blue — 인프라
     serve: '\x1b[32m', // green — 웹 서버
+    work: '\x1b[93m', // bright yellow — 워커(잡·리스너·아웃박스·스케줄)
+    hub: '\x1b[94m', // bright blue — 실시간 허브
     watcher: '\x1b[36m', // cyan — 파일 감시
     tsc: '\x1b[33m', // yellow — 타입 검사
     'vue-tsc': '\x1b[95m', // bright magenta — vue 전용

package/dist/index.js

@@ -96,9 +96,9 @@ function renderHelp(version = VERSION) {
         "  사용법:",
         "    gaon               로드맵과 개발 상태를 출력",
         "    gaon new <name>    새 프로젝트 스캐폴드 (파일 → 설치 → git · --skip-install · --skip-git · --package-manager <pnpm|npm|yarn>)",
-        "    gaon dev           개발 스택 통합 (Docker · .gaon · serve · tsc/vue-tsc · 재시작 워처)",
+        "    gaon dev           개발 스택 통합 (Docker · .gaon · serve · work · hub · tsc/vue-tsc · 재시작 워처)",
         "    gaon dev --stop-docker  Ctrl+C 시 Docker Compose 도 down",
-        "    gaon dev --no-watch|--no-tsc|--no-vue-tsc|--no-docker  개별 debug 옵션",
+        "    gaon dev --no-watch|--no-tsc|--no-vue-tsc|--no-docker|--no-work|--no-hub  개별 debug 옵션",
         "    gaon dev --port <n> --host <h>  serve 리슨 지정",
         "    gaon dev --json    통합 콘솔을 JSON 라인으로 출력(자동화)",
         "    gaon serve         웹 서버 부팅 (gaon.config.ts 자동 배선 · Fastify listen)",
@@ -207,9 +207,10 @@ export function runCli(argv, opts = {}) {
     // 설정된 env 를 덮지 않고 파일이 없으면 조용히 지나가 멱등하다(재호출 안전).
     loadDotEnv();
     // `gaon dev` — 통합 개발 오케스트레이션(M9-C · v0.15 §13.5). Docker Compose
-    // 자동 기동 + .gaon 재생성 + serve 자식 + tsc/vue-tsc watch + 서버 재시작 워처.
-    // SIGINT/SIGTERM 시 순서대로 정리(serve → tsc → 워처 → Docker[--stop-docker 시]).
-    // 개별 debug 옵션은 --no-watch / --no-tsc / --no-vue-tsc / --no-docker 뿐.
+    // 자동 기동 + .gaon 재생성 + serve·work·hub 자식(운영 3종 all-in-one · 결정 211)
+    // + tsc/vue-tsc watch + 서버 재시작 워처. SIGINT/SIGTERM 시 순서대로 정리
+    // (serve·work·hub → tsc → 워처 → Docker[--stop-docker 시]).
+    // 개별 debug 옵션은 --no-watch / --no-tsc / --no-vue-tsc / --no-docker / --no-work / --no-hub.
     if (argv[0] === "dev") {
         const portIdx = argv.indexOf("--port");
         const hostIdx = argv.indexOf("--host");
@@ -222,6 +223,8 @@ export function runCli(argv, opts = {}) {
             noTsc: argv.includes("--no-tsc"),
             noVueTsc: argv.includes("--no-vue-tsc"),
             noDocker: argv.includes("--no-docker"),
+            noWork: argv.includes("--no-work"),
+            noHub: argv.includes("--no-hub"),
             timestamp: argv.includes("--timestamp"),
             port,
             host,

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

@@ -204,8 +204,8 @@ gaon doctor       # 정적 검사 26종 (§2.2)
 | 명령 | 역할 |
 |---|---|
 | `gaon new <name>` | 프로젝트 스캐폴드 |
-| `gaon dev` | 통합 개발 오케스트레이션 (Docker·`.gaon` 재생성·**코드 변경 감시·재시작**) |
-| `gaon serve` / `work` / `hub` | 운영 프로세스 3종 (웹 · 워커 · 실시간 허브) — **감시 없음** · 웹은 `PORT`, 허브는 `GAON_HUB_PORT` |
+| `gaon dev` | 통합 개발 오케스트레이션 (Docker·`.gaon` 재생성·**serve·work·hub 자동 기동**·**코드 변경 감시·재시작** · 결정 211) |
+| `gaon serve` / `work` / `hub` | 운영 프로세스 3종 (웹 · 워커 · 실시간 허브) — **감시 없음** · 배포 배치용(`gaon dev` 가 개발 중엔 셋을 내장 기동) · 웹은 `PORT`, 허브는 `GAON_HUB_PORT` |
 | `gaon g <type> <name>` | 스캐폴드: `auth`·`controller`·`model`·`page`·`job` |
 | `gaon db <sub>` | `diff`·`migrate`(`down`)·`status`·`reset`·`seed` (`agents/data.md` §10) |
 | `gaon check` / `test` / `doctor` | 검증 루프 |

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

@@ -244,8 +244,9 @@ export default schedule((s) => {
   처리돼도 안전하게).
 - **`gaon serve` 는 스케줄러를 돌리지 않는다** — 스케줄·리더 선출·아웃박스
   릴레이는 **`gaon work` 전용**이다. 웹 프로세스는 잡을 **발행**만 할 수 있고
-  (`.later()`), 처리·스케줄은 워커가 한다. 스케줄이 안 도는 흔한 원인은
-  `gaon work` 를 안 띄운 것이다.
+  (`.later()`), 처리·스케줄은 워커가 한다. **운영에서** 스케줄이 안 도는 흔한
+  원인은 `gaon work` 를 안 띄운 것이다(개발은 `gaon dev` 가 work 를 자동 기동
+  하므로 해당 없음 · 결정 211 · §6).
 
 #### 시간대 (결정 202)
 
@@ -282,6 +283,30 @@ drain — 스케줄러 리더를 반납하고 진행 중인 잡을 완료한 뒤
 - **컨테이너 기본 워커 1** — `gaon serve` 클러스터(`--workers`)도 SIGTERM 에
   워커들을 graceful drain 후 종료한다(결정 84).
 
+#### 개발 모드는 work·hub 를 자동 기동한다 (결정 211)
+
+**`gaon dev` 는 운영 3종(serve·work·hub)을 모두 내장 기동한다.** 개발 중에는
+`gaon work`·`gaon hub` 를 따로 띄울 필요가 없다 — 잡·이벤트·리스너·아웃박스
+릴레이·스케줄·실시간이 `gaon dev` 하나로 전부 처리된다(Rails-like all-in-one).
+`gaon work`·`gaon hub` **명령 자체는 운영 배치용**으로 남는다(컨테이너·프로세스
+매니저에서 각각 스케일).
+
+- **재시작** — 도메인(잡·리스너·스케줄) 파일을 저장하면 serve 와 함께 work 도
+  재시작된다. hub 는 사용자 도메인을 로드하지 않아(인프라 라우팅) 재시작하지 않는다.
+- **끄기** — 개별 debug 시 `gaon dev --no-work` · `--no-hub`. 기본은 켬.
+- **동시성** — dev 워커는 잡을 병렬 처리하도록 큐 기본 동시성을 4로 올린다
+  (`GAON_WORKER_CONCURRENCY` 로 덮음 · 운영 `gaon work` 기본은 1). 그래서 지연
+  잡이 서로 막지 않고, 분산 락 중첩 방지(§7·§5) 같은 동시성 거동을 dev 에서도
+  관측할 수 있다.
+- **NATS 필요** — work·hub 는 NATS 에 붙는다. `gaon dev` 의 compose 가 NATS 를
+  자동 기동하므로 보통 문제없다. `--no-docker` 로 외부 NATS 없이 띄우면 work·hub
+  는 연결 실패로 조용히 종료하고 dev 는 계속된다(안내 로그 · `--no-*` 로 끌 수 있음).
+
+> 이전에는 `gaon dev` 가 serve 만 띄워, 잡·이벤트·아웃박스·스케줄이 개발 중
+> 조용히 처리되지 않는 함정이 있었다(work 미기동). 결정 211 이 이를 닫았다 —
+> "스케줄이 안 도는 흔한 원인은 `gaon work` 를 안 띄운 것" 은 이제 **운영에만**
+> 해당하고, 개발에선 `gaon dev` 가 알아서 띄운다.
+
 ### 7. 분산 락 (`lock()`) (결정 147)
 
 **동시 실행을 막아야 하면 `lock(key, fn)`** — 같은 `key` 에 대해 전
@@ -377,4 +402,5 @@ async create() {
 | 결정 200 | DLQ 재처리 `retryDlq(nats, id)` (이미 설정된 잡 전송 보존 · DLQ 재적재 후 원본 삭제) |
 | 결정 201 | graceful drain 계약 (serve 인플라이트 요청 완결 · work 진행 잡 완결 · §6) |
 | 결정 202 | 락·캐시 백엔드 serve·work 공통 배선(wireDomain) · 잡/서비스 lock() 가능 · 스케줄러 시간대(서버 로컬 TZ)·중첩 방지(§5·§7) |
+| 결정 211 | `gaon dev` all-in-one — serve·work·hub 자동 기동 · dev 워커 동시성 4(`GAON_WORKER_CONCURRENCY`) · `--no-work`/`--no-hub` (§6) |
 | §7 | 비동기 배터리 원문 (백오프 기본값 = M7 벤치마크 확정) |

package/dist/work.js

@@ -104,7 +104,10 @@ export async function runWorkCommand(opts = {}) {
             id,
             db,
             schedule: domain.schedule,
-            concurrency: opts.concurrency,
+            // 큐 기본 동시성: 옵션 > GAON_WORKER_CONCURRENCY > 잡별 선언 > 1. 잡에
+            // 명시 concurrency 가 있으면 그게 우선(worker.ts perQueueConc). 운영은
+            // 이 env 로 워커 처리량을 조절하고, gaon dev 는 개발 편의로 기본 상향한다.
+            concurrency: opts.concurrency ?? envInt('GAON_WORKER_CONCURRENCY'),
             ackWaitMs: opts.ackWaitMs ?? envInt('GAON_WORKER_ACK_WAIT_MS'),
             drainTimeoutMs: opts.drainTimeoutMs ?? envInt('GAON_WORKER_DRAIN_MS'),
             onEvent: emit,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gaonjs/cli",
-  "version": "0.37.1",
+  "version": "0.38.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.12.0",
+    "@gaonjs/data": "0.16.1",
     "@gaonjs/config": "0.15.2",
     "@gaonjs/core": "0.2.2",
-    "@gaonjs/mail": "0.2.1",
     "@gaonjs/i18n": "0.2.1",
-    "@gaonjs/data": "0.16.1",
-    "@gaonjs/web": "0.18.1"
+    "@gaonjs/web": "0.18.1",
+    "@gaonjs/mail": "0.2.1"
   },
   "scripts": {
     "build": "node ../../node_modules/typescript/bin/tsc -p tsconfig.json && node -e \"require('fs').cpSync('src/templates','dist/templates',{recursive:true})\""