@fluojs/cli 1.0.0-beta.4 → 1.0.0-beta.6

package/dist/new/scaffold.js

@@ -41,7 +41,8 @@ const PUBLISHED_INTERNAL_DEPENDENCIES = {
   '@fluojs/platform-nodejs': '^1.0.0-beta.4',
   '@fluojs/runtime': '^1.0.0-beta.9',
   '@fluojs/testing': '^1.0.0-beta.2',
-  '@fluojs/validation': '^1.0.0-beta.2'
+  '@fluojs/validation': '^1.0.0-beta.2',
+  '@fluojs/vite': '^1.0.0-beta.1'
 };
 function describeApplicationStarter(options) {
   if (options.runtime === 'bun') {
@@ -148,15 +149,17 @@ function createProjectScripts(bootstrapPlan) {
     case 'application-bun-bun-http':
       return {
         build: 'bun build ./src/main.ts --outdir ./dist --target bun',
-        dev: 'bun --watch src/main.ts',
+        dev: 'fluo dev',
+        start: 'bun dist/main.js',
         test: 'vitest run',
         'test:watch': 'vitest',
         typecheck: 'tsc -p tsconfig.json --noEmit'
       };
     case 'application-deno-deno-http':
       return {
-        build: 'mkdir -p dist && deno compile --allow-env --allow-net --output dist/app src/main.ts',
-        dev: 'deno run --allow-env --allow-net --watch src/main.ts',
+        build: 'deno compile --allow-env --allow-net --output dist/app src/main.ts',
+        dev: 'fluo dev',
+        start: './dist/app',
         test: 'deno test --allow-env --allow-net',
         'test:watch': 'deno test --allow-env --allow-net --watch',
         typecheck: 'deno check src/main.ts src/app.test.ts'
@@ -164,15 +167,18 @@ function createProjectScripts(bootstrapPlan) {
     case 'application-cloudflare-workers-cloudflare-workers-http':
       return {
         build: 'wrangler deploy --dry-run',
-        dev: 'wrangler dev',
+        deploy: 'wrangler deploy',
+        dev: 'fluo dev',
+        preview: 'wrangler dev --remote --show-interactive-dev-session=false',
         test: 'vitest run',
         'test:watch': 'vitest',
         typecheck: 'tsc -p tsconfig.json --noEmit'
       };
     default:
       return {
-        build: 'babel src --extensions .ts --out-dir dist --config-file ./babel.config.cjs && tsc -p tsconfig.build.json',
-        dev: 'node --env-file=.env --watch --watch-preserve-output --import tsx src/main.ts',
+        build: 'fluo build',
+        dev: 'fluo dev',
+        start: 'fluo start',
         test: 'vitest run',
         'test:watch': 'vitest',
         typecheck: 'tsc -p tsconfig.json --noEmit'
@@ -199,6 +205,12 @@ function createPublishedDevDependencies(bootstrapPlan) {
   if (bootstrapPlan.profile.id === 'application-deno-deno-http') {
     return {};
   }
+  if (bootstrapPlan.profile.id === 'application-bun-bun-http') {
+    return {
+      ...PUBLISHED_DEV_DEPENDENCIES,
+      '@types/bun': '^1.2.5'
+    };
+  }
   if (bootstrapPlan.profile.id === 'application-cloudflare-workers-cloudflare-workers-http') {
     return {
       ...PUBLISHED_DEV_DEPENDENCIES,
@@ -239,7 +251,8 @@ function createProjectPackageJson(options, bootstrapPlan, releaseVersion, packag
     }
   }, null, 2);
 }
-function createProjectTsconfig() {
+function createProjectTsconfig(bootstrapPlan) {
+  const types = bootstrapPlan.profile.id === 'application-bun-bun-http' ? ['node', 'bun'] : ['node'];
   return `{
   "compilerOptions": {
     "target": "ES2022",
@@ -253,7 +266,7 @@ function createProjectTsconfig() {
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
     "rootDir": "src",
-    "types": ["node"]
+    "types": ${JSON.stringify(types)}
   },
   "include": ["src/**/*.ts"]
 }
@@ -281,9 +294,22 @@ function createBabelConfig() {
 `;
 }
 function createViteConfig() {
-  return `import { defineConfig } from 'vite';
+  return `import { fluoDecoratorsPlugin } from '@fluojs/vite';
+import { defineConfig } from 'vite';
 
 export default defineConfig({
+  plugins: [fluoDecoratorsPlugin()],
+  build: {
+    emptyOutDir: true,
+    outDir: 'dist',
+    rollupOptions: {
+      output: {
+        entryFileNames: 'main.js',
+      },
+    },
+    ssr: 'src/main.ts',
+    target: 'node20',
+  },
   server: {
     port: 5173,
   },
@@ -315,12 +341,37 @@ dist
 coverage
 `;
 }
+function createHttpPackageManagerLine(options) {
+  switch (options.runtime) {
+    case 'bun':
+      return `- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')} keeps the \`fluo dev\` abstraction while defaulting to Bun's native watch loop (\`bun --watch src/main.ts\`) for fewer Node-supervised dev processes, \`fluo dev --runner fluo\` restores the Node-backed fluo restart supervisor when you need its debounce/hash reporter contract, and ${createRunCommand(options.packageManager, 'build')} plus ${createRunCommand(options.packageManager, 'start')} run Bun-native production commands (\`bun build ./src/main.ts --outdir ./dist --target bun\` then \`bun dist/main.js\`) so deployment targets do not need Node just to start the built app`;
+    case 'deno':
+      return `- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')} keeps the \`fluo dev\` abstraction while defaulting to Deno's native watch loop (\`deno run --watch --allow-env --allow-net src/main.ts\`) for fewer Node-supervised dev processes, \`fluo dev --runner fluo\` restores the Node-backed fluo restart supervisor when you need its debounce/hash reporter contract, and ${createRunCommand(options.packageManager, 'build')} plus ${createRunCommand(options.packageManager, 'start')} run Deno-native production commands (\`deno compile --allow-env --allow-net --output dist/app src/main.ts\` then \`./dist/app\`) so deployment targets can run the compiled app without Node`;
+    case 'cloudflare-workers':
+      return `- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')} keeps the \`fluo dev\` abstraction while defaulting to Wrangler's native dev loop (\`wrangler dev --show-interactive-dev-session=false\`) for Wrangler-owned reloads, \`fluo dev --runner fluo\` restores the Node-backed fluo restart supervisor when you need its debounce/hash reporter contract, and ${createRunCommand(options.packageManager, 'preview')} plus ${createRunCommand(options.packageManager, 'deploy')} run Wrangler-native preview/deploy commands; Wrangler tooling requires Node/npm-compatible tooling locally, but deployed Workers run on Cloudflare's isolate runtime`;
+    default:
+      return `- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')}, ${createRunCommand(options.packageManager, 'build')}, and ${createRunCommand(options.packageManager, 'start')} delegate to \`fluo dev\`, \`fluo build\`, and \`fluo start\`, which own the generated runtime lifecycle and default \`NODE_ENV\` when unset`;
+  }
+}
+function createHttpCommandsSection(options) {
+  const commands = [`- Dev: ${createRunCommand(options.packageManager, 'dev')}`, `- Build: ${createRunCommand(options.packageManager, 'build')}`];
+  if (options.runtime === 'bun' || options.runtime === 'deno' || options.runtime === 'cloudflare-workers') {
+    commands.push('- Dev fluo restart fallback: fluo dev --runner fluo');
+  }
+  if (options.runtime === 'cloudflare-workers') {
+    commands.push(`- Preview: ${createRunCommand(options.packageManager, 'preview')}`, `- Deploy: ${createRunCommand(options.packageManager, 'deploy')}`);
+  } else {
+    commands.push(`- Start: ${createRunCommand(options.packageManager, 'start')}`);
+  }
+  commands.push(`- Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}`, `- Test: ${createRunCommand(options.packageManager, 'test')}`);
+  return commands.join('\n');
+}
 function createHttpProjectReadme(options) {
   const starter = describeApplicationStarter(options);
   const entrypointLabel = starter.entrypoint;
   const starterContract = options.runtime === 'deno' ? `\`${entrypointLabel}\` boots the selected first-class application starter: ${starter.runtimeLabel} + ${starter.platformLabel} via \`runDenoApplication(...)\`` : options.runtime === 'cloudflare-workers' ? `\`${entrypointLabel}\` exports the selected first-class application starter: ${starter.runtimeLabel} + ${starter.platformLabel} via \`createCloudflareWorkerEntrypoint(...)\`` : `\`${entrypointLabel}\` wires the selected first-class application starter: ${starter.runtimeLabel} + ${starter.platformLabel} via \`${starter.adapterFactory}(... )\``.replace('(... )', '(...)');
   const corsLine = options.runtime === 'cloudflare-workers' ? '- CORS: defaults to allowOrigin `*`; pass a `cors` option to `createCloudflareWorkerEntrypoint(..., { cors })` when you need edge-specific restrictions' : options.runtime === 'deno' ? '- CORS: defaults to allowOrigin `*`; configure it through the Deno HTTP bootstrap path before exposing the adapter in production' : `- CORS: defaults to allowOrigin '*'; pass a \`cors\` option to \`FluoFactory.create(..., { cors, adapter: ${starter.adapterFactory}(...) })\` to restrict origins`;
-  const testingSection = options.runtime === 'deno' ? `## Official generated testing templates\n\n- \`src/app.test.ts\` — Deno-native integration-style dispatch verification for the generated runtime + starter routes.\n\nUse this test when you need confidence that the generated Deno entrypoint and module graph still agree on the same HTTP contract.` : `## Official generated testing templates\n\n- \`src/health/*.test.ts\` — unit templates for the starter-owned health slice.\n- \`src/app.test.ts\` — integration-style dispatch template for runtime + starter routes.\n- \`src/app.e2e.test.ts\` — e2e-style template powered by \`createTestApp\` from \`@fluojs/testing\`.\n- \`${createExecCommand(options.packageManager, 'fluo g repo User')}\` also adds:\n  - \`src/users/user.repo.test.ts\` (unit template)\n  - \`src/users/user.repo.slice.test.ts\` (slice/integration template via \`createTestingModule\`)\n\nUse unit templates for fast logic checks. Use slice/e2e templates when you need module wiring and route-level confidence.`;
+  const testingSection = options.runtime === 'deno' ? `## Official generated testing templates\n\n- \`src/app.test.ts\` — Deno-native integration-style dispatch verification for the generated runtime + starter routes.\n\nUse this test when you need confidence that the generated Deno entrypoint and module graph still agree on the same HTTP contract.` : `## Official generated testing templates\n\n- \`src/greeting/*.test.ts\` — unit templates for the starter-owned greeting slice.\n- \`src/app.test.ts\` — integration-style dispatch template for runtime + starter routes.\n- \`src/app.e2e.test.ts\` — e2e-style template powered by \`createTestApp\` from \`@fluojs/testing\`.\n- \`${createExecCommand(options.packageManager, 'fluo g repo User')}\` also adds:\n  - \`src/users/user.repo.test.ts\` (unit template)\n  - \`src/users/user.repo.slice.test.ts\` (slice/integration template via \`createTestingModule\`)\n\nUse unit templates for fast logic checks. Use slice/e2e templates when you need module wiring and route-level confidence.`;
   return `# ${options.projectName}
 
 Generated by @fluojs/cli.
@@ -328,19 +379,16 @@ Generated by @fluojs/cli.
 - Starter contract: ${starterContract}
 - Default baseline: when you omit \`--platform\`, \`fluo new\` still generates the Node.js + Fastify HTTP starter by default
 - Broader runtime/adapter package coverage is documented in the fluo docs and package READMEs; this generated starter intentionally describes only the wired starter path above
-- Package manager: install/run commands can use ${options.packageManager}; runtime choice stays explicit and is independent from the package manager you picked
+${createHttpPackageManagerLine(options)}
 - Runtime dependency set: generated manifest entries match the selected runtime contract instead of inheriting the Node-only starter recipe
 ${corsLine}
 - Observability: /health and /ready endpoints are included by default
 - Runtime path: bootstrapApplication -> handler mapping -> dispatcher -> middleware -> guard -> interceptor -> controller
-- Naming policy: runtime module entrypoints use governed canonical names (\`forRoot(...)\`, optional \`forRootAsync(...)\`, \`register(...)\`, \`forFeature(...)\`); helper/builders stay \`create*\` (for example \`createHealthModule()\`, \`createTestingModule(...)\`)
+- Naming policy: runtime module entrypoints use governed canonical names (\`forRoot(...)\`, optional \`forRootAsync(...)\`, \`register(...)\`, \`forFeature(...)\`); helper/builders stay \`create*\` (for example \`createTestingModule(...)\`)
 
 ## Commands
 
-- Dev: ${createRunCommand(options.packageManager, 'dev')}
-- Build: ${createRunCommand(options.packageManager, 'build')}
-- Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}
-- Test: ${createRunCommand(options.packageManager, 'test')}
+${createHttpCommandsSection(options)}
 
 ## Generator example
 
@@ -452,7 +500,7 @@ Generated by @fluojs/cli.
 - Transport: \`${starter.readmeTransportLabel}\` is the generated runnable starter contract for this project
 - Runtime: \`node\`
 - Platform: \`none\` because the microservice starter boots through \`@fluojs/microservices\`, not an HTTP adapter
-- Package manager: install/run commands can use ${options.packageManager}; ${starter.packageManagerNote}
+- Package manager: install/run commands can use ${options.packageManager}; ${createRunCommand(options.packageManager, 'dev')}, ${createRunCommand(options.packageManager, 'build')}, and ${createRunCommand(options.packageManager, 'start')} delegate to \`fluo dev\`, \`fluo build\`, and \`fluo start\`, which own the generated runtime lifecycle and default \`NODE_ENV\` when unset; ${starter.packageManagerNote}
 - Messaging contract: \`src/math/math.handler.ts\` exposes a \`${starter.pattern}\` message pattern and the generated tests verify it through an in-memory transport so the starter stays testable without external brokers
 - Entrypoint contract: ${starter.entrypointNote}
 - Starter contract note: ${starter.starterNote}
@@ -461,6 +509,7 @@ Generated by @fluojs/cli.
 ## Commands
 
 - Dev: ${createRunCommand(options.packageManager, 'dev')}
+- Start: ${createRunCommand(options.packageManager, 'start')}
 - Build: ${createRunCommand(options.packageManager, 'build')}
 - Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}
 - Test: ${createRunCommand(options.packageManager, 'test')}
@@ -502,30 +551,26 @@ function createAppFile(options) {
   const importSuffix = options.runtime === 'deno' ? '.ts' : '';
   if (options.runtime === 'cloudflare-workers') {
     return `import { Global, Module } from '@fluojs/core';
-import { createHealthModule } from '@fluojs/runtime';
-
-import { HealthModule } from './health/health.module';
+import { HealthModule } from '@fluojs/runtime';
 
-const RuntimeHealthModule = createHealthModule();
+import { GreetingModule } from './greeting/greeting.module';
 
 @Global()
 @Module({
   imports: [
-    HealthModule,
-    RuntimeHealthModule,
+    GreetingModule,
+    HealthModule.forRoot(),
   ],
 })
 export class AppModule {}
 `;
   }
-  const processEnvValue = options.runtime === 'bun' ? 'Bun.env' : options.runtime === 'deno' ? 'Deno.env.toObject()' : 'process.env';
+  const processEnvValue = options.runtime === 'deno' ? 'Deno.env.toObject()' : 'process.env';
   return `import { Global, Module } from '@fluojs/core';
 import { ConfigModule } from '@fluojs/config';
-import { createHealthModule } from '@fluojs/runtime';
-
-import { HealthModule } from './health/health.module${importSuffix}';
+import { HealthModule } from '@fluojs/runtime';
 
-const RuntimeHealthModule = createHealthModule();
+import { GreetingModule } from './greeting/greeting.module${importSuffix}';
 
 @Global()
 @Module({
@@ -534,132 +579,134 @@ const RuntimeHealthModule = createHealthModule();
       envFile: '.env',
       processEnv: ${processEnvValue},
     }),
-    HealthModule,
-    RuntimeHealthModule,
+    GreetingModule,
+    HealthModule.forRoot(),
   ],
 })
 export class AppModule {}
 `;
 }
-function createHealthResponseDtoFile() {
-  return `export class HealthResponseDto {
-  ok!: boolean;
-  service!: string;
+function createGreetingResponseDtoFile() {
+  return `export class GreetingResponseDto {
+  message!: string;
+  framework!: 'fluo';
+  project!: string;
 }
 `;
 }
-function createHealthRepoFile(projectName, importSuffix = '') {
-  return `import type { HealthResponseDto } from './health.response.dto${importSuffix}';
+function createGreetingRepoFile(projectName, importSuffix = '') {
+  return `import type { GreetingResponseDto } from './greeting.response.dto${importSuffix}';
 
-export class HealthRepo {
-  findHealth(): HealthResponseDto {
+export class GreetingRepo {
+  findGreeting(): GreetingResponseDto {
     return {
-      ok: true,
-      service: ${JSON.stringify(projectName)},
+      message: 'Hello from fluo',
+      framework: 'fluo',
+      project: ${JSON.stringify(projectName)},
     };
   }
 }
 `;
 }
-function createHealthRepoTestFile() {
+function createGreetingRepoTestFile() {
   return `import { describe, expect, it } from 'vitest';
 
-import { HealthRepo } from './health.repo';
+import { GreetingRepo } from './greeting.repo';
 
-describe('HealthRepo', () => {
-  it('returns health data', () => {
-    const repo = new HealthRepo();
-    expect(repo.findHealth()).toEqual({ ok: true, service: expect.any(String) });
+describe('GreetingRepo', () => {
+  it('returns greeting data', () => {
+    const repo = new GreetingRepo();
+    expect(repo.findGreeting()).toEqual({ message: 'Hello from fluo', framework: 'fluo', project: expect.any(String) });
   });
 });
 `;
 }
-function createHealthServiceFile(importSuffix = '') {
+function createGreetingServiceFile(importSuffix = '') {
   return `import { Inject } from '@fluojs/core';
-import type { HealthResponseDto } from './health.response.dto${importSuffix}';
+import type { GreetingResponseDto } from './greeting.response.dto${importSuffix}';
 
-import { HealthRepo } from './health.repo${importSuffix}';
+import { GreetingRepo } from './greeting.repo${importSuffix}';
 
-@Inject(HealthRepo)
-export class HealthService {
-  constructor(private readonly repo: HealthRepo) {}
+@Inject(GreetingRepo)
+export class GreetingService {
+  constructor(private readonly repo: GreetingRepo) {}
 
-  getHealth(): HealthResponseDto {
-    return this.repo.findHealth();
+  getGreeting(): GreetingResponseDto {
+    return this.repo.findGreeting();
   }
 }
 `;
 }
-function createHealthServiceTestFile() {
+function createGreetingServiceTestFile() {
   return `import { describe, expect, it } from 'vitest';
 
-import { HealthService } from './health.service';
-import { HealthRepo } from './health.repo';
+import { GreetingService } from './greeting.service';
+import { GreetingRepo } from './greeting.repo';
 
-class FakeHealthRepo {
-  findHealth() {
-    return { ok: true, service: 'test' };
+class FakeGreetingRepo {
+  findGreeting() {
+    return { message: 'Hello from fluo', framework: 'fluo' as const, project: 'test' };
   }
 }
 
-describe('HealthService', () => {
+describe('GreetingService', () => {
   it('delegates to the repo', () => {
-    const service = new HealthService(new FakeHealthRepo() as HealthRepo);
-    expect(service.getHealth()).toEqual({ ok: true, service: 'test' });
+    const service = new GreetingService(new FakeGreetingRepo() as GreetingRepo);
+    expect(service.getGreeting()).toEqual({ message: 'Hello from fluo', framework: 'fluo', project: 'test' });
   });
 });
 `;
 }
-function createHealthControllerFile(importSuffix = '') {
+function createGreetingControllerFile(importSuffix = '') {
   return `import { Inject } from '@fluojs/core';
 import { Controller, Get } from '@fluojs/http';
 
-import { HealthService } from './health.service${importSuffix}';
-import { HealthResponseDto } from './health.response.dto${importSuffix}';
+import { GreetingService } from './greeting.service${importSuffix}';
+import { GreetingResponseDto } from './greeting.response.dto${importSuffix}';
 
-@Inject(HealthService)
-@Controller('/health-info')
-export class HealthController {
-  constructor(private readonly service: HealthService) {}
+@Inject(GreetingService)
+@Controller('/greeting')
+export class GreetingController {
+  constructor(private readonly service: GreetingService) {}
 
   @Get('/')
-  getHealth(): HealthResponseDto {
-    return this.service.getHealth();
+  getGreeting(): GreetingResponseDto {
+    return this.service.getGreeting();
   }
 }
 `;
 }
-function createHealthControllerTestFile() {
+function createGreetingControllerTestFile() {
   return `import { describe, expect, it } from 'vitest';
 
-import { HealthController } from './health.controller';
+import { GreetingController } from './greeting.controller';
 
-class FakeHealthService {
-  getHealth() {
-    return { ok: true, service: 'test' };
+class FakeGreetingService {
+  getGreeting() {
+    return { message: 'Hello from fluo', framework: 'fluo' as const, project: 'test' };
   }
 }
 
-describe('HealthController', () => {
+describe('GreetingController', () => {
   it('delegates to the service', () => {
-    const controller = new HealthController(new FakeHealthService() as never);
-    expect(controller.getHealth()).toEqual({ ok: true, service: 'test' });
+    const controller = new GreetingController(new FakeGreetingService() as never);
+    expect(controller.getGreeting()).toEqual({ message: 'Hello from fluo', framework: 'fluo', project: 'test' });
   });
 });
 `;
 }
-function createHealthModuleFile(importSuffix = '') {
+function createGreetingModuleFile(importSuffix = '') {
   return `import { Module } from '@fluojs/core';
 
-import { HealthController } from './health.controller${importSuffix}';
-import { HealthRepo } from './health.repo${importSuffix}';
-import { HealthService } from './health.service${importSuffix}';
+import { GreetingController } from './greeting.controller${importSuffix}';
+import { GreetingRepo } from './greeting.repo${importSuffix}';
+import { GreetingService } from './greeting.service${importSuffix}';
 
 @Module({
-  controllers: [HealthController],
-  providers: [HealthRepo, HealthService],
+  controllers: [GreetingController],
+  providers: [GreetingRepo, GreetingService],
 })
-export class HealthModule {}
+export class GreetingModule {}
 `;
 }
 function createMainFile(options) {
@@ -1365,12 +1412,13 @@ Generated by @fluojs/cli.
 
 - Shape: \`mixed\`
 - Supported topology: \`single-package\` generates one shared Node.js package where the Fastify HTTP application also starts an attached TCP microservice from the same \`src/main.ts\`
-- Runtime contract: \`src/app.ts\` owns one shared module graph, and \`src/main.ts\` bootstraps the HTTP API before calling \`connectMicroservice()\` and \`startAllMicroservices()\`
+- Runtime contract: \`src/app.ts\` owns one shared module graph, and \`src/main.ts\` bootstraps the HTTP API before calling \`connectMicroservice()\` and \`startAllMicroservices()\`; ${createRunCommand(options.packageManager, 'dev')}, ${createRunCommand(options.packageManager, 'build')}, and ${createRunCommand(options.packageManager, 'start')} delegate to \`fluo dev\`, \`fluo build\`, and \`fluo start\`, which default \`NODE_ENV\` when unset
 - Intentional limitation: the first mixed release supports only the explicit Fastify HTTP + attached TCP microservice contract; other mixed transports or separate multi-entrypoint layouts fail validation instead of generating partial scaffolds
 
 ## Commands
 
 - Dev: ${createRunCommand(options.packageManager, 'dev')}
+- Start: ${createRunCommand(options.packageManager, 'start')}
 - Build: ${createRunCommand(options.packageManager, 'build')}
 - Typecheck: ${createRunCommand(options.packageManager, 'typecheck')}
 - Test: ${createRunCommand(options.packageManager, 'test')}
@@ -1379,12 +1427,12 @@ Generated by @fluojs/cli.
 
 - \`src/app.ts\` — shared application module with config, runtime health endpoints, and the TCP microservice registration.
 - \`src/main.ts\` — Fastify HTTP bootstrap that also starts the attached TCP microservice.
-- \`src/health/*\` — starter-owned HTTP health slice.
+- \`src/greeting/*\` — starter-owned HTTP greeting slice.
 - \`src/math/*\` — starter-owned message handler slice that proves the microservice half of the topology.
 
 ## Official generated testing templates
 
-- \`src/health/*.test.ts\` — unit templates for the HTTP slice.
+- \`src/greeting/*.test.ts\` — unit templates for the HTTP slice.
 - \`src/math/math.handler.test.ts\` — unit template for the microservice handler.
 - \`src/app.test.ts\` — hybrid verification template covering HTTP dispatch plus in-memory message routing with the same shared module contract.
 
@@ -1395,12 +1443,11 @@ function createMixedAppFile() {
   return `import { Global, Module } from '@fluojs/core';
 import { ConfigModule } from '@fluojs/config';
 import { MicroservicesModule, TcpMicroserviceTransport } from '@fluojs/microservices';
-import { createHealthModule } from '@fluojs/runtime';
+import { HealthModule } from '@fluojs/runtime';
 
-import { HealthModule } from './health/health.module';
+import { GreetingModule } from './greeting/greeting.module';
 import { MathHandler } from './math/math.handler';
 
-const RuntimeHealthModule = createHealthModule();
 const parsedMicroservicePort = Number.parseInt(process.env.MICROSERVICE_PORT ?? '4000', 10);
 const microservicePort = Number.isFinite(parsedMicroservicePort) ? parsedMicroservicePort : 4000;
 const microserviceHost = process.env.MICROSERVICE_HOST ?? '127.0.0.1';
@@ -1412,8 +1459,8 @@ const microserviceHost = process.env.MICROSERVICE_HOST ?? '127.0.0.1';
       envFile: '.env',
       processEnv: process.env,
     }),
-    HealthModule,
-    RuntimeHealthModule,
+    GreetingModule,
+    HealthModule.forRoot(),
     MicroservicesModule.forRoot({
       transport: new TcpMicroserviceTransport({ host: microserviceHost, port: microservicePort }),
     }),
@@ -1450,9 +1497,9 @@ import {
   MicroservicesModule,
   type MicroserviceTransport,
 } from '@fluojs/microservices';
-import { FluoFactory, createHealthModule } from '@fluojs/runtime';
+import { FluoFactory, HealthModule } from '@fluojs/runtime';
 
-import { HealthModule } from './health/health.module';
+import { GreetingModule } from './greeting/greeting.module';
 import { MathHandler } from './math/math.handler';
 
 type TransportHandler = Parameters<MicroserviceTransport['listen']>[0];
@@ -1527,8 +1574,6 @@ function createResponse(): FrameworkResponse & { body?: unknown } {
 describe('AppModule mixed starter', () => {
   it('keeps HTTP routes and message handlers in one explicit topology contract', async () => {
     const transport = new InMemoryLoopbackTransport();
-    const RuntimeHealthModule = createHealthModule();
-
     @Global()
     @Module({
       imports: [
@@ -1536,8 +1581,8 @@ describe('AppModule mixed starter', () => {
           envFile: '.env',
           processEnv: process.env,
         }),
-        HealthModule,
-        RuntimeHealthModule,
+        GreetingModule,
+        HealthModule.forRoot(),
         MicroservicesModule.forRoot({ transport }),
       ],
       providers: [MathHandler],
@@ -1545,13 +1590,13 @@ describe('AppModule mixed starter', () => {
     class TestAppModule {}
 
     const app = await FluoFactory.create(TestAppModule, {});
-    const healthResponse = createResponse();
+    const greetingResponse = createResponse();
 
     const microservice = await app.connectMicroservice();
 
-    await Promise.all([app.startAllMicroservices(), app.dispatch(createRequest('/health-info/'), healthResponse)]);
+    await Promise.all([app.startAllMicroservices(), app.dispatch(createRequest('/greeting/'), greetingResponse)]);
 
-    expect(healthResponse.body).toEqual({ ok: true, service: expect.any(String) });
+    expect(greetingResponse.body).toEqual({ message: 'Hello from fluo', framework: 'fluo', project: expect.any(String) });
     await expect(transport.send('math.sum', { a: 20, b: 22 })).resolves.toBe(42);
     expect(microservice.state).toBe('ready');
 
@@ -1622,13 +1667,13 @@ describe('AppModule', () => {
     await app.close();
   });
 
-  it('dispatches the health-info route', async () => {
+  it('dispatches the greeting route', async () => {
     const app = await FluoFactory.create(AppModule, {});
     const response = createResponse();
 
-    await app.dispatch(createRequest('/health-info/'), response);
+    await app.dispatch(createRequest('/greeting/'), response);
 
-    expect(response.body).toEqual({ ok: true, service: expect.any(String) });
+    expect(response.body).toEqual({ message: 'Hello from fluo', framework: 'fluo', project: expect.any(String) });
 
     await app.close();
   });
@@ -1654,8 +1699,8 @@ describe('AppModule e2e', () => {
       body: { status: 'ready' },
       status: 200,
     });
-    await expect(app.dispatch({ method: 'GET', path: '/health-info/' })).resolves.toMatchObject({
-      body: { ok: true, service: expect.any(String) },
+    await expect(app.dispatch({ method: 'GET', path: '/greeting/' })).resolves.toMatchObject({
+      body: { message: 'Hello from fluo', framework: 'fluo', project: expect.any(String) },
       status: 200,
     });
 
@@ -1714,7 +1759,7 @@ Deno.test('AppModule dispatches the generated Deno starter routes', async () =>
 
   await app.dispatch({ body: undefined, cookies: {}, headers: {}, method: 'GET', params: {}, path: '/health', query: {}, raw: {}, url: '/health' }, healthResponse as never);
   await app.dispatch({ body: undefined, cookies: {}, headers: {}, method: 'GET', params: {}, path: '/ready', query: {}, raw: {}, url: '/ready' }, readyResponse as never);
-  await app.dispatch({ body: undefined, cookies: {}, headers: {}, method: 'GET', params: {}, path: '/health-info/', query: {}, raw: {}, url: '/health-info/' }, infoResponse as never);
+  await app.dispatch({ body: undefined, cookies: {}, headers: {}, method: 'GET', params: {}, path: '/greeting/', query: {}, raw: {}, url: '/greeting/' }, infoResponse as never);
 
   if (JSON.stringify(healthResponse.body) !== JSON.stringify({ status: 'ok' })) {
     throw new Error('Expected /health to return status ok.');
@@ -1725,12 +1770,12 @@ Deno.test('AppModule dispatches the generated Deno starter routes', async () =>
   }
 
   if (typeof infoResponse.body !== 'object' || infoResponse.body === null) {
-    throw new Error('Expected /health-info/ to return an object body.');
+    throw new Error('Expected /greeting/ to return an object body.');
   }
 
-  const infoBody = infoResponse.body as { ok?: unknown; service?: unknown };
-  if (infoBody.ok !== true || typeof infoBody.service !== 'string') {
-    throw new Error('Expected /health-info/ to return the generated service payload.');
+  const infoBody = infoResponse.body as { framework?: unknown; message?: unknown; project?: unknown };
+  if (infoBody.message !== 'Hello from fluo' || infoBody.framework !== 'fluo' || typeof infoBody.project !== 'string') {
+    throw new Error('Expected /greeting/ to return the generated service payload.');
   }
 
   await app.close();
@@ -1816,7 +1861,7 @@ function emitSharedScaffoldFiles(options, bootstrapPlan, releaseVersion, package
   }];
   if (bootstrapPlan.profile.id !== 'application-deno-deno-http') {
     sharedFiles.push({
-      content: createProjectTsconfig(),
+      content: createProjectTsconfig(bootstrapPlan),
       path: 'tsconfig.json'
     }, {
       content: createProjectTsconfigBuild(),
@@ -1856,20 +1901,20 @@ function emitApplicationScaffoldFiles(options) {
     content: createMainFile(options),
     path: entrypointPath
   }, {
-    content: createHealthResponseDtoFile(),
-    path: 'src/health/health.response.dto.ts'
+    content: createGreetingResponseDtoFile(),
+    path: 'src/greeting/greeting.response.dto.ts'
   }, {
-    content: createHealthRepoFile(options.projectName, importSuffix),
-    path: 'src/health/health.repo.ts'
+    content: createGreetingRepoFile(options.projectName, importSuffix),
+    path: 'src/greeting/greeting.repo.ts'
   }, {
-    content: createHealthServiceFile(importSuffix),
-    path: 'src/health/health.service.ts'
+    content: createGreetingServiceFile(importSuffix),
+    path: 'src/greeting/greeting.service.ts'
   }, {
-    content: createHealthControllerFile(importSuffix),
-    path: 'src/health/health.controller.ts'
+    content: createGreetingControllerFile(importSuffix),
+    path: 'src/greeting/greeting.controller.ts'
   }, {
-    content: createHealthModuleFile(importSuffix),
-    path: 'src/health/health.module.ts'
+    content: createGreetingModuleFile(importSuffix),
+    path: 'src/greeting/greeting.module.ts'
   }];
   if (options.runtime === 'deno') {
     files.push({
@@ -1879,14 +1924,14 @@ function emitApplicationScaffoldFiles(options) {
     return files;
   }
   files.push({
-    content: createHealthRepoTestFile(),
-    path: 'src/health/health.repo.test.ts'
+    content: createGreetingRepoTestFile(),
+    path: 'src/greeting/greeting.repo.test.ts'
   }, {
-    content: createHealthServiceTestFile(),
-    path: 'src/health/health.service.test.ts'
+    content: createGreetingServiceTestFile(),
+    path: 'src/greeting/greeting.service.test.ts'
   }, {
-    content: createHealthControllerTestFile(),
-    path: 'src/health/health.controller.test.ts'
+    content: createGreetingControllerTestFile(),
+    path: 'src/greeting/greeting.controller.test.ts'
   }, {
     content: createAppTestFile(importSuffix),
     path: 'src/app.test.ts'
@@ -1942,29 +1987,29 @@ function emitScaffoldFilesForRecipe(options, recipeId) {
       content: createMixedMainFile(),
       path: 'src/main.ts'
     }, {
-      content: createHealthResponseDtoFile(),
-      path: 'src/health/health.response.dto.ts'
+      content: createGreetingResponseDtoFile(),
+      path: 'src/greeting/greeting.response.dto.ts'
     }, {
-      content: createHealthRepoFile(options.projectName),
-      path: 'src/health/health.repo.ts'
+      content: createGreetingRepoFile(options.projectName),
+      path: 'src/greeting/greeting.repo.ts'
     }, {
-      content: createHealthRepoTestFile(),
-      path: 'src/health/health.repo.test.ts'
+      content: createGreetingRepoTestFile(),
+      path: 'src/greeting/greeting.repo.test.ts'
     }, {
-      content: createHealthServiceFile(),
-      path: 'src/health/health.service.ts'
+      content: createGreetingServiceFile(),
+      path: 'src/greeting/greeting.service.ts'
     }, {
-      content: createHealthServiceTestFile(),
-      path: 'src/health/health.service.test.ts'
+      content: createGreetingServiceTestFile(),
+      path: 'src/greeting/greeting.service.test.ts'
     }, {
-      content: createHealthControllerFile(),
-      path: 'src/health/health.controller.ts'
+      content: createGreetingControllerFile(),
+      path: 'src/greeting/greeting.controller.ts'
     }, {
-      content: createHealthControllerTestFile(),
-      path: 'src/health/health.controller.test.ts'
+      content: createGreetingControllerTestFile(),
+      path: 'src/greeting/greeting.controller.test.ts'
     }, {
-      content: createHealthModuleFile(),
-      path: 'src/health/health.module.ts'
+      content: createGreetingModuleFile(),
+      path: 'src/greeting/greeting.module.ts'
     }, {
       content: createMathHandlerFile({
         transport: 'tcp'