@taicode/common-server 4.0.0-beta.1 → 4.0.0-beta.3

package/output/app/error-contract.test.js

@@ -97,16 +97,15 @@ describe('错误契约', () => {
         expect(body.message).toContain('GET /missing');
         await app.close();
     });
-    it('资源包里的 `classifyError` 被用作数据层错误分类（→500）', async () => {
+    it('资源注册的 `ctx.registerClassifyError` 分类器生效（→500，错误码 = 分类器返回的 SystemError.type）', async () => {
         const server = defineServer({
             app: { service: 'error-contract-database', title: 'Error Contract Database', version: '1.0.0' },
-            resources: () => ({
-                database: {
-                    classifyError: (error) => error instanceof Error && error.message === 'pg down'
-                        ? new SystemError('DATABASE_ERROR', { operation: 'query' }, 'pg down')
-                        : null,
-                },
-            }),
+            resources: (ctx) => {
+                ctx.registerClassifyError((error) => error instanceof Error && error.message === 'pg down'
+                    ? new SystemError('DATABASE_ERROR', { operation: 'query' }, 'pg down')
+                    : null);
+                return {};
+            },
             config: () => ({}),
             services: () => ({}),
             middlewares: () => [],
@@ -122,4 +121,107 @@ describe('错误契约', () => {
         expect(response.json()).toEqual({ status: 'DATABASE_ERROR', message: 'pg down', data: null });
         await app.close();
     });
+    it('跨资源注册：每个资源各注册自己的分类器，各自认领域内错误（顺序短路），都不认领则兜底', async () => {
+        const calls = [];
+        const server = defineServer({
+            app: { service: 'error-contract-cross-resource', title: 'Error Contract Cross Resource', version: '1.0.0' },
+            resources: (ctx) => {
+                // prisma 资源：只认领自己域内的 Prisma 错误（认领不了返回 null）
+                ctx.registerClassifyError((error) => {
+                    calls.push('prisma');
+                    return error instanceof Error && error.name === 'PrismaError'
+                        ? new SystemError('DATABASE_ERROR', { operation: 'query' }, '数据库错误')
+                        : null;
+                });
+                // cache 资源：只认领自己域内的缓存错误
+                ctx.registerClassifyError((error) => {
+                    calls.push('cache');
+                    return error instanceof Error && error.name === 'CacheError'
+                        ? new SystemError('CACHE_ERROR', undefined, '缓存错误')
+                        : null;
+                });
+                return { prisma: {}, cache: {} };
+            },
+            config: () => ({}),
+            services: () => ({}),
+            middlewares: () => [],
+            routers: (ctx) => {
+                ctx.app.get('/prisma-error', () => {
+                    throw Object.assign(new Error('db down'), { name: 'PrismaError' });
+                });
+                ctx.app.get('/cache-error', () => {
+                    throw Object.assign(new Error('cache down'), { name: 'CacheError' });
+                });
+                ctx.app.get('/unclaimed-error', () => {
+                    throw new Error('someone else error');
+                });
+            },
+        });
+        const app = await startServer(server, { listen: false });
+        // ① prisma 域：prisma 分类器认领，错误码正确；首个命中即短路（不再问 cache）
+        calls.length = 0;
+        const prisma = await app.inject({ method: 'GET', url: '/prisma-error' });
+        expect(prisma.statusCode).toBe(500);
+        expect(prisma.json()).toEqual({ status: 'DATABASE_ERROR', message: '数据库错误', data: null });
+        expect(calls).toEqual(['prisma']);
+        // ② cache 域：prisma 返回 null → 交给 cache 认领，错误码正确
+        calls.length = 0;
+        const cache = await app.inject({ method: 'GET', url: '/cache-error' });
+        expect(cache.statusCode).toBe(500);
+        expect(cache.json()).toEqual({ status: 'CACHE_ERROR', message: '缓存错误', data: null });
+        expect(calls).toEqual(['prisma', 'cache']);
+        // ③ 都不认领 → 落 `UNKNOWN_ERROR` 兜底
+        calls.length = 0;
+        const unclaimed = await app.inject({ method: 'GET', url: '/unclaimed-error' });
+        expect(unclaimed.statusCode).toBe(500);
+        expect(unclaimed.json()).toEqual({ status: 'UNKNOWN_ERROR', message: 'someone else error', data: null });
+        expect(calls).toEqual(['prisma', 'cache']);
+        await app.close();
+    });
+    it('一个资源都不注册分类器 → 资源错误分支不生效，落 `UNKNOWN_ERROR` 兜底', async () => {
+        const server = defineServer({
+            app: { service: 'error-contract-none', title: 'Error Contract None', version: '1.0.0' },
+            resources: () => ({}),
+            config: () => ({}),
+            services: () => ({}),
+            middlewares: () => [],
+            routers: (ctx) => {
+                ctx.app.get('/boom', () => {
+                    throw new Error('boom');
+                });
+            },
+        });
+        const app = await startServer(server, { listen: false });
+        const response = await app.inject({ method: 'GET', url: '/boom' });
+        expect(response.statusCode).toBe(500);
+        expect(response.json()).toEqual({ status: 'UNKNOWN_ERROR', message: 'boom', data: null });
+        await app.close();
+    });
+    it('注册的分类器不影响既有分支：`UserError` 仍走 400（分类器只在资源错误分支求值）', async () => {
+        let classified = 0;
+        const server = defineServer({
+            app: { service: 'error-contract-user', title: 'Error Contract User', version: '1.0.0' },
+            resources: (ctx) => {
+                ctx.registerClassifyError((error) => {
+                    classified += 1;
+                    return error instanceof Error ? new SystemError('SHOULD_NOT_HAPPEN', undefined, 'x') : null;
+                });
+                return {};
+            },
+            config: () => ({}),
+            services: () => ({}),
+            middlewares: () => [],
+            routers: (ctx) => {
+                ctx.app.get('/user-error-2', () => {
+                    throw new UserError('INVALID_TOKEN', undefined, 'token 无效');
+                });
+            },
+        });
+        const app = await startServer(server, { listen: false });
+        const response = await app.inject({ method: 'GET', url: '/user-error-2' });
+        expect(response.statusCode).toBe(400);
+        expect(response.json()).toEqual({ status: 'INVALID_TOKEN', message: 'token 无效', data: null });
+        expect(classified).toBe(0); // `UserError` 在分支①命中，分类器根本没被求值
+        await app.close();
+    });
 });

package/output/app/index.d.ts

@@ -8,7 +8,7 @@ export { createCorsMiddleware, createContextMiddleware, createAuthMiddleware, cr
 export { REQUEST_ID_HEADER } from './core/request-id.js';
 export { DOC_ROUTE_PREFIX, DOC_SPEC_ROUTE } from './core/openapi.js';
 export { extractPermissionOperations } from './permission-operations.js';
-export type { AppIdentity, AppInstance, LoggerLike, MaybePromise, RedisHandle, Live, ResourcesView, AssertNoDependencies, ServicesShape, ResourcesContext, ResourcesFactory, ConfigContext, ConfigFactory, ServiceUnit, ServiceContext, ServicesFactory, MiddlewareUnit, MiddlewareContext, MiddlewaresFactory, RouterContext, RoutersFactory, ServerConfig, Server, StartServerOptions, ShutdownContext, OpenApiDocument, } from './types.js';
+export type { AppIdentity, AppInstance, LoggerLike, MaybePromise, RedisHandle, Live, ResourcesView, AssertNoDependencies, ServicesShape, ErrorClassifier, ResourcesContext, ResourcesFactory, ConfigContext, ConfigFactory, ServiceUnit, ServiceContext, ServicesFactory, MiddlewareUnit, MiddlewareContext, MiddlewaresFactory, RouterContext, RoutersFactory, ServerConfig, Server, StartServerOptions, ShutdownContext, OpenApiDocument, } from './types.js';
 export type { CacheSetupParams } from './redis.js';
 export type { PermissionOperation } from './permission-operations.js';
 export type { CorsMiddlewareOptions, ContextMiddlewareOptions, AuthMiddlewareOptions, AuthSkip, AuthVerifyInput, AuthVerifyMetadata, AuthVerifyResult, AccountIntegrationConfig, RateLimitMiddlewareOptions } from './middleware/index.js';

package/output/app/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/app/index.ts"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,CAAA;AAG1B,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAGjG,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACvI,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGzC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGpD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAGtF,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAG3K,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAGpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAGxE,YAAY,EAEV,WAAW,EACX,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EAEX,IAAI,EACJ,aAAa,EACb,oBAAoB,EACpB,aAAa,EAEb,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,WAAW,EACX,cAAc,EACd,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,cAAc,EAEd,YAAY,EACZ,MAAM,EACN,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACrE,YAAY,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,QAAQ,EAAE,eAAe,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAA;AAC1O,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/app/index.ts"],"names":[],"mappings":"AAEA,OAAO,mBAAmB,CAAA;AAG1B,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAGjG,OAAO,EAAE,YAAY,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACvI,YAAY,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGzC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAGpD,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,+BAA+B,EAAE,MAAM,YAAY,CAAA;AAGtF,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AAG3K,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AAGpE,OAAO,EAAE,2BAA2B,EAAE,MAAM,4BAA4B,CAAA;AAGxE,YAAY,EAEV,WAAW,EACX,WAAW,EACX,UAAU,EACV,YAAY,EACZ,WAAW,EAEX,IAAI,EACJ,aAAa,EACb,oBAAoB,EACpB,aAAa,EAEb,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,WAAW,EACX,cAAc,EACd,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAClB,aAAa,EACb,cAAc,EAEd,YAAY,EACZ,MAAM,EACN,kBAAkB,EAClB,eAAe,EACf,eAAe,GAChB,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAClD,YAAY,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAA;AACrE,YAAY,EAAE,qBAAqB,EAAE,wBAAwB,EAAE,qBAAqB,EAAE,QAAQ,EAAE,eAAe,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAA;AAC1O,YAAY,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA"}

package/output/app/lifecycle-logging.test.js

@@ -1,12 +1,14 @@
 import { describe, expect, it, vi } from 'vitest';
+import { Disposer } from '@taicode/common-base';
 import { defineServer, startServer } from './entries.js';
-import { buildDisposeOrder, initServiceUnits, LIFECYCLE_PHASE_DISPOSE, LIFECYCLE_PHASE_INIT, MIDDLEWARES_LOG_STAGE, middlewareUnitName, SERVICES_STAGE, serviceUnitName, } from './lifecycle.js';
+import { buildDisposeOrder, disposeStage, initServiceUnits, LIFECYCLE_PHASE_DISPOSE, LIFECYCLE_PHASE_INIT, MIDDLEWARES_LOG_STAGE, middlewareUnitName, RESOURCES_STAGE, SERVICES_STAGE, serviceUnitName, } from './lifecycle.js';
 import { createRecordingLogger } from './test-support.js';
 /**
  * 逐单元日志。
  *
  * - **注册期**：每个中间件注册后打一条 `debug`，带 `{ service, unit, stage: 'middlewares' }`；
  * - **init / dispose**：逐单元 `debug`（开始 / 完成），失败 `error`；带 `{ service, unit, stage, phase }`；
+ * - **阶段 flush**：`disposeStage` 每阶段一条 `debug`（`unit` = 阶段名）；
  * - 中间件名字：`unit.name ?? '<service>:middleware[<index>]'`；services 用对象键。
  *
  * 分两层验证：
@@ -91,6 +93,19 @@ describe('逐单元日志：init / dispose', () => {
         expect(middlewareUnitName('svc', {}, 3)).toBe('svc:middleware[3]');
         expect(middlewareUnitName('svc', { name: 'named' }, 1)).toBe('named');
     });
+    it('阶段 flush：`unit` / `stage` = 阶段名，`phase` = dispose', async () => {
+        const log = createRecordingLogger();
+        const disposer = new Disposer();
+        await disposeStage({ service: 'svc', log, stage: RESOURCES_STAGE, disposer });
+        const fields = log.entries.map((entry) => entry.obj);
+        expect(fields.length).toBeGreaterThan(0);
+        for (const field of fields) {
+            expect(field.service).toBe('svc');
+            expect(field.unit).toBe(RESOURCES_STAGE);
+            expect(field.stage).toBe(RESOURCES_STAGE);
+            expect(field.phase).toBe(LIFECYCLE_PHASE_DISPOSE);
+        }
+    });
 });
 // ── 真路径：`startServer` 走完整装配，捕获框架 logger 写入 ────────
 const captured = vi.hoisted(() => ({ lines: [] }));
@@ -148,8 +163,13 @@ describe('startServer 真路径：注册 / init / dispose 逐单元日志', () =
         // init / dispose：services 逐单元 debug（带 `phase`）
         expect(matchRecords(records, { unit: 'alpha', stage: SERVICES_STAGE, phase: LIFECYCLE_PHASE_INIT }).length).toBeGreaterThan(0);
         expect(matchRecords(records, { unit: 'alpha', stage: SERVICES_STAGE, phase: LIFECYCLE_PHASE_DISPOSE }).length).toBeGreaterThan(0);
-        // 中间件**不参与生命周期**：没有 middlewares 阶段的 init / dispose 日志
+        // 中间件**没有逐单元生命周期**：没有 middlewares 阶段的 init 日志；dispose 只有阶段 flush
         expect(matchRecords(records, { stage: MIDDLEWARES_LOG_STAGE, phase: LIFECYCLE_PHASE_INIT })).toHaveLength(0);
-        expect(matchRecords(records, { stage: MIDDLEWARES_LOG_STAGE, phase: LIFECYCLE_PHASE_DISPOSE })).toHaveLength(0);
+        const middlewareDispose = matchRecords(records, {
+            stage: MIDDLEWARES_LOG_STAGE,
+            phase: LIFECYCLE_PHASE_DISPOSE,
+        });
+        expect(middlewareDispose.length).toBeGreaterThan(0);
+        expect(middlewareDispose.every((record) => record.unit === MIDDLEWARES_LOG_STAGE)).toBe(true);
     });
 });

package/output/app/lifecycle.d.ts

@@ -1,15 +1,27 @@
+import type { Disposer } from '@taicode/common-base';
 import type { LoggerLike } from './types.js';
 /**
  * 生命周期序（N1 §4 / N2 §2.5）。
  *
- * **只有 `services` 参与生命周期**：
+ * **每个阶段一个 `Disposer`**（`ctx.disposer`，所有槽位都有）：在创建某个东西的地方当场
+ * `ctx.disposer.add(() => 释放它)` —— 创建与释放同处一地。
+ *
+ * 关闭时按阶段**逆序 flush**：`routers → middlewares → services → config → resources`
+ * （后创建的先销毁；Prisma / Redis 这类资源最后才断）。
+ *
+ * **`services` 额外有逐单元生命周期**：
  * - 单元之间**不得相互依赖**（`services` 的 ctx 没有 `services` 字段，编译期禁止）；
- * - 顺序语义只有一条：按**对象声明序** `init`、**逆序** `dispose`；
- * - `middlewares` 按数组序注册，**不参与生命周期**（要常驻资源就放 `services`）；
- * - `resources` 只是惰性包装（构造不建连），框架不替它们做生命周期。
+ * - `init` 按**对象声明序**，`dispose` **逆序**；
+ * - services 阶段内部**先 flush `ctx.disposer`**（构造期注册的清理），再逐单元 `dispose`。
+ *
+ * `middlewares` 按数组序注册；它只有 `disposer`，没有逐单元生命周期。
  */
 export declare const SERVICES_STAGE = "services";
-/** `middlewares` 的**注册期日志**阶段标签（中间件不参与生命周期，只用于注册日志） */
+export declare const CONFIG_STAGE = "config";
+export declare const MIDDLEWARES_STAGE = "middlewares";
+export declare const ROUTERS_STAGE = "routers";
+export declare const RESOURCES_STAGE = "resources";
+/** `middlewares` 的**注册期日志**阶段标签（与生命周期阶段同名） */
 export declare const MIDDLEWARES_LOG_STAGE = "middlewares";
 /** 生命周期相位（逐单元日志字段 `phase`） */
 export declare const LIFECYCLE_PHASE_INIT = "init";
@@ -27,7 +39,7 @@ export interface LifecycleLogContext {
     /** 记录型 logger（`ctx.log`）；缺省 = 不打日志 */
     log?: LoggerLike;
 }
-/** 逐单元日志字段（全拼）：`unit` = 有效名字，`stage` = `services` */
+/** 逐单元日志字段（全拼）：`unit` = 有效名字（阶段 flush 时为阶段名），`stage` = 阶段名 */
 export interface LifecycleUnitLogFields {
     service: string;
     unit: string;
@@ -67,4 +79,18 @@ export declare function buildDisposeOrder(params: DisposeServiceUnitsParams): Ar
  * 此处仅保证单步不阻断后续。
  */
 export declare function disposeServices(params: DisposeServiceUnitsParams): Promise<void>;
+/** `disposeStage` 入参（参数签名内联对象类型已按 lint 规则外提） */
+export interface DisposeStageParams extends LifecycleLogContext {
+    /** 阶段名（`routers` / `middlewares` / `services` / `config` / `resources`） */
+    stage: string;
+    /** 该阶段的 `Disposer`（构造期注册的清理函数，**逆注册序**执行） */
+    disposer: Disposer;
+}
+/**
+ * 关闭步：flush 某个阶段的 `disposer`。
+ *
+ * 单元名 = 阶段名（一个阶段一个 `Disposer`，不逐注册项打日志）；`phase` 固定 `dispose`。
+ * 单个清理函数失败由 `Disposer` 自己捕获记录，不影响同阶段其它函数。
+ */
+export declare function disposeStage(params: DisposeStageParams): Promise<void>;
 //# sourceMappingURL=lifecycle.d.ts.map

package/output/app/lifecycle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../source/app/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;GAQG;AAEH,eAAO,MAAM,cAAc,aAAa,CAAA;AACxC,uDAAuD;AACvD,eAAO,MAAM,qBAAqB,gBAAgB,CAAA;AAElD,8BAA8B;AAC9B,eAAO,MAAM,oBAAoB,SAAS,CAAA;AAC1C,eAAO,MAAM,uBAAuB,YAAY,CAAA;AAChD,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,GAAG,OAAO,uBAAuB,CAAA;AAEzF;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,sCAAsC;IACtC,GAAG,CAAC,EAAE,UAAU,CAAA;CACjB;AAED,qDAAqD;AACrD,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,cAAc,CAAA;CACtB;AAMD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKxF;AAED,oDAAoD;AACpD,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IACjE,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAmCD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpF;AAED,6EAA6E;AAC7E,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACpE,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,yBAAyB,GAAG,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAMtG;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtF"}
+{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../source/app/lifecycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAE5C;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,cAAc,aAAa,CAAA;AACxC,eAAO,MAAM,YAAY,WAAW,CAAA;AACpC,eAAO,MAAM,iBAAiB,gBAAgB,CAAA;AAC9C,eAAO,MAAM,aAAa,YAAY,CAAA;AACtC,eAAO,MAAM,eAAe,cAAc,CAAA;AAC1C,8CAA8C;AAC9C,eAAO,MAAM,qBAAqB,gBAAoB,CAAA;AAEtD,8BAA8B;AAC9B,eAAO,MAAM,oBAAoB,SAAS,CAAA;AAC1C,eAAO,MAAM,uBAAuB,YAAY,CAAA;AAChD,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,GAAG,OAAO,uBAAuB,CAAA;AAEzF;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,sCAAsC;IACtC,GAAG,CAAC,EAAE,UAAU,CAAA;CACjB;AAED,8DAA8D;AAC9D,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,cAAc,CAAA;CACtB;AAMD;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKxF;AAED,oDAAoD;AACpD,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IACjE,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAmCD;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpF;AAED,6EAA6E;AAC7E,MAAM,WAAW,yBAA0B,SAAQ,mBAAmB;IACpE,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACnC;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,yBAAyB,GAAG,KAAK,CAAC,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAMtG;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,MAAM,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAQtF;AAED,gDAAgD;AAChD,MAAM,WAAW,kBAAmB,SAAQ,mBAAmB;IAC7D,2EAA2E;IAC3E,KAAK,EAAE,MAAM,CAAA;IACb,6CAA6C;IAC7C,QAAQ,EAAE,QAAQ,CAAA;CACnB;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAU5E"}

package/output/app/lifecycle.js

@@ -1,15 +1,26 @@
 /**
  * 生命周期序（N1 §4 / N2 §2.5）。
  *
- * **只有 `services` 参与生命周期**：
+ * **每个阶段一个 `Disposer`**（`ctx.disposer`，所有槽位都有）：在创建某个东西的地方当场
+ * `ctx.disposer.add(() => 释放它)` —— 创建与释放同处一地。
+ *
+ * 关闭时按阶段**逆序 flush**：`routers → middlewares → services → config → resources`
+ * （后创建的先销毁；Prisma / Redis 这类资源最后才断）。
+ *
+ * **`services` 额外有逐单元生命周期**：
  * - 单元之间**不得相互依赖**（`services` 的 ctx 没有 `services` 字段，编译期禁止）；
- * - 顺序语义只有一条：按**对象声明序** `init`、**逆序** `dispose`；
- * - `middlewares` 按数组序注册，**不参与生命周期**（要常驻资源就放 `services`）；
- * - `resources` 只是惰性包装（构造不建连），框架不替它们做生命周期。
+ * - `init` 按**对象声明序**，`dispose` **逆序**；
+ * - services 阶段内部**先 flush `ctx.disposer`**（构造期注册的清理），再逐单元 `dispose`。
+ *
+ * `middlewares` 按数组序注册；它只有 `disposer`，没有逐单元生命周期。
  */
 export const SERVICES_STAGE = 'services';
-/** `middlewares` 的**注册期日志**阶段标签（中间件不参与生命周期，只用于注册日志） */
-export const MIDDLEWARES_LOG_STAGE = 'middlewares';
+export const CONFIG_STAGE = 'config';
+export const MIDDLEWARES_STAGE = 'middlewares';
+export const ROUTERS_STAGE = 'routers';
+export const RESOURCES_STAGE = 'resources';
+/** `middlewares` 的**注册期日志**阶段标签（与生命周期阶段同名） */
+export const MIDDLEWARES_LOG_STAGE = MIDDLEWARES_STAGE;
 /** 生命周期相位（逐单元日志字段 `phase`） */
 export const LIFECYCLE_PHASE_INIT = 'init';
 export const LIFECYCLE_PHASE_DISPOSE = 'dispose';
@@ -97,3 +108,20 @@ export async function disposeServices(params) {
         }
     }
 }
+/**
+ * 关闭步：flush 某个阶段的 `disposer`。
+ *
+ * 单元名 = 阶段名（一个阶段一个 `Disposer`，不逐注册项打日志）；`phase` 固定 `dispose`。
+ * 单个清理函数失败由 `Disposer` 自己捕获记录，不影响同阶段其它函数。
+ */
+export async function disposeStage(params) {
+    const fields = {
+        service: params.service ?? '',
+        unit: params.stage,
+        stage: params.stage,
+        phase: LIFECYCLE_PHASE_DISPOSE,
+    };
+    params.log?.debug(fields, `[lifecycle] ${LIFECYCLE_PHASE_DISPOSE} "${params.stage}" start`);
+    await params.disposer.dispose();
+    params.log?.debug(fields, `[lifecycle] ${LIFECYCLE_PHASE_DISPOSE} "${params.stage}" done`);
+}

package/output/app/lifecycle.test.js

@@ -4,10 +4,11 @@ import { buildDisposeOrder, initServiceUnits, serviceUnitName } from './lifecycl
 /**
  * 生命周期（N1 §4）。
  *
- * - **只有 `services` 参与**：按**对象声明序** `init` / **逆序** `dispose`；
+ * - **每个阶段一个 `Disposer`**（`ctx.disposer`）：创建处注册释放，关闭时按阶段逆序 flush；
+ * - **`services` 额外有逐单元生命周期**：按**对象声明序** `init` / **逆序** `dispose`；
+ * - services 阶段内部：先 flush 自己的 `disposer`，再逐单元 `dispose`；
  * - **没有 `dependsOn`**（`services` 的 ctx 没有 `services` 字段，编译期禁止互依）；
- * - 单元名 = **对象键**；
- * - `middlewares` 按数组序注册，**不参与生命周期**。
+ * - 单元名 = **对象键**。
  */
 describe('init / dispose 顺序：声明序 / 逆序（N1 §4 / §5）', () => {
     it('init：services 按对象声明序', async () => {

package/output/app/middleware-order.test.js

@@ -10,20 +10,21 @@ import { defaultMiddlewares } from './middleware/index.js';
 const fakeMiddlewareContext = {
     app: {},
     log: { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } },
+    disposer: { add: () => { }, dispose: async () => { } },
     services: {},
     config: {},
 };
 describe('ctx 可见性（N1 §2）', () => {
-    it('MiddlewareContext 有 app / log / services / config；没有 resources / env / disposer', () => {
+    it('MiddlewareContext 有 app / log / disposer / services / config；没有 resources / env', () => {
         expectTypeOf().toHaveProperty('app');
         expectTypeOf().toHaveProperty('services');
         expectTypeOf().toHaveProperty('config');
+        // `disposer` 是所有槽位的标配（不是 services 专属）
+        expectTypeOf().toHaveProperty('disposer');
         // @ts-expect-error 中间件看不到 resources（禁直连数据层）
         void 0..resources;
         // @ts-expect-error 中间件看不到 env
         void 0..env;
-        // @ts-expect-error 中间件看不到 disposer（disposer 只属 services）
-        void 0..disposer;
     });
 });
 describe('默认预设', () => {

package/output/app/redis.d.ts

@@ -4,17 +4,21 @@ import type { LoggerLike, RedisHandle } from './types.js';
 /**
  * 引导期 Redis / cache helper（N2 §2.13）。
  *
- * 在 `resources(ctx)` 槽位里按需调用（框架自己**不**创建 Redis）：
+ * 在 `resources(ctx)` 槽位里按需调用（框架自己**不**创建 Redis）；释放**在创建处**登记：
  *
  * ```ts
  * resources: (ctx) => {
  *   const redis = createRedis(ctx.env, ctx.log)          // 无 REDIS_URL → undefined
+ *   if (redis) {
+ *     ctx.disposer.add(() => redis.dispose())            // 关闭时 resources 阶段最后 flush
+ *   }
  *   return { redis, cache: createCache({ env: ctx.env, prefix: 'account', redis }) }
  * }
  * ```
  *
  * `REDIS_URL` 由 helper 直接读 `env`（固定约定），**不**取自 `config`；`redis` / `cache` 一律是
  * **惰性包装**：构造时不建连、不 ping，首次真正使用才建连 —— 「出 spec 不连库/Redis」结构性成立。
+ * 释放永远走调用方在 `ctx.disposer` 里的登记，框架不替资源持有句柄。
  */
 /** 一级/二级缓存默认 TTL（秒），与 `RedisCache` 默认一致 */
 export declare const DEFAULT_REDIS_CACHE_TTL_SECONDS = 300;

package/output/app/redis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../source/app/redis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAEzD;;;;;;;;;;;;;;GAcG;AAEH,2CAA2C;AAC3C,eAAO,MAAM,+BAA+B,MAAM,CAAA;AAElD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAmBrF;AAED,uBAAuB;AACvB,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,SAAS,CAAA;IACd,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,GAAG,CAAC,EAAE,UAAU,CAAA;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAYhE"}
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../source/app/redis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAEzD;;;;;;;;;;;;;;;;;;GAkBG;AAEH,2CAA2C;AAC3C,eAAO,MAAM,+BAA+B,MAAM,CAAA;AAElD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,UAAU,GAAG,WAAW,GAAG,SAAS,CAmBrF;AAED,uBAAuB;AACvB,MAAM,WAAW,gBAAgB;IAC/B,GAAG,EAAE,SAAS,CAAA;IACd,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,KAAK,CAAC,EAAE,WAAW,CAAA;IACnB,GAAG,CAAC,EAAE,UAAU,CAAA;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,gBAAgB,GAAG,UAAU,CAYhE"}

package/output/app/redis.js

@@ -2,17 +2,21 @@ import { createRedisClient, RedisCache } from '../redis-cache/index.js';
 /**
  * 引导期 Redis / cache helper（N2 §2.13）。
  *
- * 在 `resources(ctx)` 槽位里按需调用（框架自己**不**创建 Redis）：
+ * 在 `resources(ctx)` 槽位里按需调用（框架自己**不**创建 Redis）；释放**在创建处**登记：
  *
  * ```ts
  * resources: (ctx) => {
  *   const redis = createRedis(ctx.env, ctx.log)          // 无 REDIS_URL → undefined
+ *   if (redis) {
+ *     ctx.disposer.add(() => redis.dispose())            // 关闭时 resources 阶段最后 flush
+ *   }
  *   return { redis, cache: createCache({ env: ctx.env, prefix: 'account', redis }) }
  * }
  * ```
  *
  * `REDIS_URL` 由 helper 直接读 `env`（固定约定），**不**取自 `config`；`redis` / `cache` 一律是
  * **惰性包装**：构造时不建连、不 ping，首次真正使用才建连 —— 「出 spec 不连库/Redis」结构性成立。
+ * 释放永远走调用方在 `ctx.disposer` 里的登记，框架不替资源持有句柄。
  */
 /** 一级/二级缓存默认 TTL（秒），与 `RedisCache` 默认一致 */
 export const DEFAULT_REDIS_CACHE_TTL_SECONDS = 300;

package/output/app/resources.test.js

@@ -16,7 +16,7 @@ const assertLiveKeysRemovesFalse = () => {
 };
 void assertLiveKeysRemovesFalse;
 describe('resources 槽位（N1 §2 / N2 §2.3）', () => {
-    it('① 入参只有 env + log，且资源嵌套在 ctx.resources 下（config / services 都能用）', async () => {
+    it('① 入参为 env + log + disposer + registerClassifyError，且资源嵌套在 ctx.resources 下（config / services 都能用）', async () => {
         let captured;
         const observed = {};
         const server = defineServer({
@@ -43,9 +43,13 @@ describe('resources 槽位（N1 §2 / N2 §2.3）', () => {
         });
         const app = await startServer(server, { listen: false });
         try {
-            expect(Object.keys(captured ?? {}).sort()).toEqual(['env', 'log']);
+            // 槽位 ctx：env + log + disposer（+ 专属的 registerClassifyError）
+            expect(Object.keys(captured ?? {}).sort()).toEqual(['disposer', 'env', 'log', 'registerClassifyError']);
             expect(captured?.env.ENV).toBeTypeOf('string');
             expect(typeof captured?.log.info).toBe('function');
+            expect(typeof captured?.disposer.add).toBe('function');
+            // resources 槽位专属能力：每个资源注册自己的错误分类器（函数）
+            expect(typeof captured?.registerClassifyError).toBe('function');
             expect(observed.inConfig).toBe('rows:select 1');
             expect(observed.inServices).toBe('domain:cached');
             const response = await app.inject({ method: 'GET', url: '/resource' });
@@ -141,38 +145,59 @@ describe('resources 槽位（N1 §2 / N2 §2.3）', () => {
             await app.close();
         }
     });
-    it('⑤ 框架不管资源生命周期：资源上的 dispose 不被调用（释放要放 services）', async () => {
+    it('⑤ resources 的 disposer 在 services 阶段**之后**执行；阶段内按逆注册序；资源对象自带的 dispose 不被调用', async () => {
         const calls = [];
         const server = defineServer({
             app: { service: 'resources-lifecycle', title: 'Resources Lifecycle', version: '1.0.0' },
-            resources: () => ({
-                database: {
+            resources: (ctx) => {
+                // 资源对象自带的 `dispose` 不参与生命周期：释放只认 `ctx.disposer.add(...)`
+                const database = {
                     dispose: () => {
-                        calls.push('dispose:resource');
+                        calls.push('dispose:resource-object');
                     },
-                },
-            }),
+                };
+                ctx.disposer.add(() => {
+                    calls.push('dispose:resource-a');
+                });
+                ctx.disposer.add(() => {
+                    calls.push('dispose:resource-b');
+                });
+                return { database };
+            },
             config: () => ({}),
-            services: () => ({
-                databaseClient: {
-                    dispose: () => {
-                        calls.push('dispose:service');
+            services: (ctx) => {
+                ctx.disposer.add(() => {
+                    calls.push('dispose:services-disposer');
+                });
+                return {
+                    databaseClient: {
+                        dispose: () => {
+                            calls.push('dispose:service-unit');
+                        },
                     },
-                },
-            }),
+                };
+            },
             middlewares: () => [],
             routers: () => undefined,
         });
         const app = await startServer(server, { listen: false });
         await app.close();
-        expect(calls).toEqual(['dispose:service']);
+        expect(calls).toEqual([
+            'dispose:services-disposer',
+            'dispose:service-unit',
+            'dispose:resource-b',
+            'dispose:resource-a',
+        ]);
     });
-    it('⑥ 出 spec 路径同样跑 resources（只构造，不建连）', async () => {
-        let calls = 0;
+    it('⑥ 出 spec 路径同样跑 resources（只构造，不建连），但不 flush 任何 disposer', async () => {
+        const calls = [];
         const server = defineServer({
             app: { service: 'resources-openapi', title: 'Resources OpenApi', version: '1.0.0' },
-            resources: () => {
-                calls += 1;
+            resources: (ctx) => {
+                calls.push('resources');
+                ctx.disposer.add(() => {
+                    calls.push('dispose:resources');
+                });
                 return {};
             },
             config: () => ({}),
@@ -181,7 +206,7 @@ describe('resources 槽位（N1 §2 / N2 §2.3）', () => {
             routers: () => undefined,
         });
         await generateOpenApi(server);
-        expect(calls).toBe(1);
+        expect(calls).toEqual(['resources']);
     });
 });
 /** `ResourcesView` 自证：`Awaited<>` 归一（同步 / 异步两写法等价） */

package/output/app/shutdown.d.ts

@@ -1,14 +1,19 @@
 /**
  * 固定关闭步（N1 §5）——**顺序写死在数组里**。
  *
- * 新口径下框架不再持有 Redis / 数据库 / 外链客户端（这些都在 `resources` 里，由各仓自行构造，
- * 需要释放时放 `services` 单元）；配置失效通道已删除，故没有 `unsubscribeConfig` 步。
+ * `disposer` 是所有槽位 ctx 的标配：每个阶段一个 `Disposer`，在**创建处**注册释放。
+ * 关闭时按阶段**逆序 flush**：`routers → middlewares → services → config → resources`
+ * （后创建的先销毁；Prisma / Redis 这类资源**最后**才断）。
  *
- * 固定两步：`stopProducers`（`ctx.disposer` 注册的清理）→ `disposeServices`（services 逆序）。
+ * `services` 阶段内部保持既有语义：先 flush 自己的 `disposer`（原 `stopProducers`），
+ * 再 `disposeServices`（单元**逆序** `dispose`）。配置失效通道已删除，故没有 `unsubscribeConfig` 步。
+ *
+ * 固定六步：`flushRouters` → `flushMiddlewares` → `flushServices` → `disposeServices`
+ * → `flushConfig` → `flushResources`。
  *
  * 每步失败记日志、不阻断后续，最后聚合上报。
  */
-export declare const SHUTDOWN_ORDER: readonly ["stopProducers", "disposeServices"];
+export declare const SHUTDOWN_ORDER: readonly ["flushRouters", "flushMiddlewares", "flushServices", "disposeServices", "flushConfig", "flushResources"];
 export type ShutdownStepName = (typeof SHUTDOWN_ORDER)[number];
 export type ShutdownHandles = Record<ShutdownStepName, () => void | Promise<void>>;
 export interface ShutdownLogger {

package/output/app/shutdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../source/app/shutdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,+CAAgD,CAAA;AAE3E,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,gBAAgB,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;AAElF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5C;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAe9F"}
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../source/app/shutdown.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,oHAOjB,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE9D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,gBAAgB,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAA;AAElF,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5C;AAED;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAe9F"}

package/output/app/shutdown.js

@@ -1,14 +1,26 @@
 /**
  * 固定关闭步（N1 §5）——**顺序写死在数组里**。
  *
- * 新口径下框架不再持有 Redis / 数据库 / 外链客户端（这些都在 `resources` 里，由各仓自行构造，
- * 需要释放时放 `services` 单元）；配置失效通道已删除，故没有 `unsubscribeConfig` 步。
+ * `disposer` 是所有槽位 ctx 的标配：每个阶段一个 `Disposer`，在**创建处**注册释放。
+ * 关闭时按阶段**逆序 flush**：`routers → middlewares → services → config → resources`
+ * （后创建的先销毁；Prisma / Redis 这类资源**最后**才断）。
  *
- * 固定两步：`stopProducers`（`ctx.disposer` 注册的清理）→ `disposeServices`（services 逆序）。
+ * `services` 阶段内部保持既有语义：先 flush 自己的 `disposer`（原 `stopProducers`），
+ * 再 `disposeServices`（单元**逆序** `dispose`）。配置失效通道已删除，故没有 `unsubscribeConfig` 步。
+ *
+ * 固定六步：`flushRouters` → `flushMiddlewares` → `flushServices` → `disposeServices`
+ * → `flushConfig` → `flushResources`。
  *
  * 每步失败记日志、不阻断后续，最后聚合上报。
  */
-export const SHUTDOWN_ORDER = ['stopProducers', 'disposeServices'];
+export const SHUTDOWN_ORDER = [
+    'flushRouters',
+    'flushMiddlewares',
+    'flushServices',
+    'disposeServices',
+    'flushConfig',
+    'flushResources',
+];
 /**
  * 顺序执行关闭步骤；单步抛错记录后**继续**后续步骤，最后聚合上报
  * （避免「一步报错导致后面资源没关」）。