@dunx/create-app 2.3.1 → 2.5.0

package/dist/{chunk-yzz4z6jv.js → chunk-nn9ekg83.js}

@@ -82,6 +82,37 @@ var CONFIG_GROUPS = Object.freeze({
     field: "readonly authorization: { readonly enabled: boolean };",
     map: "authorization: { enabled: true },",
     env: []
+  },
+  throttle: {
+    schema: [
+      "/** The app-wide limit. Generous, so a per-route `@Throttle` is the interesting half. */",
+      "THROTTLE_LIMIT: z.coerce.number().int().min(1).default(1000),",
+      "THROTTLE_WINDOW_SECONDS: z.coerce.number().int().min(1).default(60),"
+    ],
+    field: "readonly throttle: { readonly limit: number; readonly windowSeconds: number };",
+    map: "throttle: { limit: value.THROTTLE_LIMIT, windowSeconds: value.THROTTLE_WINDOW_SECONDS },",
+    env: [
+      { name: "THROTTLE_LIMIT", value: "1000" },
+      { name: "THROTTLE_WINDOW_SECONDS", value: "60" }
+    ]
+  },
+  schedule: {
+    schema: [
+      "/** A `@Cron` that names no zone of its own runs in this one. */",
+      "SCHEDULE_TZ: z.string().default('UTC'),"
+    ],
+    field: "readonly schedule: { readonly tz: string };",
+    map: "schedule: { tz: value.SCHEDULE_TZ },",
+    env: [{ name: "SCHEDULE_TZ", value: "UTC" }]
+  },
+  upstream: {
+    schema: [
+      "/** Per-call budget for the outbound client. */",
+      "UPSTREAM_TIMEOUT_MS: z.coerce.number().int().min(1).default(5000),"
+    ],
+    field: "readonly upstream: { readonly timeoutMs: number };",
+    map: "upstream: { timeoutMs: value.UPSTREAM_TIMEOUT_MS },",
+    env: [{ name: "UPSTREAM_TIMEOUT_MS", value: "5000" }]
   }
 });
 var BASE_CONFIG = ["appName", "port", "log"];
@@ -101,13 +132,13 @@ var FEATURES = [
     summary: "OpenAPI 3.1 from the routes own schemas, plus the Swagger UI page.",
     requires: [],
     module: { klass: "DocsModule", from: "./docs/docs.module.js" },
-    dependencies: ["@dunx/openapi", "swagger-ui-dist", "zod"],
+    dependencies: ["@dunx/openapi", "zod"],
     config: []
   },
   {
     name: "http",
     source: "http",
-    summary: "CORS, a request-logging middleware and error mapping.",
+    summary: "CORS, a middleware of your own on the response, and error mapping.",
     requires: [],
     module: { klass: "HttpModule", from: "./http/http.module.js" },
     dependencies: [],
@@ -200,11 +231,51 @@ var FEATURES = [
   {
     name: "health",
     source: "health",
-    summary: "One endpoint reporting which parts are live and which degraded.",
+    summary: "`HealthModule`'s liveness and readiness probes, wired to this app's own indicators.",
     requires: ["cache", "database", "files"],
-    module: { klass: "HealthModule", from: "./health/health.module.js" },
+    module: { klass: "ProbesModule", from: "./health/health.module.js" },
     dependencies: ["@dunx/infra"],
     config: ["appName"]
+  },
+  {
+    name: "throttle",
+    source: "throttle",
+    summary: "A fixed-window rate limit, with the counter in Redis and per-route overrides.",
+    requires: ["cache"],
+    module: { klass: "LimitsModule", from: "./throttle/throttle.module.js" },
+    dependencies: ["@dunx/infra"],
+    config: ["appName", "throttle"],
+    service: "Redis or Valkey"
+  },
+  {
+    name: "schedule",
+    source: "schedule",
+    summary: "@Cron, @Interval and @OnceOnBoot on Bun.cron, armed at boot and triggerable.",
+    requires: [],
+    module: {
+      klass: "MaintenanceModule",
+      from: "./schedule/schedule.module.js"
+    },
+    dependencies: ["@dunx/infra"],
+    config: ["schedule"]
+  },
+  {
+    name: "assets",
+    source: "assets",
+    summary: "A static directory on Bun.file, with a short max-age and an immutable rule.",
+    requires: [],
+    module: { klass: "AssetsModule", from: "./assets/assets.module.js" },
+    dependencies: [],
+    config: []
+  },
+  {
+    name: "client",
+    source: "upstream",
+    summary: "The outbound half of @dunx/http: retry, backoff and a typed FetchError.",
+    requires: [],
+    module: { klass: "UpstreamModule", from: "./upstream/upstream.module.js" },
+    dependencies: [],
+    config: ["appName", "upstream"]
   }
 ];
 var featureNames = FEATURES.map((feature) => feature.name);
@@ -289,16 +360,15 @@ var manifest = (features) => {
     dependencies,
     devDependencies: {
       "@dunx/testing": "__DUNX_VERSION__",
-      "@types/bun": ">=1.3.0",
+      "@types/bun": ">=1.4.0",
       typescript: "^5.7.0"
     },
-    engines: { bun: ">=1.3.0" }
+    engines: { bun: ">=1.4.0" }
   }, null, 2)}
 `;
 };
 var THIRD_PARTY = Object.freeze({
   zod: "^4.4.3",
-  "swagger-ui-dist": "^5.32.14",
   "drizzle-orm": "^0.45.2",
   "better-auth": "^1.6.25",
   bullmq: "^6.0.5",
@@ -307,7 +377,9 @@ var THIRD_PARTY = Object.freeze({
 var versionOf = (dep) => THIRD_PARTY[dep] ?? "latest";
 var appModule = (name, features) => {
   const needsLogger = true;
+  const documentsAuth = has(features, "openapi") && has(features, "auth");
   const imports = [
+    ...documentsAuth ? ["import { Auth } from '@dunx/auth';"] : [],
     "import { ConfigModule, Module } from '@dunx/core';",
     ...needsLogger ? ["import { LoggerModule } from '@dunx/infra/logger';"] : [],
     "import { AppConfigService, validate } from './config.js';",
@@ -341,7 +413,10 @@ var appModule = (name, features) => {
   imports: [
 ${moduleImports.map((line) => `    ${line}`).join(`
 `)}
-  ],
+  ],${documentsAuth ? `
+  // Better Auth serves its own routes, so the document is the only place they
+  // appear - and \`betterAuthDocument\` needs the instance.
+  exports: [Auth],` : ""}
 })
 export class AppModule {}
 `;
@@ -406,17 +481,37 @@ var bootstrap = (name, features) => {
   const openapi = has(features, "openapi");
   const websockets = has(features, "websockets");
   const http = has(features, "http");
+  const documentsAuth = openapi && has(features, "auth");
+  const assets = has(features, "assets");
+  const throttle = has(features, "throttle");
   const imports = [
-    `import { HttpFactory${websockets ? ", RedisRelay" : ""}, type HttpApp } from '@dunx/http';`,
+    ...documentsAuth ? ["import { Auth, betterAuthDocument } from '@dunx/auth';"] : [],
+    `import { ${[
+      "HttpFactory",
+      ...websockets ? ["RedisRelay"] : [],
+      ...assets ? ["StaticFiles"] : [],
+      ...throttle ? ["ThrottleGuard"] : [],
+      "type HttpApp"
+    ].join(", ")} } from '@dunx/http';`,
     ...openapi ? ["import { OpenApiModule } from '@dunx/openapi';"] : [],
     "import { AppModule } from './app.module.js';",
     `import { ${[
       ...http ? ["AppConfigService"] : [],
       ...websockets ? ["RELAY_CHANNEL"] : []
     ].join(", ")} } from './config.js';`,
-    ...http ? ["import { RequestLoggerMiddleware } from './http/request-log.js';"] : []
+    ...http ? ["import { RequestTrailMiddleware } from './http/request-trail.js';"] : []
   ].filter((line) => !line.includes("{  }"));
-  const root = openapi ? `OpenApiModule.forRoot({
+  const root = documentsAuth ? `OpenApiModule.forRootAsync({
+      root: AppModule,
+      inject: [Auth] as const,
+      useFactory: (auth: Auth) => ({
+        title: '__DUNX_APP_NAME__',
+        version: '0.1.0',
+        contribute: [
+          betterAuthDocument(auth, { basePath: '/api/auth', tag: 'Auth' }),
+        ],
+      }),
+    })` : openapi ? `OpenApiModule.forRoot({
       title: '__DUNX_APP_NAME__',
       version: '0.1.0',
       root: AppModule,
@@ -431,15 +526,17 @@ var bootstrap = (name, features) => {
   ] : [];
   const shaping = [
     "app.setGlobalPrefix('api');",
+    ...assets ? ["app.use(StaticFiles);"] : [],
     ...http ? [
-      "app.use(RequestLoggerMiddleware);",
+      "app.use(RequestTrailMiddleware);",
       "app.set('trust proxy', true);",
       "app.enableCors({",
       "  origin: app.get(AppConfigService).get('corsOrigin'),",
       "  credentials: true,",
       "  maxAge: 600,",
       "});"
-    ] : []
+    ] : [],
+    ...throttle ? ["app.use(ThrottleGuard);"] : []
   ];
   return `${HEADER(name)}${imports.join(`
 `)}
@@ -694,6 +791,3 @@ var scaffold = async (options) => {
 };
 
 export { FEATURES, featureNames, impliedBy, TEMPLATES, VERSION_PLACEHOLDER, ScaffoldError, scaffold };
-
-//# debugId=BC087157153A09C764756E2164756E21
-//# sourceMappingURL=chunk-yzz4z6jv.js.map

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   featureNames,
   impliedBy,
   scaffold
-} from "./chunk-yzz4z6jv.js";
+} from "./chunk-nn9ekg83.js";
 
 // src/cli.ts
 import { parseArgs } from "util";
@@ -129,6 +129,3 @@ try {
     fail(error.message);
   throw error;
 }
-
-//# debugId=01853E264154F96764756E2164756E21
-//# sourceMappingURL=cli.js.map

package/dist/index.js

@@ -4,13 +4,10 @@ import {
   TEMPLATES,
   VERSION_PLACEHOLDER,
   scaffold
-} from "./chunk-yzz4z6jv.js";
+} from "./chunk-nn9ekg83.js";
 export {
   ScaffoldError,
   TEMPLATES,
   VERSION_PLACEHOLDER,
   scaffold
 };
-
-//# debugId=2DFAD801C180F0A064756E2164756E21
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/create-app",
-  "version": "2.3.1",
+  "version": "2.5.0",
   "description": "Scaffold a new dunx application - bunx @dunx/create-app my-api",
   "keywords": [
     "bun",
@@ -58,6 +58,6 @@
     }
   },
   "engines": {
-    "bun": ">=1.3.0"
+    "bun": ">=1.4.0"
   }
 }

package/templates/features/assets/assets.demo.ts

@@ -0,0 +1,41 @@
+import { Logger } from '@dunx/core';
+
+/**
+ * The two cache policies, and the traversal refusal.
+ *
+ * There is no `index.html` fallback and no SPA rewrite here, because `StaticFiles`
+ * ships neither: building one in would mean the middleware deciding what a 404
+ * means for paths it does not own.
+ */
+export class AssetsDemo {
+  constructor(private readonly logger: Logger) {}
+
+  async demonstrate(url: string): Promise<void> {
+    for (const path of ['assets/site.css', 'assets/app.a1b2c3d4.js']) {
+      const response = await fetch(new URL(path, url));
+      this.logger.info(
+        `GET /${path} -> ${response.status} ` +
+          `${response.headers.get('content-type')}, ` +
+          `cache-control: ${response.headers.get('cache-control')}`,
+      );
+      await response.arrayBuffer();
+    }
+    this.logger.info(
+      'the hashed name is immutable, the plain one is max-age=60 - a content ' +
+        'hash is the only honest reason to promise forever',
+    );
+
+    // Resolved against the root at construction, and checked on every request.
+    const escaped = await fetch(new URL('assets/../../package.json', url));
+    this.logger.info(
+      `GET /assets/../../package.json -> ${escaped.status} (never leaves the root)`,
+    );
+
+    // Anything outside the mount falls straight through, so the app's own routes
+    // and its 404 behave exactly as they did before this was registered.
+    const through = await fetch(new URL('api/notes', url));
+    this.logger.info(
+      `GET /api/notes -> ${through.status} (outside /assets, untouched)`,
+    );
+  }
+}

package/templates/features/assets/assets.module.ts

@@ -0,0 +1,37 @@
+import { Module } from '@dunx/core';
+import { StaticModule } from '@dunx/http';
+import { AssetsDemo } from './assets.demo.js';
+
+/** A content hash, so a change produces a different URL. */
+const HASHED = /\.[0-9a-f]{8}\.(js|css)$/;
+
+/**
+ * The `public/` directory next to this file, served at `/assets`.
+ *
+ * `StaticModule` binds `StaticFiles`; the **app** registers it, in `bootstrap.ts`.
+ * Position in the chain is the app's decision and no default can make it: assets
+ * usually want to be outside an auth guard and inside request logging.
+ *
+ * The mount is outside `setGlobalPrefix('api')`, because middleware is not a
+ * discovered route and never gets the prefix.
+ */
+@Module({
+  imports: [
+    StaticModule.forRoot({
+      // Inside the feature folder rather than at the app root, so the folder is
+      // self-contained: `@dunx/create-app` vendors this directory wholesale, and
+      // an asset kept outside it would need machinery to travel with it.
+      root: new URL('./public', import.meta.url).pathname,
+      path: '/assets',
+      // Short, because a long max-age on a name that can change is a promise the
+      // server cannot keep.
+      maxAge: 60,
+      // Only honest for a content-addressed name. Guessing wrong here is a stale
+      // asset nobody can flush, which is why the default claims nothing.
+      immutable: (pathname) => HASHED.test(pathname),
+    }),
+  ],
+  providers: [AssetsDemo],
+  exports: [AssetsDemo],
+})
+export class AssetsModule {}

package/templates/features/assets/public/app.a1b2c3d4.js

@@ -0,0 +1 @@
+globalThis.dunxExample = 'content-addressed, so cacheable forever';

package/templates/features/assets/public/index.html

@@ -0,0 +1,9 @@
+<main>
+  <h1>dunx static assets</h1>
+  <p>
+    Served by <code>StaticFiles</code> from <code>examples/full/public</code>,
+    on <code>Bun.file</code> - which streams, sets the content type, and answers
+    a Range request with sendfile(2).
+  </p>
+  <script src="/assets/app.a1b2c3d4.js"></script>
+</main>

package/templates/features/assets/public/site.css

@@ -0,0 +1,3 @@
+body {
+  font-family: system-ui;
+}

package/templates/features/auth/auth.module.ts

@@ -1,8 +1,8 @@
-import { AuthModule, bunPassword } from '@dunx/auth';
+import { Auth, AuthModule, bunPassword } from '@dunx/auth';
 import { drizzleDatabase } from '@dunx/auth/drizzle';
 import { Module } from '@dunx/core';
 import { DbConnection } from '@dunx/infra/db';
-import { admin, bearer } from 'better-auth/plugins';
+import { admin, bearer, openAPI } from 'better-auth/plugins';
 import { AppConfigService } from '../config.js';
 import { DatabaseModule } from '../database/database.module.js';
 import { AuthDemo } from './auth.demo.js';
@@ -46,7 +46,15 @@ import { ProfileController } from './profile.controller.js';
           // `admin` puts `role` on the user, which `@Roles()` then reads. `bearer`
           // lets a non-browser client send `Authorization: Bearer <token>` instead of
           // a cookie - which is what the tour does.
-          plugins: [admin(), bearer()],
+          // `openAPI()` is what makes `generateOpenAPISchema` exist, and
+          // `betterAuthDocument` in bootstrap.ts is what puts its paths in the app's
+          // document. `disableDefaultReference` because dunx already serves an
+          // explorer at /api/docs and two reference pages is one too many.
+          plugins: [
+            admin(),
+            bearer(),
+            openAPI({ disableDefaultReference: true }),
+          ],
         }),
         inject: [AppConfigService, DbConnection] as const,
       },
@@ -59,6 +67,9 @@ import { ProfileController } from './profile.controller.js';
   providers: [AuthTables, Audit, AuthDemo],
   // `AuthTables` creates them on the app's own handle, so this module needs the
   // drizzle handle as well as the connection the factory above used.
-  exports: [Audit, AuthDemo],
+  //
+  // `Auth` comes back out because `OpenApiModule` wraps the root and can only
+  // inject what the root exports - see bootstrap.ts.
+  exports: [Audit, AuthDemo, Auth],
 })
 export class AccountsModule {}

package/templates/features/cache/cache.controller.ts

@@ -12,14 +12,17 @@ import { Sessions } from './sessions.service.js';
 
 const SessionKey = z
   .object({ id: z.string().min(1).max(80) })
-  .meta({ id: 'SessionKey', title: 'A session id' });
+  .meta({ id: 'SessionKey', description: 'A session id' });
 
 const StoreSession = z
   .object({
     data: z.record(z.string(), z.unknown()),
     ttl: z.coerce.number().int().min(1).max(3600).default(60),
   })
-  .meta({ id: 'StoreSession', title: 'Session payload and its lifetime' });
+  .meta({
+    id: 'StoreSession',
+    description: 'Session payload and its lifetime',
+  });
 
 const oneSession = { params: SessionKey } as const;
 const putSession = { params: SessionKey, body: StoreSession } as const;

package/templates/features/database/ledger.controller.ts

@@ -14,14 +14,14 @@ import type { Entry } from './schema.js';
 
 const EntryIndex = z
   .object({ id: z.coerce.number().int().min(1) })
-  .meta({ id: 'EntryIndex', title: 'A ledger entry id in the path' });
+  .meta({ id: 'EntryIndex', description: 'A ledger entry id in the path' });
 
 const CreateEntry = z
   .object({
     memo: z.string().min(1).max(80),
     amount: z.number().int(),
   })
-  .meta({ id: 'CreateEntry', title: 'A single ledger movement' });
+  .meta({ id: 'CreateEntry', description: 'A single ledger movement' });
 
 /** Both legs succeed or neither does - the rollback is the point of the route. */
 const Transfer = z
@@ -36,7 +36,7 @@ const Transfer = z
      */
     fail: z.boolean().default(false),
   })
-  .meta({ id: 'Transfer', title: 'Move an amount between two memos' });
+  .meta({ id: 'Transfer', description: 'Move an amount between two memos' });
 
 const listEntries = {
   query: z.object({
@@ -68,7 +68,10 @@ const pageQuery = z
       .optional()
       .describe('Opaque cursor from meta.nextCursor. Omit for the first page.'),
   })
-  .meta({ id: 'LedgerPageQuery', title: 'Keyset pagination over the ledger' });
+  .meta({
+    id: 'LedgerPageQuery',
+    description: 'Keyset pagination over the ledger',
+  });
 
 const pagedEntries = { query: pageQuery } as const;
 const oneEntry = { params: EntryIndex } as const;

package/templates/features/guards/reports.controller.ts

@@ -12,12 +12,21 @@ import { z } from 'zod';
 import { AuthGuard, RolesGuard } from './auth.guard.js';
 import { ReportsService } from './reports.service.js';
 
+const CreateReport = z
+  .object({ title: z.string().min(1) })
+  .meta({ id: 'CreateReport', description: 'A report to file' });
+
+const RenameReport = z.object({ title: z.string().min(1) }).meta({
+  id: 'RenameReport',
+  description: 'A new title for an existing report',
+});
+
 const renameReport = {
   params: z.object({ id: z.coerce.number().int() }),
-  body: z.object({ title: z.string().min(1) }),
+  body: RenameReport,
 } as const;
 
-const createReport = { body: z.object({ title: z.string().min(1) }) } as const;
+const createReport = { body: CreateReport } as const;
 
 // `@UseGuards(AuthGuard)` at class scope rather than as global middleware: every
 // other route in this app is meant to be reachable without credentials, and a

package/templates/features/health/health.demo.ts

@@ -0,0 +1,72 @@
+import { Logger } from '@dunx/core';
+import { Readiness, type HealthReport } from '@dunx/http';
+
+/**
+ * The two probes an orchestrator reads, and the one thing about them that is worth
+ * demonstrating rather than describing: `Readiness.hold()` takes the pod out of
+ * rotation while liveness keeps passing, so a migration sheds traffic without
+ * inviting a restart.
+ */
+export class HealthDemo {
+  constructor(
+    private readonly logger: Logger,
+    private readonly readiness: Readiness,
+  ) {}
+
+  async demonstrate(url: string): Promise<void> {
+    const get = async (
+      path: string,
+    ): Promise<{ status: number; body: HealthReport }> => {
+      const response = await fetch(new URL(`api/health/${path}`, url));
+      return {
+        status: response.status,
+        body: (await response.json()) as HealthReport,
+      };
+    };
+
+    const live = await get('live');
+    this.logger.info(
+      `GET /api/health/live -> ${live.status} ${live.body.status}, ` +
+        `${this.describe(live.body)}`,
+    );
+
+    const ready = await get('ready');
+    this.logger.info(
+      `GET /api/health/ready -> ${ready.status} ${ready.body.status}, ` +
+        `${this.describe(ready.body)}`,
+    );
+
+    // A non-critical check that is down does not shed traffic, which is the whole
+    // reason `critical` exists. With no Redis running, this is that case observed.
+    const soft = ready.body.checks.filter(
+      (check) => !check.critical && check.state !== 'up',
+    );
+    this.logger.info(
+      soft.length === 0
+        ? 'every check up, so critical and non-critical read the same today'
+        : `non-critical and down: ${soft.map((c) => c.name).join(', ')} - ` +
+            `readiness is still ${ready.body.status}`,
+    );
+
+    // Taking the pod out by hand, the way a migration would.
+    this.readiness.hold('migrating');
+    const held = await get('ready');
+    const heldLive = await get('live');
+    this.logger.info(
+      `readiness.hold("migrating") -> ready ${held.status} ` +
+        `${held.body.checks[0]?.detail ?? ''}, live still ${heldLive.status}`,
+    );
+
+    this.readiness.release();
+    this.logger.info(
+      `readiness.release() -> ready ${(await get('ready')).status}`,
+    );
+  }
+
+  private describe(report: HealthReport): string {
+    const checks = report.checks
+      .map((check) => `${check.name}=${check.state}`)
+      .join(' ');
+    return `${report.uptimeMs} ms up, ${checks || 'no checks'}`;
+  }
+}

package/templates/features/health/health.module.ts

@@ -1,14 +1,75 @@
-import { Module } from '@dunx/core';
+import { Module, provide } from '@dunx/core';
+import { HealthModule } from '@dunx/http';
+import { DbConnection } from '@dunx/infra/db';
+import { RedisConnection } from '@dunx/infra/redis';
 import { CacheModule } from '../cache/cache.module.js';
 import { DatabaseModule } from '../database/database.module.js';
-import { StorageModule } from '../storage/storage.module.js';
-import { HealthController } from './health.controller.js';
+import { Ledger } from '../database/ledger.service.js';
+import { WorkspaceModule } from '../storage/storage.module.js';
+import { Workspace } from '../storage/workspace.js';
+import { HealthDemo } from './health.demo.js';
+import { AppIndicators } from './indicators.js';
 
-// A health check is the module that imports the most: it reports on every area, so it
-// needs each one's public surface. That is the boundary doing its job - the imports
-// list is now an accurate statement of what this feature touches.
+/**
+ * The indicators, in a module of their own for the reason `WorkspaceModule` is:
+ * `HealthModule.forRootAsync` registers its provider in its own scope, so a factory
+ * injecting `AppIndicators` has to name the module it comes from - and pointing that
+ * back at `ProbesModule` would be a cycle.
+ *
+ * A health check is still the feature that imports the most, so this list is an
+ * accurate statement of what it touches.
+ */
 @Module({
-  imports: [DatabaseModule, CacheModule, StorageModule],
-  controllers: [HealthController],
+  imports: [DatabaseModule, CacheModule, WorkspaceModule],
+  providers: [
+    provide(AppIndicators, {
+      // Async because the upload root is: `Workspace.create()` is idempotent, so
+      // this is the directory `FilesModule` already made rather than a second one.
+      useFactory: async (
+        db: DbConnection,
+        redis: RedisConnection,
+        ledger: Ledger,
+        workspace: Workspace,
+      ) =>
+        new AppIndicators({
+          db,
+          redis,
+          ledger,
+          uploadRoot: await workspace.create(),
+        }),
+      inject: [DbConnection, RedisConnection, Ledger, Workspace] as const,
+    }),
+  ],
+  exports: [AppIndicators],
 })
-export class HealthModule {}
+export class IndicatorsModule {}
+
+/**
+ * `HealthModule` from `@dunx/http`, which mounts `/api/health/live` and
+ * `/api/health/ready`. Both are `@Public()` and hidden from the OpenAPI document:
+ * a probe carries no credentials and is not an API a consumer calls.
+ *
+ * There is no indicator for `@dunx/infra/files` or `@dunx/infra/images`. Both are
+ * in-process, so "it booted" is already answered by the port answering at all, and
+ * a check that cannot fail tells an operator nothing.
+ */
+@Module({
+  imports: [
+    IndicatorsModule,
+    HealthModule.forRootAsync({
+      imports: [IndicatorsModule],
+      useFactory: (indicators: AppIndicators) => ({
+        readiness: indicators.readiness,
+        liveness: indicators.liveness,
+        // A real deployment sets a few probe intervals here, so a load balancer
+        // sees readiness fail before the socket closes. Short enough that
+        // `bun run tour` and the suites are not waiting on it.
+        drainDelayMs: 250,
+      }),
+      inject: [AppIndicators] as const,
+    }),
+  ],
+  providers: [HealthDemo],
+  exports: [AppIndicators, HealthDemo],
+})
+export class ProbesModule {}