@tbox.cn/app-toolkit 0.5.0 → 0.7.0

package/tests/views.test.ts

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { createAppToolkit, type AppToolkit } from '../src/factory.js';
 import { invalidateContractsResolver } from '../src/core/contracts-resolver.js';
 import { walkManifests, type WalkManifestsResult } from '../src/assembly/walk-manifests.js';
-import { buildIntegrationFieldRegistry, loadModuleFormViews, loadModuleIntegrationSchemas, loadServiceFieldRegistry } from '../src/views/integration-schemas.js';
+import { buildIntegrationFieldRegistry, loadModuleFormViews, loadModuleIntegrationSchemas, loadServiceFieldRegistry, loadServiceIntegrationSchemas } from '../src/views/integration-schemas.js';
 import { resolveServiceDisplay } from '../src/views/context.js';
 import type { ViewSnapshot } from '../src/views/context.js';
 import { URL_METHOD_MAP } from './naming-alignment.test.js';
@@ -24,7 +24,7 @@ interface Harness {
 }
 
 function harnessWithContracts(
-  opts: { version?: string; withStrict?: boolean; missingEvaluationExports?: boolean } = {},
+  opts: { version?: string; withStrict?: boolean; missingEvaluationExports?: boolean; resolveBody?: string[] } = {},
 ): Harness {
   const app = createTempApp('tbox-views-');
   invalidateContractsResolver();
@@ -33,6 +33,7 @@ function harnessWithContracts(
     version: opts.version ?? '0.9.0',
     withStrict: opts.withStrict ?? true,
     missingEvaluationExports: opts.missingEvaluationExports,
+    ...(opts.resolveBody ? { resolveBody: opts.resolveBody.join(' ') } : {}),
   });
   linkContracts(app.appDir, store, { subdir: 'apps/server' });
   // 应用结构：parking 模块（packages/ 约定发现）+ 注册表两实例 + integrations.json
@@ -240,6 +241,96 @@ function layerHarness(): {
   return { app, tk: createAppToolkit(app.appDir), schemas, joycity };
 }
 
+/** E 系列基座（v4.7 D38 引入；v5.1 D39 提升至模块层共用——原 D38 describe 内定义）：wanda 双槽
+ *  （layerHarness 形态）+ joycity 双 impl（O6 形态）+ config/schemas/ok.json（O15 形态）+
+ *  module-parking demand。schema 内容互异防断言串扰：
+ *  wQuery={baseUrl} / wParking={mallId} / joycity@1={joycityUrl} / joycity@2={endpointV2} / ok={okEndpoint}。
+ *  每用例独立 eHarness()——fixture 全新 temp app，零 file-cache stat 指纹串扰（不取重写+bumpMtime 方案）。
+ *  供给矩阵：wanda 供给 {parking.query, parking.payment}；joycity 仅供给 {parking.query}
+ *  （provider-multi 双 impl 皆 query）——D39 用例 (厂商 × 服务) 选型须对照本矩阵。 */
+function eHarness(): {
+  app: TempApp;
+  tk: AppToolkit;
+  schemas: { wQuery: object; wParking: object; joycity1: object; joycity2: object; ok: object };
+} {
+  const app = createTempApp('tbox-d38-');
+  invalidateContractsResolver();
+  const store = join(app.appDir, 'contracts');
+  writeFakeContractsPackage(store, { version: '0.9.0' });
+  linkContracts(app.appDir, store, { subdir: 'apps/server' });
+  const schemas = {
+    wQuery: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
+    wParking: { type: 'object', properties: { mallId: { type: 'string' } } },
+    joycity1: { type: 'object', properties: { joycityUrl: { type: 'string' } } },
+    joycity2: { type: 'object', properties: { endpointV2: { type: 'string' } } },
+    ok: { type: 'object', properties: { okEndpoint: { type: 'string' } } },
+  };
+  writeAppFile(
+    app.appDir,
+    'packages/provider-w/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      id: 'provider-w',
+      version: '0.1.0',
+      kind: 'business',
+      declare: {
+        providers: {
+          slots: [
+            { service: 'parking.query', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/query.json' },
+            { service: 'parking.payment', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/parking.json' },
+          ],
+        },
+      },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(app.appDir, 'packages/provider-w/schemas/query.json', JSON.stringify(schemas.wQuery));
+  writeAppFile(app.appDir, 'packages/provider-w/schemas/parking.json', JSON.stringify(schemas.wParking));
+  writeAppFile(
+    app.appDir,
+    'packages/provider-multi/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      id: 'provider-multi',
+      version: '0.1.0',
+      kind: 'business',
+      declare: {
+        providers: {
+          slots: [
+            { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/query.json' },
+            { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@2', credentialType: 'joycity-c', configSchema: 'schemas/query2.json' },
+          ],
+        },
+      },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(app.appDir, 'packages/provider-multi/schemas/query.json', JSON.stringify(schemas.joycity1));
+  writeAppFile(app.appDir, 'packages/provider-multi/schemas/query2.json', JSON.stringify(schemas.joycity2));
+  writeAppFile(app.appDir, 'config/schemas/ok.json', JSON.stringify(schemas.ok));
+  writeAppFile(
+    app.appDir,
+    'packages/module-parking/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      id: 'module-parking',
+      version: '0.1.0',
+      kind: 'business',
+      declare: { owns: [{ service: 'parking.query' }], consumes: [{ service: 'parking.query', optional: false }] },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  return { app, tk: createAppToolkit(app.appDir), schemas };
+}
+
+/** integrations.json 单次写入（每用例独立 harness——零缓存串扰） */
+function writeIntegrations(appDir: string, config: Record<string, unknown>): void {
+  writeAppFile(appDir, 'config/integrations.json', JSON.stringify(config));
+}
+
 describe('views/工厂（O 矩阵核心族）', () => {
   let h: Harness;
 
@@ -267,7 +358,8 @@ describe('views/工厂（O 矩阵核心族）', () => {
     const mod = await h.tk.loadModule('module-parking');
     // v4.4 D34：domainKeys/providerBindings/configEditable 显式化（include 两键可选缺席——F4）
     // v7 词汇统一：模块展示名 name 前置（恒发——兜底 id）
-    expect(Object.keys(mod)).toEqual(['name', 'description', 'ownedServices', 'integration', 'binding', 'configEditable', 'services']);
+    // resources 只读镜像（N2 读半边——基座 integrations modules 节无 resources → null 仍恒发）
+    expect(Object.keys(mod)).toEqual(['name', 'description', 'ownedServices', 'integration', 'resources', 'binding', 'configEditable', 'services']);
     const svc = await h.tk.loadService('parking.query');
     expect(Object.keys(svc).some((k) => ['resolution', 'issues', 'contracts'].includes(k))).toBe(false);
     // 静态端点在 <0.9 下照常（永不 503——O13 反例联动）
@@ -287,6 +379,41 @@ describe('views/工厂（O 矩阵核心族）', () => {
     expect(single.resolution.inheritance).toHaveLength(4);
   });
 
+  it('O17 v6 ownerOf 视图轴透传（回归锁——fef9a71a 漏改点）：求值单源带 walk.ownership 第 5 参；modules 级 config 不触发 fail-visible', async () => {
+    // 假 contracts 复刻 v6 fail-visible 语义 + 回显 ownerOf：缺席 + modules 绑定面 → binding-unresolved；
+    // 在场 → effective.provider 前缀回显 owner 模块 id（证明透传值 = walk.ownership 内容本身）
+    const ownerEcho = harnessWithContracts({
+      resolveBody: [
+        'const modBinding = integrations && integrations.modules',
+        '  && Object.values(integrations.modules).some((m) => m.provider != null || m.config != null);',
+        'if ((ownerOf === undefined || ownerOf === null) && modBinding) return { status: "binding-unresolved", message: "OWNEROF_MISSING" };',
+        'const owner = ownerOf ? ownerOf[service] : undefined;',
+        'const slot = integrations && integrations.services && integrations.services[service];',
+        'const prov = (slot && slot.provider) || "root-mock";',
+        'return { status: "ok", effective: { provider: owner ? owner + ":" + prov : prov, implementation: "impl@1", config: {} } };',
+      ],
+    });
+    // 触发形态（bug 实景）：modules 仅 config（无 provider）+ 空 slot——依赖 ownerOf 注入才能过 fail-visible
+    writeAppFile(
+      ownerEcho.app.appDir,
+      'config/integrations.json',
+      JSON.stringify({
+        provider: 'root-mock',
+        modules: { 'module-parking': { config: { parkName: '示例车场' } } },
+        services: { 'parking.query': {}, 'auth.alipay-login': {} },
+      }),
+    );
+    const single = await ownerEcho.tk.loadServiceResolution('parking.query');
+    // ① fail-visible 未触发（ownerOf 已注入）
+    expect(single.resolution.status).toBe('ok');
+    // ② 透传值 = walk.ownership 内容（parking.query 归属 module-parking——harness manifest declare.owns）
+    expect(single.resolution.provider).toBe('module-parking:root-mock');
+    // ③ 无主服务回退无前缀（排除「任意 truthy 值即绿」的假阳性）
+    const orphan = await ownerEcho.tk.loadServiceResolution('auth.alipay-login');
+    expect(orphan.resolution.provider).toBe('root-mock');
+    ownerEcho.app.dispose();
+  });
+
   it('O3 键集 = 服务词汇 ∪ 已配置；required echo（OR 聚合 + 平台 false）', async () => {
     // vocabulary 空（无契约包 fixture 物化 slots——退化态回归锁；词汇在场态见 B1 族 T-O3）
     const batch = await h.tk.loadServiceResolutions();
@@ -302,28 +429,29 @@ describe('views/工厂（O 矩阵核心族）', () => {
     expect(batch.issues.length).toBeGreaterThanOrEqual(single.issues.length);
   });
 
-  it('O13 门控正反例：<0.9 求值 503 三分支 + 静态 200；多实例无显式默认 → 通配口径', async () => {
+  it('O13 门控正反例：<0.9 读求值轴降级骨架（v7 503 退役）+ 静态 200 + 写端点 503 保留；多实例无显式默认 → 通配口径', async () => {
     // 正例：≥0.9 求值可用（harness 默认）
     const batch = await h.tk.loadServiceResolutions();
     expect(batch.contracts.strictValidation).toBe(true);
     h.app.dispose();
 
-    // 反例：缺 zod 面（0.8.2）→ 求值 throw 503 + message 升级指引；静态照常
+    // 反例：缺 zod 面（0.8.2）→ 读求值轴降级骨架 + N1 升级指引入 statusMessage；静态照常
     const low = harnessWithContracts({ version: '0.8.2', withStrict: false });
-    await expect(low.tk.loadServiceResolutions()).rejects.toMatchObject({
-      code: 'CONTRACTS_NOT_RESOLVED',
-      httpStatus: 503,
-    });
-    await expect(low.tk.loadServiceResolutions()).rejects.toThrow(/升级应用 @tbox.cn\/app-contracts/);
+    const lowBatch = await low.tk.loadServiceResolutions();
+    expect(lowBatch.contracts.strictValidation).toBe(false);
+    const lowEntries = Object.values(lowBatch.resolutions);
+    expect(lowEntries.length).toBeGreaterThan(0);
+    expect(lowEntries.every((e) => e.status === 'evaluation-unavailable')).toBe(true);
+    expect(lowEntries[0]?.statusMessage).toMatch(/升级应用 @tbox\.cn\/app-contracts/);
+    expect(lowBatch.issues).toEqual([]);
     // 静态永不 503
     const appView = await low.tk.loadApp();
     expect(appView.services).toBeInstanceOf(Array);
-    // 写端点同样门控
+    // 写端点 503 门控保留（policy at edge 收窄至写/迁移面）
     await expect(
       low.tk.writeServiceIntegration('parking.query', { provider: 'mock' }),
     ).rejects.toMatchObject({ code: 'CONTRACTS_NOT_RESOLVED', httpStatus: 503 });
     low.app.dispose();
-
     // 默认实例委托：无 defaultInstanceId（多实例）→ '*' 通配口径（normalizeInstances null → '*'）
     const wild = harnessWithContracts();
     writeAppFile(
@@ -607,41 +735,102 @@ describe('O6/O7/O10/O14（FX-3 补全）', () => {
 });
 
 describe('A2 错误面（P-4 notes 优先 / P-5 畸形包 503）', () => {
-  it('M1 导入失败 message 含构建指引且不再误报未安装（P-4 notes 优先）', async () => {
+  it('M1 导入失败 message 含构建指引且不再误报未安装（P-4 notes 优先——v7 降级骨架 statusMessage 承载）', async () => {
     const app = createTempApp('tbox-m1-');
     invalidateContractsResolver();
     const store = joinStore(app.appDir, 'contracts');
     writeFakeContractsPackage(store, { version: '0.9.0', brokenDist: true });
     linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(app.appDir, 'config/integrations.json', JSON.stringify({ provider: 'mock', services: { 'parking.query': {} } }));
+    const tk = createAppToolkit(app.appDir);
+    const batch = await tk.loadServiceResolutions();
+    const entry = batch.resolutions['parking.query'];
+    expect(entry.status).toBe('evaluation-unavailable');
+    expect(entry.statusMessage).toMatch(/构建产物导入失败/);
+    expect(entry.statusMessage).not.toMatch(/未安装/);
+    app.dispose();
+  });
+
+  it('M4 无契约包（未安装）→ 降级骨架 + 声明实例枚举 + T2 空键集诚实态（问题②主形态）', async () => {
+    // T1 形态：contracts 未安装，walk 静态面在场（manifest demand/owns + integrations 配置）
+    const app = createTempApp('tbox-m4-');
+    invalidateContractsResolver();
+    writeAppFile(app.appDir, 'packages/module-parking/tbox.module.json', JSON.stringify({
+      schemaVersion: 1, id: 'module-parking', version: '0.1.0', kind: 'business',
+      declare: { owns: [{ service: 'parking.query' }], consumes: [{ service: 'parking.query', optional: false }] },
+      dependencies: { modules: [] },
+      env: [],
+    }));
+    writeAppFile(app.appDir, 'config/integrations.json', JSON.stringify({
+      provider: 'mock', instances: [{ id: 'mall-1' }], defaultInstanceId: 'mall-1',
+      services: { 'parking.query': { instances: { 'mall-1': { provider: 'wanda', implementation: 'wanda-parking@1' } } } },
+    }));
     const tk = createAppToolkit(app.appDir);
-    await expect(tk.loadServiceResolutions()).rejects.toThrow(/构建产物导入失败/);
-    await expect(tk.loadServiceResolutions()).rejects.not.toThrow(/未安装/);
+    const batch = await tk.loadServiceResolutions();
+    const entry = batch.resolutions['parking.query'];
+    expect(entry.status).toBe('evaluation-unavailable');
+    expect(entry.statusMessage).toMatch(/未安装/);
+    // 静态可算字段：module = demand owners 首（与求值轴同源）；required = OR 聚合
+    expect(entry.module).toBe('@app/module-parking');
+    expect(entry.required).toBe(true);
+    expect(batch.issues).toEqual([]);
+    // 单体：声明实例枚举（原始数据投影——root instances[].id）逐实例同标记；
+    // inheritance 四层静态投影（app=root.provider；instance=显式 defaultInstanceId 位声明——降级默认实例口径实证）
+    const detail = await tk.loadServiceResolution('parking.query');
+    expect(detail.resolution.instances.map((i) => i.instanceId)).toEqual(['mall-1']);
+    expect(detail.resolution.instances.every((i) => i.status === 'evaluation-unavailable')).toBe(true);
+    expect(detail.resolution.inheritance).toHaveLength(4);
+    expect(detail.resolution.inheritance.find((l) => l.layer === 'app')?.provider).toBe('mock');
+    const instLayer = detail.resolution.inheritance.find((l) => l.layer === 'instance');
+    expect(instLayer?.provider).toBe('wanda');
+    expect(instLayer?.implementation).toBe('wanda-parking@1');
+    // include 轴内嵌骨架（四面统一——P14 (b)）
+    const appInc = await tk.loadApp({ include: ['serviceResolutions'] });
+    expect(appInc.serviceResolutions?.resolutions['parking.query']?.status).toBe('evaluation-unavailable');
     app.dispose();
+
+    // T2 形态：无 manifest 无 integrations → 空键集诚实态（空列表非 503；envelope 携带原因）
+    const bare = createTempApp('tbox-m4b-');
+    invalidateContractsResolver();
+    const bareTk = createAppToolkit(bare.appDir);
+    const bareBatch = await bareTk.loadServiceResolutions();
+    expect(bareBatch.resolutions).toEqual({});
+    expect(bareBatch.contracts.version).toBeNull();
+    expect(bareBatch.contracts.notes.join()).toMatch(/未安装/);
+    bare.dispose();
   });
 
-  it('M2 <0.9 message 对齐 api.md 信封（需 ≥0.9.0——resolver note 文案）', async () => {
+  it('M2 <0.9 message 对齐 api.md 信封（需 ≥0.9.0——resolver note 文案入降级 statusMessage）', async () => {
     const app = createTempApp('tbox-m2-');
     invalidateContractsResolver();
     const store = joinStore(app.appDir, 'contracts');
     writeFakeContractsPackage(store, { version: '0.8.2', withStrict: false });
     linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(app.appDir, 'config/integrations.json', JSON.stringify({ provider: 'mock', services: { 'parking.query': {} } }));
     const tk = createAppToolkit(app.appDir);
-    await expect(tk.loadServiceResolutions()).rejects.toThrow(/需 ≥0\.9\.0/);
+    const entry = (await tk.loadServiceResolutions()).resolutions['parking.query'];
+    expect(entry.status).toBe('evaluation-unavailable');
+    expect(entry.statusMessage).toMatch(/需 ≥0\.9\.0/);
     app.dispose();
   });
 
-  it('M3 畸形包（求值面缺席）+ 无 config → 503 非 500（P-5——predicateIssues 早退绕过 assertFn 的唯一后续拦截点）', async () => {
+  it('M3 畸形包（严格面在场求值面缺席）→ 降级骨架非 5xx（v7——evaluationContracts throw 面不再可达；形态异常 note 入 statusMessage）', async () => {
     const app = createTempApp('tbox-m3-');
     invalidateContractsResolver();
     const store = joinStore(app.appDir, 'contracts');
     writeFakeContractsPackage(store, { version: '0.9.0', missingEvaluationExports: true, slots: ['parking.query'] });
     linkContracts(app.appDir, store, { subdir: 'apps/server' });
-    const tk = createAppToolkit(app.appDir); // 不写 integrations.json——config === null 早退路径
-    await expect(tk.loadServiceResolutions()).rejects.toMatchObject({
-      code: 'CONTRACTS_NOT_RESOLVED',
-      httpStatus: 503,
-    });
-    await expect(tk.loadServiceResolutions()).rejects.not.toThrow(/工厂门控应先行拦截/);
+    writeAppFile(app.appDir, 'config/integrations.json', JSON.stringify({ provider: 'mock', services: { 'parking.query': {} } }));
+    const tk = createAppToolkit(app.appDir);
+    const batch = await tk.loadServiceResolutions();
+    const entry = batch.resolutions['parking.query'];
+    expect(entry.status).toBe('evaluation-unavailable');
+    expect(entry.statusMessage).toMatch(/求值面具名导出缺席/);
+    expect(entry.statusMessage).toMatch(/契约包形态异常/);
+    // 声明实例投影在场（降级 detail——原始数据非 normalizeInstances 派生）
+    const detail = await tk.loadServiceResolution('parking.query');
+    expect(detail.resolution.status).toBe('evaluation-unavailable');
+    expect(detail.resolution.inheritance).toHaveLength(4);
     app.dispose();
   });
 });
@@ -758,7 +947,7 @@ describe('v6 所有权族（D34 多域钉死退役 → ownedServices/binding 单
     app.dispose();
   });
 
-  it('D6 偏斜态 503 第四分支（P1 标记门）：v5 contracts 假件（无 OWNERSHIP_BINDING_V6）+ v6 toolkit → 503', async () => {
+  it('D6 偏斜态分级（P1 标记门 v7）：v5 contracts 假件 + v6 toolkit → 写端点 503 保留；读求值轴降级骨架（503 退役）', async () => {
     const app = createTempApp('tbox-d6-');
     invalidateContractsResolver();
     const store = joinStore(app.appDir, 'contracts');
@@ -768,15 +957,21 @@ describe('v6 所有权族（D34 多域钉死退役 → ownedServices/binding 单
       schemaVersion: 1, id: 'module-parking', version: '0.1.0', kind: 'business',
       declare: { owns: [{ service: 'parking.query' }] },
     }));
+    writeAppFile(app.appDir, 'config/integrations.json', JSON.stringify({ provider: 'mock', services: { 'parking.query': {} } }));
     const tk = createAppToolkit(app.appDir);
-    // 写路径门控（求值轴同此门——assertContractsUsable 单点）
+    // 写路径门控保留（assertContractsUsable——policy at edge 收窄至写/迁移面）
     await expect(tk.writeModuleIntegration('module-parking', { provider: 'wanda' })).rejects.toMatchObject({
       code: 'CONTRACTS_NOT_RESOLVED',
       httpStatus: 503,
       message: expect.stringContaining('OWNERSHIP_BINDING_V6'),
     });
-    await expect(tk.loadServiceResolutions()).rejects.toMatchObject({ code: 'CONTRACTS_NOT_RESOLVED', httpStatus: 503 });
-    // 静态端点照常（永不 503——门控 policy at edge 只拦求值/写/migrate）
+    // 读求值轴降级（503 退役）：statusMessage 与写门控同源（N1 标记分支单源）
+    const degraded = await tk.loadServiceResolutions();
+    expect(degraded.contracts.strictValidation).toBe(true);
+    const entry = degraded.resolutions['parking.query'];
+    expect(entry.status).toBe('evaluation-unavailable');
+    expect(entry.statusMessage).toMatch(/OWNERSHIP_BINDING_V6 标记缺席/);
+    // 静态端点照常（永不 503——门控 policy at edge 只拦写/迁移）
     const mod = await tk.loadModule('module-parking');
     expect(mod.ownedServices).toEqual(['parking.query']);
     app.dispose();
@@ -830,15 +1025,20 @@ describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
     h2.app.dispose();
   });
 
-  it('I3 degrade：<0.9 → null 永不 503；形态异常包（严格面在场求值面缺席）→ null（双条件）', async () => {
+  it('I3 degrade：内嵌轴同步降级（v7 P14 (b)——D31 null 分支退役）：三条件不满足 → 骨架非 null', async () => {
     const low = harnessWithContracts({ version: '0.8.2', withStrict: false });
-    expect((await low.tk.loadApp({ include: ['serviceResolutions'] })).serviceResolutions).toBeNull();
+    const lowInc = await low.tk.loadApp({ include: ['serviceResolutions'] });
+    expect(lowInc.serviceResolutions).not.toBeNull();
+    const lowEntries = Object.values(lowInc.serviceResolutions!.resolutions);
+    expect(lowEntries.length).toBeGreaterThan(0);
+    expect(lowEntries.every((e) => e.status === 'evaluation-unavailable')).toBe(true);
     expect((await low.tk.loadApp({ include: ['integrationSchemas'] })).integrationSchemas).toEqual({ provider: 'mock', services: {} }); // 静态轴富化零 contracts
     low.app.dispose();
+    // 畸形包（严格面在场求值面缺席）→ 内嵌轴同样降级（503/双 null 全退役）
     const malformed = harnessWithContracts({ missingEvaluationExports: true });
-    expect((await malformed.tk.loadApp({ include: ['serviceResolutions'] })).serviceResolutions).toBeNull();
-    // 对照：求值轴端点同 fixture → 503（M3 已钉——门控与内嵌两机制不共用断言）
-    await expect(malformed.tk.loadServiceResolutions()).rejects.toMatchObject({ httpStatus: 503 });
+    const malformedInc = await malformed.tk.loadApp({ include: ['serviceResolutions'] });
+    expect(malformedInc.serviceResolutions).not.toBeNull();
+    expect(Object.values(malformedInc.serviceResolutions!.resolutions)[0]?.status).toBe('evaluation-unavailable');
     malformed.app.dispose();
   });
 
@@ -1022,93 +1222,6 @@ describe('模块清单 provider 家族排除（2026-09-16 双缺陷批——供
 });
 
 describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
-  /** E 系列基座：wanda 双槽（layerHarness 形态）+ joycity 双 impl（O6 形态）+ config/schemas/ok.json
-   *  （O15 形态）+ module-parking demand。schema 内容互异防断言串扰：
-   *  wQuery={baseUrl} / wParking={mallId} / joycity@1={joycityUrl} / joycity@2={endpointV2} / ok={okEndpoint}。
-   *  每用例独立 eHarness()——fixture 全新 temp app，零 file-cache stat 指纹串扰（不取重写+bumpMtime 方案）。 */
-  function eHarness(): {
-    app: TempApp;
-    tk: AppToolkit;
-    schemas: { wQuery: object; wParking: object; joycity1: object; joycity2: object; ok: object };
-  } {
-    const app = createTempApp('tbox-d38-');
-    invalidateContractsResolver();
-    const store = join(app.appDir, 'contracts');
-    writeFakeContractsPackage(store, { version: '0.9.0' });
-    linkContracts(app.appDir, store, { subdir: 'apps/server' });
-    const schemas = {
-      wQuery: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
-      wParking: { type: 'object', properties: { mallId: { type: 'string' } } },
-      joycity1: { type: 'object', properties: { joycityUrl: { type: 'string' } } },
-      joycity2: { type: 'object', properties: { endpointV2: { type: 'string' } } },
-      ok: { type: 'object', properties: { okEndpoint: { type: 'string' } } },
-    };
-    writeAppFile(
-      app.appDir,
-      'packages/provider-w/tbox.module.json',
-      JSON.stringify({
-        schemaVersion: 1,
-        id: 'provider-w',
-        version: '0.1.0',
-        kind: 'business',
-        declare: {
-          providers: {
-            slots: [
-              { service: 'parking.query', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/query.json' },
-              { service: 'parking.payment', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/parking.json' },
-            ],
-          },
-        },
-        dependencies: { modules: [] },
-        env: [],
-      }),
-    );
-    writeAppFile(app.appDir, 'packages/provider-w/schemas/query.json', JSON.stringify(schemas.wQuery));
-    writeAppFile(app.appDir, 'packages/provider-w/schemas/parking.json', JSON.stringify(schemas.wParking));
-    writeAppFile(
-      app.appDir,
-      'packages/provider-multi/tbox.module.json',
-      JSON.stringify({
-        schemaVersion: 1,
-        id: 'provider-multi',
-        version: '0.1.0',
-        kind: 'business',
-        declare: {
-          providers: {
-            slots: [
-              { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/query.json' },
-              { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@2', credentialType: 'joycity-c', configSchema: 'schemas/query2.json' },
-            ],
-          },
-        },
-        dependencies: { modules: [] },
-        env: [],
-      }),
-    );
-    writeAppFile(app.appDir, 'packages/provider-multi/schemas/query.json', JSON.stringify(schemas.joycity1));
-    writeAppFile(app.appDir, 'packages/provider-multi/schemas/query2.json', JSON.stringify(schemas.joycity2));
-    writeAppFile(app.appDir, 'config/schemas/ok.json', JSON.stringify(schemas.ok));
-    writeAppFile(
-      app.appDir,
-      'packages/module-parking/tbox.module.json',
-      JSON.stringify({
-        schemaVersion: 1,
-        id: 'module-parking',
-        version: '0.1.0',
-        kind: 'business',
-        declare: { owns: [{ service: 'parking.query' }], consumes: [{ service: 'parking.query', optional: false }] },
-        dependencies: { modules: [] },
-        env: [],
-      }),
-    );
-    return { app, tk: createAppToolkit(app.appDir), schemas };
-  }
-
-  /** integrations.json 单次写入（每用例独立 harness——零缓存串扰） */
-  function writeIntegrations(appDir: string, config: Record<string, unknown>): void {
-    writeAppFile(appDir, 'config/integrations.json', JSON.stringify(config));
-  }
-
   it('E1 显式 string + catalog schema（分支②）', async () => {
     const h = eHarness();
     writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
@@ -1287,6 +1400,170 @@ describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
   });
 });
 
+/**
+ * v5.1 D39 测试族（服务轴向假想绑定——?serviceProvider= 表单双投影重定向）。
+ * 供给矩阵（eHarness）：wanda 供给 {parking.query, parking.payment}；joycity 仅供给
+ * {parking.query}（provider-multi 双 impl 皆 query）——用例 (厂商 × 服务) 选型须对照本矩阵：
+ * catalog-miss 形态（D39-7）与豁免链正例（D39-6）不得混淆供给边界。每用例独立 eHarness
+ * （零 file-cache stat 指纹串扰）；D39-8/D39-9 用 layerHarness（x-tbox-global 标记 fixture）。
+ */
+describe('v5.1 D39（服务轴向假想绑定 serviceProvider）', () => {
+  it('D39-1 假想 happy + I1：双投影切 joycity 且 provider 一致 + 单键边界正例', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const both = ['integrationSchemas', 'integrationFieldRegistry'];
+    const v = await h.tk.loadService('parking.query', { include: both, serviceProvider: 'joycity' });
+    // I1：双投影同源同口径（fields = joycity schema 字段——catalog 复合键声明序首个 = @1 的 joycityUrl）
+    expect(v.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h.schemas.joycity1 });
+    expect(v.integrationFieldRegistry?.provider).toBe('joycity');
+    expect(v.integrationFieldRegistry!.fields.map((f) => f.key)).toEqual(['joycityUrl']);
+    // 单键边界正例：仅 integrationSchemas + 轴参 → 200 假想计算；registry 未请求 = 缺席（S7-1 尾部先例）
+    const only = await h.tk.loadService('parking.query', { include: ['integrationSchemas'], serviceProvider: 'joycity' });
+    expect(only.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h.schemas.joycity1 });
+    expect('integrationFieldRegistry' in only).toBe(false);
+    h.app.dispose();
+  });
+
+  it('D39-2 I2 锁：integration/suppliedBy/defaults 恒实际态', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda', config: { baseUrl: 'https://w.example' } } } });
+    const base = await h.tk.loadService('parking.query');
+    const v = await h.tk.loadService('parking.query', { include: ['integrationSchemas', 'integrationFieldRegistry'], serviceProvider: 'joycity' });
+    expect(v.integration).toEqual(base.integration); // 文件逐字原值不被重定向（预览不产生「已保存」误导）
+    expect(v.suppliedBy).toEqual(base.suppliedBy); // catalog 静态切片恒实际
+    expect(v.defaults).toEqual(base.defaults); // manifest 预填恒实际
+    expect(v.integrationSchemas?.provider).toBe('joycity'); // 对照：表单层已重定向
+    h.app.dispose();
+  });
+
+  it('D39-3 I3 锁 + 错轴静默忽略：空串 ≡ 缺席 ≡ 实际；appProvider/moduleProvider 被无视', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const empty = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'], serviceProvider: '' });
+    const absent = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'] });
+    expect(empty.integrationFieldRegistry).toEqual(absent.integrationFieldRegistry);
+    // 错轴参数（变量绕过多余属性检查——运行时按名读取，appProvider/moduleProvider 被无视；S7-4 先例镜像）
+    const opts = { include: ['integrationFieldRegistry'], serviceProvider: '', appProvider: 'joycity', moduleProvider: 'joycity' };
+    const wrongAxis = await h.tk.loadService('parking.query', opts);
+    expect(wrongAxis.integrationFieldRegistry).toEqual(absent.integrationFieldRegistry);
+    h.app.dispose();
+  });
+
+  it('D39-4 轴参严检矩阵：400 先于 404（镜像 S7-1 形态）', async () => {
+    const h = eHarness();
+    await expect(h.tk.loadService('parking.query', { serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['serviceProvider'],
+    });
+    await expect(h.tk.loadService('parking.query', { include: [], serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['serviceProvider'],
+    });
+    // 先于 404：ghost 服务 + 无表单键轴参 → 400（非 SERVICE_NOT_FOUND）；表单键在场 → 放行至 404
+    await expect(h.tk.loadService('ghost', { serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['serviceProvider'],
+    });
+    await expect(h.tk.loadService('ghost', { include: ['integrationSchemas'], serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'SERVICE_NOT_FOUND', httpStatus: 404,
+    });
+    h.app.dispose();
+  });
+
+  it('D39-5 同构承诺锁：假想 ≡ PUT 改写 provider 后实读（双投影；S6 写通道先例）', async () => {
+    const h = eHarness();
+    const both = ['integrationSchemas', 'integrationFieldRegistry'];
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const hyp = await h.tk.loadService('parking.query', { include: both, serviceProvider: 'joycity' });
+    // 状态演进全经 toolkit 写通道——写后本实例缓存即刻失效，免外部写缓存关注
+    const cur = await h.tk.loadService('parking.query');
+    const w = await h.tk.writeServiceIntegration('parking.query', { ...cur.integration!, provider: 'joycity' });
+    expect(w.written).toBe(true);
+    const act = await h.tk.loadService('parking.query', { include: both });
+    expect(act.integrationSchemas).toEqual(hyp.integrationSchemas);
+    expect(act.integrationFieldRegistry).toEqual(hyp.integrationFieldRegistry);
+    h.app.dispose();
+  });
+
+  it('D39-6 假想豁免链三分支：malformed 不污染 / 内联不读取无 H9 / 未绑定仍非 null', async () => {
+    // ① malformed 节点（E14 形态）+ 假想 → 非 null（短路在节点读取之前——坏形态只影响实际态投影）
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      modules: { 'module-parking': { provider: 'wanda' } },
+      services: { 'parking.query': { provider: { provider: 'my-api' } } },
+    });
+    const bad = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'], serviceProvider: 'joycity' });
+    expect(bad.integrationFieldRegistry).not.toBeNull();
+    expect(bad.integrationFieldRegistry!.provider).toBe('joycity');
+    // 实际态对照：同坏节点无轴参 → 整字段 null（E14 双态互证——预览与坏文件解耦）
+    const badActual = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(badActual.integrationSchemas).toBeNull();
+    h.app.dispose();
+    // ② 内联 ref 逃逸节点（E4 形态）+ 假想 → 无 H9 400（短路不读节点内联 ref——换厂商即离开内联）
+    const h2 = eHarness();
+    writeIntegrations(h2.app.appDir, {
+      services: { 'parking.query': { provider: { provider: 'my-api', credentialType: '-', configSchema: 'config/schemas-evil/x.json' } } },
+    });
+    const inline = await h2.tk.loadService('parking.query', { include: ['integrationSchemas'], serviceProvider: 'joycity' });
+    expect(inline.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h2.schemas.joycity1 });
+    h2.app.dispose();
+    // ③ 全链未绑定（E8 形态）+ 假想 → 仍非 null（服务轴恒可写——无 module 轴零归属豁免形态）；
+    //    wanda 供给 payment（供给矩阵）→ mallId 字段在场
+    const h3 = eHarness();
+    writeIntegrations(h3.app.appDir, { services: { 'parking.payment': {} } });
+    const unbound = await h3.tk.loadService('parking.payment', { include: ['integrationFieldRegistry'], serviceProvider: 'wanda' });
+    // fields[].schema = 字段子 schema（非整文件 schema——G 批锁 :1777 同型）
+    expect(unbound.integrationFieldRegistry).toEqual({
+      provider: 'wanda', schemaless: [], unsupplied: [], additionalPropertiesAllowed: true,
+      fields: [{ key: 'mallId', schema: { type: 'string' }, sources: [{ service: 'parking.payment', required: false }], global: false }],
+    });
+    h3.app.dispose();
+  });
+
+  it('D39-7 catalog miss：假想未知厂商 → 非 null 空集（schemaless=[service]）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const v = await h.tk.loadService('parking.query', { include: ['integrationSchemas', 'integrationFieldRegistry'], serviceProvider: 'ghost-vendor' });
+    expect(v.integrationSchemas).toEqual({ provider: 'ghost-vendor', configSchema: null });
+    expect(v.integrationFieldRegistry).toEqual({
+      provider: 'ghost-vendor', schemaless: ['parking.query'], unsupplied: [], additionalPropertiesAllowed: true, fields: [],
+    });
+    h.app.dispose();
+  });
+
+  it('D39-8 global 旗标假想透传：标记位如实（layerHarness——true 正例 + 未标记 false 不过滤）', async () => {
+    const h = layerHarness();
+    // joycity 供给 parking.query → 假想后 fields = joycity query schema 字段（fixture 全标记 → global:true）
+    const joy = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'], serviceProvider: 'joycity' });
+    expect(joy.integrationFieldRegistry!.provider).toBe('joycity');
+    expect(joy.integrationFieldRegistry!.fields.length).toBeGreaterThan(0);
+    expect(joy.integrationFieldRegistry!.fields.every((f) => f.global)).toBe(true);
+    // wanda 供给 parking.payment → mallId global:true / parkLotId global:false 在场（服务轴不过滤——G 批语义假想不变）；
+    // payment 先配置入词汇（P9：契约包 ∪ 已配置——layerHarness 初始 integrations.json 未配置 payment；
+    // 覆盖写后 payment 节点 {} 实际态级联双缺 → null，假想 wanda 短路仍非 null——豁免链③同型，S7-7 外部写先例）
+    writeAppFile(h.app.appDir, 'config/integrations.json', JSON.stringify({ services: { 'parking.payment': {} } }));
+    const wan = await h.tk.loadService('parking.payment', { include: ['integrationFieldRegistry'], serviceProvider: 'wanda' });
+    expect(wan.integrationFieldRegistry!.fields.map((f) => f.key).sort()).toEqual(['mallId', 'parkLotId']);
+    expect(wan.integrationFieldRegistry!.fields.find((f) => f.key === 'mallId')!.global).toBe(true);
+    expect(wan.integrationFieldRegistry!.fields.find((f) => f.key === 'parkLotId')!.global).toBe(false);
+    h.app.dispose();
+  });
+
+  it('D39-9 单源锁：loadServiceFieldRegistry(snap,s,X) ≡ buildIntegrationFieldRegistry over 链函数', async () => {
+    const h = layerHarness();
+    const { loadViewSnapshotSync } = await import('../src/views/context.js');
+    const snap = loadViewSnapshotSync({ appDir: h.app.appDir }, await h.tk.resolveContracts());
+    const X = 'joycity';
+    const reg = loadServiceFieldRegistry(snap, 'parking.query', X);
+    const schemas = loadServiceIntegrationSchemas(snap, 'parking.query', X);
+    expect(schemas).not.toBeNull();
+    // 结构性断言（依赖契约锁——registry 旁路重取 schema 破 I1 即刻红；S8 同族意图）
+    const manual = buildIntegrationFieldRegistry({
+      provider: schemas!.provider,
+      services: { 'parking.query': { configSchema: schemas!.configSchema } },
+    });
+    expect(reg).toEqual(manual);
+    h.app.dispose();
+  });
+});
+
 /**
  * v4.6 D36/D37 测试族（S5 接续 S1-S4）：S5a 纯代数（直调合成 layer 字面量，零 fs）/
  * S5b 接线序 + 等价锁 / S6 同构（假想 ≡ 写后实读）/ S7 边界（400·null 两态·I2·空集）/
@@ -1891,6 +2168,46 @@ describe('B1 展示名链', () => {
     h2.app.dispose();
   });
 
+  it('T2b loadModulesView：hidden 模块默认过滤；includeHidden 可见 + 徽标；detail 恒 200 不滤', async () => {
+    const app = createTempApp('tbox-hidden-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    const manifest = (id: string, name: string, extra: Record<string, unknown> = {}): string =>
+      JSON.stringify({
+        schemaVersion: 1,
+        id,
+        version: '0.1.0',
+        kind: 'business',
+        name,
+        declare: { owns: [], consumes: [] },
+        dependencies: { modules: [] },
+        env: [],
+        ...extra,
+      });
+    mkdirSync(join(app.appDir, 'packages', 'module-visible'), { recursive: true });
+    writeAppFile(app.appDir, 'packages/module-visible/tbox.module.json', manifest('module-visible', '可见模块'));
+    mkdirSync(join(app.appDir, 'packages', 'module-secret'), { recursive: true });
+    writeAppFile(app.appDir, 'packages/module-secret/tbox.module.json', manifest('module-secret', '隐藏模块', { hidden: true }));
+
+    const tk = createAppToolkit(app.appDir);
+    // 默认：hidden 模块不进清单（可见模块无 hidden 键——additive 纪律）
+    const def = await tk.loadModules();
+    expect(def.modules.map((m) => m.id)).toEqual(['module-visible']);
+    expect(def.modules[0]).not.toHaveProperty('hidden');
+    // includeHidden = true：可见并携带 hidden: true 徽标
+    const inc = await tk.loadModules({ includeHidden: true });
+    expect(inc.modules.map((m) => m.id).sort()).toEqual(['module-secret', 'module-visible']);
+    expect(inc.modules.find((m) => m.id === 'module-secret')?.hidden).toBe(true);
+    expect(inc.modules.find((m) => m.id === 'module-visible')).not.toHaveProperty('hidden');
+    // detail 端点恒 200 不滤——视图携带 hidden 徽标
+    const detail = await tk.loadModule('module-secret');
+    expect(detail.name).toBe('隐藏模块');
+    expect(detail.hidden).toBe(true);
+    app.dispose();
+  });
+
   it('T3 loadModuleDetailView：meta 恒发；services[] 词汇优先（demand 车位查询被词汇停车查询压过——防漂移锁）', async () => {
     const h2 = displayHarness();
     const v = await h2.tk.loadModule('module-parking');