@tbox.cn/app-toolkit 0.2.0 → 0.4.0

package/tests/views.test.ts

@@ -4,6 +4,10 @@ import { mkdirSync, readFileSync, symlinkSync } from 'node:fs';
 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 } 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';
 import { createTempApp, writeFakeContractsPackage, linkContracts, writeAppFile, type TempApp } from './demo-app.js';
 
@@ -76,6 +80,159 @@ function mkdirDeep(dir: string): void {
   mkdirSync(dir, { recursive: true });
 }
 
+/** v4.4/v4.6 层级 schema 测试基座（模块作用域共享——S 系列 + D36/D37 族）：wanda 供给两服务
+ *  （单域 schema 文件）+ module-parking 单域双 demand。v4.6 additive：joycity 三 slot
+ *  （query/payment 双 schema 同 type 部分重叠 + 冲突 key 全分支样本 + vehicle 无 schema）+
+ *  partial 单 slot 无 schema——slot 不进 catalog.services（owners 仅 demand 触发）→ 既有断言键零触碰。 */
+function layerHarness(): {
+  app: TempApp;
+  tk: AppToolkit;
+  schemas: { query: object; parking: object };
+  joycity: { query: object; payment: object };
+} {
+  const app = createTempApp('tbox-v44-');
+  invalidateContractsResolver();
+  const store = joinStore(app.appDir, 'contracts');
+  writeFakeContractsPackage(store, {
+    version: '0.9.0',
+    resolveBody: [
+      'const slot = integrations && integrations.services && integrations.services[service];',
+      'if (!slot) return { status: "service-not-configured" };',
+      'const prov = typeof slot.provider === "string" ? slot.provider : slot.provider && slot.provider.provider;',
+      'if (!prov) return { status: "service-not-configured" };',
+      'return { status: "ok", effective: { provider: prov, implementation: slot.implementation || "impl@1", config: slot.config || {} } };',
+    ].join(' '),
+  });
+  linkContracts(app.appDir, store, { subdir: 'apps/server' });
+  const schemas = {
+    query: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
+    parking: { type: 'object', properties: { mallId: { type: 'string' } } },
+  };
+  // v4.6 joycity 代数 fixture：R1（baseUrl 双无 enum / env 同集异序 / envMixed 混布）/
+  // R2（options 深相等 / meta 异构）/ R3（lotId string≠integer / timeout number≠integer / untyped 无 type）/
+  // required 聚合（query [baseUrl,lotId] / payment [apiKey,options]）+ payment 属性序 apiKey 先在（双轴序判别）
+  const joycity = {
+    query: {
+      type: 'object',
+      properties: {
+        baseUrl: { type: 'string', format: 'uri' },
+        lotId: { type: 'string' },
+        env: { type: 'string', enum: ['dev', 'staging', 'prod'] },
+        envMixed: { type: 'string', enum: ['a', 'b'] },
+        meta: { type: 'object', properties: { region: { type: 'string' } } },
+        options: { type: 'object', properties: { x: { type: 'string' } } },
+        untyped: { description: 'x' },
+        timeout: { type: 'number' },
+      },
+      required: ['baseUrl', 'lotId'],
+    },
+    payment: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        apiKey: { type: 'string' },
+        baseUrl: { type: 'string' },
+        lotId: { type: 'integer' },
+        env: { type: 'string', enum: ['prod', 'dev', 'staging'] },
+        envMixed: { type: 'string' },
+        meta: { type: 'object', properties: { zone: { type: 'number' } } },
+        options: { type: 'object', properties: { x: { type: 'string' } } },
+        untyped: { type: 'string' },
+        timeout: { type: 'integer' },
+      },
+      required: ['apiKey', 'options'],
+    },
+  };
+  writeAppFile(
+    app.appDir,
+    'packages/provider-w/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      name: 'provider-w',
+      version: '0.1.0',
+      kind: 'business',
+      contributes: {
+        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.query));
+  writeAppFile(app.appDir, 'packages/provider-w/schemas/parking.json', JSON.stringify(schemas.parking));
+  // v4.6：provider-j（joycity——vehicle 无 configSchema：app 轴 schemaless / module 轴作用域差）+ provider-p（partial）
+  writeAppFile(
+    app.appDir,
+    'packages/provider-j/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      name: 'provider-j',
+      version: '0.1.0',
+      kind: 'business',
+      contributes: {
+        providers: {
+          slots: [
+            { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/query.json' },
+            { service: 'parking.payment', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/payment.json' },
+            { service: 'parking.vehicle', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c' },
+          ],
+        },
+      },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(app.appDir, 'packages/provider-j/schemas/query.json', JSON.stringify(joycity.query));
+  writeAppFile(app.appDir, 'packages/provider-j/schemas/payment.json', JSON.stringify(joycity.payment));
+  writeAppFile(
+    app.appDir,
+    'packages/provider-p/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      name: 'provider-p',
+      version: '0.1.0',
+      kind: 'business',
+      contributes: {
+        providers: {
+          slots: [{ service: 'parking.payment', provider: 'partial', implementation: 'partial-payment@1', credentialType: 'partial-c' }],
+        },
+      },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(
+    app.appDir,
+    'packages/module-parking/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      name: 'module-parking',
+      version: '0.1.0',
+      kind: 'business',
+      contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'parking.payment', optional: true }] },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(
+    app.appDir,
+    'config/integrations.json',
+    JSON.stringify({
+      provider: 'wanda',
+      instances: [{ id: 'mall-bj-01', name: '北京店' }],
+      defaultInstanceId: 'mall-bj-01',
+      domains: { parking: { provider: 'wanda' } },
+      services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
+    }),
+  );
+  return { app, tk: createAppToolkit(app.appDir), schemas, joycity };
+}
+
 describe('views/工厂（O 矩阵核心族）', () => {
   let h: Harness;
 
@@ -102,7 +259,8 @@ describe('views/工厂（O 矩阵核心族）', () => {
     expect(Object.keys(appView)).toEqual(['services', 'integration']);
     const mod = await h.tk.loadModule('module-parking');
     // v4.4 D34：domainKeys/providerBindings/configEditable 显式化（include 两键可选缺席——F4）
-    expect(Object.keys(mod)).toEqual(['domainKeys', 'integration', 'providerBindings', 'configEditable', 'services']);
+    // B1 additive：模块 meta title/description 前置（恒发——兜底 name/''）
+    expect(Object.keys(mod)).toEqual(['title', 'description', 'domainKeys', 'integration', 'providerBindings', '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 反例联动）
@@ -123,7 +281,7 @@ describe('views/工厂（O 矩阵核心族）', () => {
   });
 
   it('O3 键集 = 服务词汇 ∪ 已配置；required echo（OR 聚合 + 平台 false）', async () => {
-    // vocabulary 空（无契约包 fixture）→ 键集 = 已配置（parking.query + auth.alipay-login）
+    // vocabulary 空（无契约包 fixture 物化 slots——退化态回归锁；词汇在场态见 B1 族 T-O3）
     const batch = await h.tk.loadServiceResolutions();
     expect(Object.keys(batch.resolutions).sort()).toEqual(['auth.alipay-login', 'parking.query']);
     // parking.query 由 module-parking demand required:0 → required true
@@ -200,15 +358,15 @@ describe('views/工厂（O 矩阵核心族）', () => {
     expect(reread.integration).toEqual(node);
   });
 
-  it('no-diff 深度等价 → written:false + restartScheduled:false；dryRun files 恒 []', async () => {
+  it('no-diff 深度等价 → written:false + restartScheduled:false；dryRun+diff files = 将触碰预览（D35）', async () => {
     const svc = await h.tk.loadService('parking.query');
     const result = await h.tk.writeServiceIntegration('parking.query', svc.integration ?? {});
     expect(result.written).toBe(false);
     expect(result.restartScheduled).toBe(false);
-    // dryRun：复读管线不落盘
+    // dryRun：复读管线不落盘；body（{provider:'mock'}）与现值（inline custom API）实为 diff → files 预览
     const dry = await h.tk.writeServiceIntegration('parking.query', { provider: 'mock' }, { dryRun: true });
     expect(dry.written).toBe(false);
-    expect(dry.files).toEqual([]);
+    expect(dry.files).toEqual(['config/integrations.json']);
   });
 
   it('写时自动初始化（R13 语义翻转提示）+ N1 清域（模块 {} 删域键）', async () => {
@@ -598,75 +756,6 @@ describe('D34 多域模块钉死（v4.4 F3）', () => {
 });
 
 describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
-  /** 层级 schema 测试基座：wanda 供给两服务（单域 schema 文件）+ module-parking 单域双 demand */
-  function layerHarness(): { app: TempApp; tk: AppToolkit; schemas: { query: object; parking: object } } {
-    const app = createTempApp('tbox-v44-');
-    invalidateContractsResolver();
-    const store = joinStore(app.appDir, 'contracts');
-    writeFakeContractsPackage(store, {
-      version: '0.9.0',
-      resolveBody: [
-        'const slot = integrations && integrations.services && integrations.services[service];',
-        'if (!slot) return { status: "service-not-configured" };',
-        'const prov = typeof slot.provider === "string" ? slot.provider : slot.provider && slot.provider.provider;',
-        'if (!prov) return { status: "service-not-configured" };',
-        'return { status: "ok", effective: { provider: prov, implementation: slot.implementation || "impl@1", config: slot.config || {} } };',
-      ].join(' '),
-    });
-    linkContracts(app.appDir, store, { subdir: 'apps/server' });
-    const schemas = {
-      query: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
-      parking: { type: 'object', properties: { mallId: { type: 'string' } } },
-    };
-    writeAppFile(
-      app.appDir,
-      'packages/provider-w/tbox.module.json',
-      JSON.stringify({
-        schemaVersion: 1,
-        name: 'provider-w',
-        version: '0.1.0',
-        kind: 'business',
-        contributes: {
-          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.query));
-    writeAppFile(app.appDir, 'packages/provider-w/schemas/parking.json', JSON.stringify(schemas.parking));
-    writeAppFile(
-      app.appDir,
-      'packages/module-parking/tbox.module.json',
-      JSON.stringify({
-        schemaVersion: 1,
-        name: 'module-parking',
-        version: '0.1.0',
-        kind: 'business',
-        contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'parking.payment', optional: true }] },
-        dependencies: { modules: [] },
-        env: [],
-      }),
-    );
-    writeAppFile(
-      app.appDir,
-      'config/integrations.json',
-      JSON.stringify({
-        provider: 'wanda',
-        instances: [{ id: 'mall-bj-01', name: '北京店' }],
-        defaultInstanceId: 'mall-bj-01',
-        domains: { parking: { provider: 'wanda' } },
-        services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
-      }),
-    );
-    return { app, tk: createAppToolkit(app.appDir), schemas };
-  }
-
   it('I1 include 正例：app/module 双键内嵌 + 未请求缺席（内嵌三律）+ issues 恒全量', async () => {
     const h2 = harnessWithContracts();
     const appInc = await h2.tk.loadApp({ include: ['serviceResolutions', 'integrationSchemas'] });
@@ -829,3 +918,938 @@ describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
     app.dispose();
   });
 });
+
+describe('模块清单 provider 家族排除（2026-09-16 双缺陷批——供给/实施载体非可配置业务模块）', () => {
+  /** 夹具基座 = harnessWithContracts（module-parking 业务模块）+ provider-custom
+   *  （channel 2 零贡献空壳——模板出厂真实形态）+ vendor-mock（channel 1 sdk 登记且
+   *  id 无家族前缀 + pkg 有——pkg basename 判定分支独测钉，防实现退化只查 id） */
+  function providerHarness(): Harness {
+    const h = harnessWithContracts();
+    writeAppFile(
+      h.app.appDir,
+      'packages/provider-custom/tbox.module.json',
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'provider-custom',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: { providers: { slots: [] }, services: [] },
+        dependencies: { modules: [] },
+        env: [],
+      }),
+    );
+    writeAppFile(
+      h.app.appDir,
+      join('.tbox', 'app.json'),
+      JSON.stringify({
+        templateVersion: 'test',
+        npmModules: [{ id: 'vendor-mock', package: '@tbox.cn/app-provider-mock', version: '0.2.0', mode: 'sdk' }],
+      }),
+    );
+    writeAppFile(
+      h.app.appDir,
+      join('node_modules', '@tbox.cn', 'app-provider-mock', 'tbox.module.json'),
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'provider-mock',
+        contributes: {
+          providers: { slots: [{ service: 'parking.query', provider: 'mock', implementation: 'mock-parking@1', credentialType: '-' }] },
+        },
+      }),
+    );
+    return h;
+  }
+
+  it('清单排除 provider 家族包（双通道 + id/pkg 漂移）；walk 声明集不变量 + 详情 200 + 供给轴保持', async () => {
+    const h2 = providerHarness();
+    // 清单排除：仅业务模块（provider-custom 经 id 判定；vendor-mock 经 pkg basename 判定——id 漂移形态）
+    const view = await h2.tk.loadModules();
+    expect(view.modules.map((m) => m.id)).toEqual(['module-parking']);
+    // walk 不变量：声明集仍含双 provider（predicate / 平台服务占用 / CLI 装配消费面依赖 provider 在内）
+    const walk = walkManifests(h2.app.appDir);
+    expect(walk.modules.map((m) => m.id).sort()).toEqual(['module-parking', 'provider-custom', 'vendor-mock']);
+    // 详情 200 保持（装包仍合法——零域空态；写通道零域由 D34 守卫拦）
+    const custom = await h2.tk.loadModule('provider-custom');
+    expect(custom.domainKeys).toEqual([]);
+    expect(custom.configEditable).toBe(false);
+    expect(custom.services).toEqual([]);
+    const mock = await h2.tk.loadModule('vendor-mock');
+    expect(mock.domainKeys).toEqual([]);
+    // 供给轴不受影响：provider-mock 槽位照常进 catalog（清单排除不伤聚合）
+    const providers = await h2.tk.loadProviders();
+    expect(providers.providers.map((p) => p.provider)).toContain('mock');
+    h2.app.dispose();
+  });
+});
+
+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,
+        name: 'provider-w',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: {
+          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,
+        name: 'provider-multi',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: {
+          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,
+        name: 'module-parking',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: { services: [{ 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' } } });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'wanda', configSchema: h.schemas.wQuery });
+    h.app.dispose();
+  });
+
+  it('E2 多 impl 钉版不影响 schema（§4.9 升级窗口——解析自默认 impl = 声明序首个）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      services: { 'parking.query': { provider: 'joycity', implementation: 'joycity-parking@2' } },
+    });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    // 钉版 @2 不影响 schema——复合键取声明序首个（@1 的 query.json；与组合单体同源同判）
+    expect(view.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h.schemas.joycity1 });
+    h.app.dispose();
+  });
+
+  it('E3 受控内联 + ref（分支③）；catalog > 内联 ref 优先级', async () => {
+    // ① catalog miss → 内联 ref（config/schemas/ok.json）
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      services: {
+        'parking.query': {
+          provider: { provider: 'my-api', credentialType: '-', configSchema: 'config/schemas/ok.json' },
+          implementation: 'my-api-parking@1',
+        },
+      },
+    });
+    const inline = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(inline.integrationSchemas).toEqual({ provider: 'my-api', configSchema: h.schemas.ok });
+    // ② 内联名命中 catalog → catalog 胜出（组合单体同判）
+    const h2 = eHarness();
+    writeIntegrations(h2.app.appDir, {
+      services: {
+        'parking.query': { provider: { provider: 'wanda', credentialType: '-', configSchema: 'config/schemas/ok.json' } },
+      },
+    });
+    const hit = await h2.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(hit.integrationSchemas).toEqual({ provider: 'wanda', configSchema: h2.schemas.wQuery });
+    h.app.dispose();
+    h2.app.dispose();
+  });
+
+  it('E4 内联 ref 路径逃逸 → 400（H9 共享路径复测——lexical 形态）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      services: {
+        'parking.query': { provider: { provider: 'my-api', credentialType: '-', configSchema: 'config/schemas-evil/x.json' } },
+      },
+    });
+    await expect(h.tk.loadService('parking.query', { include: ['integrationSchemas'] })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED',
+      httpStatus: 400,
+    });
+    h.app.dispose();
+  });
+
+  it('E5 bare 未知厂商 → { provider, configSchema: null } 不 404（富化非门控）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'nope-vendor' } } });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'nope-vendor', configSchema: null });
+    h.app.dispose();
+  });
+
+  it('E6 域级联（分支①）+ ghost 域厂商诚实态', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { domains: { parking: { provider: 'wanda' } }, services: { 'parking.query': {} } });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'wanda', configSchema: h.schemas.wQuery });
+    // ghost 域厂商（catalog 外）→ configSchema null（诊断归谓词 #11——富化非门控）
+    const h2 = eHarness();
+    writeIntegrations(h2.app.appDir, { domains: { parking: { provider: 'ghost-vendor' } }, services: { 'parking.query': {} } });
+    const ghost = await h2.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(ghost.integrationSchemas).toEqual({ provider: 'ghost-vendor', configSchema: null });
+    h.app.dispose();
+    h2.app.dispose();
+  });
+
+  it('E7 root 级联（分支①）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { provider: 'wanda', services: { 'parking.query': {} } });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'wanda', configSchema: h.schemas.wQuery });
+    h.app.dispose();
+  });
+
+  it('E8 全链未绑定 → 整字段 null', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.payment': {} } });
+    const view = await h.tk.loadService('parking.payment', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toBeNull();
+    h.app.dispose();
+  });
+
+  it('E9 实例层无条件排除（链仍走 root/域）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      provider: 'wanda',
+      services: { 'parking.query': { instances: { 'mall-1': { provider: 'joycity' } } } },
+    });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'wanda', configSchema: h.schemas.wQuery });
+    h.app.dispose();
+  });
+
+  it('E10 未请求 = 缺席（缺省零富化键）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const view = await h.tk.loadService('parking.query');
+    expect('integrationSchemas' in view).toBe(false);
+    h.app.dispose();
+  });
+
+  it('E11 未知 include 键 → 400 先于 404', async () => {
+    const h = eHarness();
+    await expect(h.tk.loadService('ghost', { include: ['bogus'] })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED',
+      httpStatus: 400,
+      fields: ['include'],
+    });
+    h.app.dispose();
+  });
+
+  it('E12 include + 未知服务 → 404 SERVICE_NOT_FOUND', async () => {
+    const h = eHarness();
+    await expect(h.tk.loadService('ghost', { include: ['integrationSchemas'] })).rejects.toMatchObject({
+      code: 'SERVICE_NOT_FOUND',
+      httpStatus: 404,
+    });
+    h.app.dispose();
+  });
+
+  it('E13 受控内联无 ref → { provider, configSchema: null }', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      services: { 'parking.query': { provider: { provider: 'my-api', credentialType: '-' }, implementation: 'x@1' } },
+    });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'my-api', configSchema: null });
+    h.app.dispose();
+  });
+
+  it('E14 malformed → 整字段 null（不落域级联——分支回归锚）', async () => {
+    // ① 坏对象（缺 credentialType）——配 domains 佐证未走域级联
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      domains: { parking: { provider: 'wanda' } },
+      services: { 'parking.query': { provider: { provider: 'my-api' } } },
+    });
+    const bad = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(bad.integrationSchemas).toBeNull();
+    // ② provider: null（谓词 #5 同判 INLINE_PROVIDER_INVALID——坏形态非缺席）
+    const h2 = eHarness();
+    writeIntegrations(h2.app.appDir, {
+      domains: { parking: { provider: 'wanda' } },
+      services: { 'parking.query': { provider: null } },
+    });
+    const nul = await h2.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(nul.integrationSchemas).toBeNull();
+    h.app.dispose();
+    h2.app.dispose();
+  });
+
+  it('E15 provider 空串 → 走域级联（非 null）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      domains: { parking: { provider: 'wanda' } },
+      services: { 'parking.query': { provider: '' } },
+    });
+    const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(view.integrationSchemas).toEqual({ provider: 'wanda', configSchema: h.schemas.wQuery });
+    h.app.dispose();
+  });
+});
+
+/**
+ * v4.6 D36/D37 测试族（S5 接续 S1-S4）：S5a 纯代数（直调合成 layer 字面量，零 fs）/
+ * S5b 接线序 + 等价锁 / S6 同构（假想 ≡ 写后实读）/ S7 边界（400·null 两态·I2·空集）/
+ * S8 双投影互证（依赖契约锁——旁路重取 serviceSchemas 破 S8-2/S8-3 即刻红）。
+ */
+describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () => {
+  /** sources 单元 */
+  const src = (service: string, required: boolean): { service: string; required: boolean } => ({ service, required });
+
+  /** E1：module 轴 moduleProvider=joycity（scope = demand 序 [query, payment]） */
+  const E1 = {
+    provider: 'joycity',
+    schemaless: [],
+    unsupplied: [],
+    additionalPropertiesAllowed: false,
+    fields: [
+      { key: 'baseUrl', schema: { type: 'string', format: 'uri' }, sources: [src('parking.query', true), src('parking.payment', false)] },
+      { key: 'lotId', schema: null, sources: [src('parking.query', true), src('parking.payment', false)] },
+      { key: 'env', schema: { type: 'string', enum: ['dev', 'staging', 'prod'] }, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'envMixed', schema: null, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'meta', schema: null, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'options', schema: { type: 'object', properties: { x: { type: 'string' } } }, sources: [src('parking.query', false), src('parking.payment', true)] },
+      { key: 'untyped', schema: null, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'timeout', schema: null, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'apiKey', schema: { type: 'string' }, sources: [src('parking.payment', true)] },
+    ],
+  };
+
+  /** E2：app 轴 appProvider=joycity（scope = 足迹字母序 [payment, query, vehicle]——序判别 + 首源漂移） */
+  const E2 = {
+    provider: 'joycity',
+    schemaless: ['parking.vehicle'],
+    unsupplied: [],
+    additionalPropertiesAllowed: false,
+    fields: [
+      { key: 'apiKey', schema: { type: 'string' }, sources: [src('parking.payment', true)] },
+      { key: 'baseUrl', schema: { type: 'string' }, sources: [src('parking.payment', false), src('parking.query', true)] },
+      { key: 'lotId', schema: null, sources: [src('parking.payment', false), src('parking.query', true)] },
+      { key: 'env', schema: { type: 'string', enum: ['prod', 'dev', 'staging'] }, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'envMixed', schema: null, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'meta', schema: null, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'options', schema: { type: 'object', properties: { x: { type: 'string' } } }, sources: [src('parking.payment', true), src('parking.query', false)] },
+      { key: 'untyped', schema: null, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'timeout', schema: null, sources: [src('parking.payment', false), src('parking.query', false)] },
+    ],
+  };
+
+  /** E3：module 轴 moduleProvider=partial（scope=[payment]，schemaless + 部分 unsupplied 四合一） */
+  const E3 = { provider: 'partial', schemaless: ['parking.payment'], unsupplied: ['parking.query'], additionalPropertiesAllowed: true, fields: [] };
+
+  /** E4：module 轴 moduleProvider=ghost-x（未知厂商——非 null 空集 + 全 demand 回填，demand 序） */
+  const E4 = { provider: 'ghost-x', schemaless: [], unsupplied: ['parking.query', 'parking.payment'], additionalPropertiesAllowed: true, fields: [] };
+
+  /** E5：实际态（无轴参，wanda；scope = [query, payment]） */
+  const E5 = {
+    provider: 'wanda',
+    schemaless: [],
+    unsupplied: [],
+    additionalPropertiesAllowed: true,
+    fields: [
+      { key: 'baseUrl', schema: { type: 'string', format: 'uri' }, sources: [src('parking.query', true)] },
+      { key: 'mallId', schema: { type: 'string' }, sources: [src('parking.payment', false)] },
+    ],
+  };
+
+  // ── S5a 纯代数（直调——合成 layer 字面量，零 fs）──
+  const reg = (services: Record<string, { configSchema: object | null }>, o?: { unsupplied?: string[] }) =>
+    buildIntegrationFieldRegistry({ provider: 'x', services }, o);
+
+  it('S5a-1..4 R1 标量：双无 enum 首源保真 / enum 同集异序 / 异集 / 混布', () => {
+    const both = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'string', format: 'uri', title: 'T' } } } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'string' } } } },
+    });
+    expect(both.fields[0].schema).toEqual({ type: 'string', format: 'uri', title: 'T' }); // 首源逐字保真
+    const sameSet = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'string', enum: ['a', 'b'] } } } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'string', enum: ['b', 'a', 'a'] } } } },
+    });
+    expect(sameSet.fields[0].schema).toEqual({ type: 'string', enum: ['a', 'b'] }); // 序不敏感 + 去重
+    const diffSet = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'string', enum: ['a'] } } } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'string', enum: ['b'] } } } },
+    });
+    expect(diffSet.fields[0].schema).toBeNull();
+    const mixed = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'string', enum: ['a'] } } } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'string' } } } },
+    });
+    expect(mixed.fields[0].schema).toBeNull(); // 混布（哨兵 ≠ 集签名）
+  });
+
+  it('S5a-5/6 R2 object：深相等（键序不敏感）→ 首源；异构 → null', () => {
+    const deep = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'object', properties: { x: { type: 'string' }, y: { type: 'number' } } } } } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'object', properties: { y: { type: 'number' }, x: { type: 'string' } } } } } },
+    });
+    expect(deep.fields[0].schema).toEqual({ type: 'object', properties: { x: { type: 'string' }, y: { type: 'number' } } });
+    const hetero = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'object', properties: { x: { type: 'string' } } } } } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'object', properties: { y: { type: 'string' } } } } } },
+    });
+    expect(hetero.fields[0].schema).toBeNull();
+  });
+
+  it('S5a-7 R3 族：type 不等 / integer≠number / type 缺席 / 布尔子 schema 入列 / type 数组序异', () => {
+    const r3 = reg({
+      'a.one': {
+        configSchema: {
+          type: 'object',
+          properties: {
+            mismatch: { type: 'string' },
+            numeric: { type: 'number' },
+            untypedK: { description: 'x' },
+            boolK: true,
+            typeArr: { type: ['string', 'null'] },
+            objK: { type: 'object', properties: { p: { type: 'string' } } },
+          },
+        },
+      },
+      'a.two': {
+        configSchema: {
+          type: 'object',
+          properties: {
+            mismatch: { type: 'integer' },
+            numeric: { type: 'integer' },
+            untypedK: { type: 'string' },
+            boolK: { type: 'string' },
+            typeArr: { type: ['null', 'string'] },
+            objK: { type: 'object', properties: { q: { type: 'number' } } },
+          },
+        },
+      },
+    });
+    const byKey = Object.fromEntries(r3.fields.map((f) => [f.key, f]));
+    for (const k of ['mismatch', 'numeric', 'untypedK', 'boolK', 'typeArr', 'objK']) {
+      expect(byKey[k]?.schema, k).toBeNull();
+    }
+    expect(byKey.boolK?.sources).toHaveLength(2); // F1：布尔子 schema 照样入列（key 在、sources 在、schema null）
+  });
+
+  it('S5a-8/9 单源直通 + required 聚合（some；conflict 照常聚合）', () => {
+    const single = reg({ 'a.one': { configSchema: { type: 'object', properties: { only: { type: 'string', enum: ['z'] } } } } });
+    expect(single.fields[0]).toEqual({ key: 'only', schema: { type: 'string', enum: ['z'] }, sources: [src('a.one', false)] });
+    const some = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'string' } }, required: ['k'] } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'string' } } } },
+    });
+    expect(some.fields[0].sources).toEqual([src('a.one', true), src('a.two', false)]);
+    const conflictReq = reg({
+      'a.one': { configSchema: { type: 'object', properties: { k: { type: 'string' } }, required: ['k'] } },
+      'a.two': { configSchema: { type: 'object', properties: { k: { type: 'integer' } } } },
+    });
+    expect(conflictReq.fields[0].schema).toBeNull();
+    expect(conflictReq.fields[0].sources.some((s) => s.required)).toBe(true);
+  });
+
+  it('S5a-10/11/12 聚合与装配：apAllowed 四态 / schemaless / unsupplied / 空 scope / 布尔整 schema 防御', () => {
+    expect(reg({ 'a.one': { configSchema: { type: 'object', properties: {} } } }).additionalPropertiesAllowed).toBe(true);
+    expect(reg({ 'a.one': { configSchema: { type: 'object', additionalProperties: false } } }).additionalPropertiesAllowed).toBe(false);
+    expect(reg({}).additionalPropertiesAllowed).toBe(true); // 空真
+    // N4：布尔整 schema 防御——不入 schemaless、零参与、fields 空
+    expect(reg({ 'a.one': { configSchema: true as unknown as object } })).toEqual({
+      provider: 'x', schemaless: [], unsupplied: [], additionalPropertiesAllowed: true, fields: [],
+    });
+    expect(reg({})).toEqual({ provider: 'x', schemaless: [], unsupplied: [], additionalPropertiesAllowed: true, fields: [] });
+    const asm = reg(
+      { 'a.one': { configSchema: null }, 'a.two': { configSchema: { type: 'object', properties: { k: { type: 'string' } } } } },
+      { unsupplied: ['b.x'] },
+    );
+    expect(asm.schemaless).toEqual(['a.one']);
+    expect(asm.unsupplied).toEqual(['b.x']);
+  });
+
+  it('S5a-13 fields 序 = services 迭代序（首声明序 + 首源归序）', () => {
+    const order = reg({
+      'b.second': { configSchema: { type: 'object', properties: { beta: { type: 'string' }, shared: { type: 'string', format: 'uri' } } } },
+      'a.first': { configSchema: { type: 'object', properties: { alpha: { type: 'string' }, shared: { type: 'string' } } } },
+    });
+    expect(order.fields.map((f) => f.key)).toEqual(['beta', 'shared', 'alpha']);
+    expect(order.fields[1].sources.map((s) => s.service)).toEqual(['b.second', 'a.first']);
+    expect(order.fields[1].schema).toEqual({ type: 'string', format: 'uri' }); // 首源 = b.second
+  });
+
+  // ── S5b 接线序 + 等价锁 ──
+  it('S5b-1/2/3 接线：假想双轴 registry 逐字（E1/E2/E3）+ 实际态（E5）+ fields 序判别', async () => {
+    const h2 = layerHarness();
+    const modInc = await h2.tk.loadModule('module-parking', {
+      include: ['integrationSchemas', 'integrationFieldRegistry'],
+      moduleProvider: 'joycity',
+    });
+    expect(modInc.integrationFieldRegistry).toEqual(E1);
+    expect(modInc.integrationSchemas).toEqual({
+      provider: 'joycity',
+      services: { 'parking.query': { configSchema: h2.joycity.query }, 'parking.payment': { configSchema: h2.joycity.payment } },
+    });
+    const appInc = await h2.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'joycity' });
+    expect(appInc.integrationFieldRegistry).toEqual(E2);
+    expect(appInc.integrationFieldRegistry?.fields[0].key).toBe('apiKey'); // 足迹字母序（vs E1 首键 baseUrl）
+    expect(appInc.integrationFieldRegistry?.fields[1].schema).toEqual({ type: 'string' }); // 首源漂移（payment 先）
+    const partial = await h2.tk.loadModule('module-parking', { include: ['integrationFieldRegistry'], moduleProvider: 'partial' });
+    expect(partial.integrationFieldRegistry).toEqual(E3);
+    const actual = await h2.tk.loadModule('module-parking', { include: ['integrationFieldRegistry'] });
+    expect(actual.integrationFieldRegistry).toEqual(E5);
+    h2.app.dispose();
+  });
+
+  it('S5b-4 旧 loader 等价锁：loadModuleIntegrationSchemas ≡ loadModuleFormViews.integrationSchemas', async () => {
+    const h2 = layerHarness();
+    const walk = walkManifests(h2.app.appDir);
+    const snap: ViewSnapshot = {
+      appDir: h2.app.appDir,
+      walk,
+      catalog: walk.catalog,
+      integrations: await h2.tk.readIntegrationsConfig(),
+      contracts: await h2.tk.resolveContracts(),
+    };
+    const viaOld = loadModuleIntegrationSchemas(snap, 'module-parking');
+    expect(viaOld).toEqual(loadModuleFormViews(snap, 'module-parking').integrationSchemas);
+    expect(viaOld).toEqual({
+      provider: 'wanda',
+      services: { 'parking.query': { configSchema: h2.schemas.query }, 'parking.payment': { configSchema: h2.schemas.parking } },
+    });
+    h2.app.dispose();
+  });
+
+  // ── S6 同构（状态演进全经 toolkit 写通道——免外部写缓存关注）──
+  it('S6 同构：假想预览 ≡ 真实写入后实读（含跟随应用级 + config 值无关）', async () => {
+    const h2 = layerHarness();
+    const both = ['integrationSchemas', 'integrationFieldRegistry'];
+    // ① 假想 joycity ≡ 写 {provider:'joycity'} 后实读（双投影）
+    const hypJoy = await h2.tk.loadModule('module-parking', { include: both, moduleProvider: 'joycity' });
+    const w1 = await h2.tk.writeModuleIntegration('module-parking', { provider: 'joycity' });
+    expect(w1.written).toBe(true);
+    const actJoy = await h2.tk.loadModule('module-parking', { include: both });
+    expect(actJoy.integrationFieldRegistry).toEqual(hypJoy.integrationFieldRegistry);
+    expect(actJoy.integrationSchemas).toEqual(hypJoy.integrationSchemas);
+    // ② 跟随应用级（root.provider=wanda）≡ 清域（N1 删 domains.parking → root 兜底）后实读——非平凡：清域前实际态 = E1
+    const hypFollow = await h2.tk.loadModule('module-parking', { include: both, moduleProvider: 'wanda' });
+    expect(hypFollow.integrationFieldRegistry).toEqual(E5);
+    await h2.tk.writeModuleIntegration('module-parking', {});
+    const actFollow = await h2.tk.loadModule('module-parking', { include: both });
+    expect(actFollow.integrationFieldRegistry).toEqual(hypFollow.integrationFieldRegistry);
+    // ③ PUT 任意 config 值不改 registry（schema 侧投影与值无关）
+    await h2.tk.writeModuleIntegration('module-parking', { provider: 'joycity', config: { baseUrl: 'https://example' } });
+    const actCfg = await h2.tk.loadModule('module-parking', { include: both });
+    expect(actCfg.integrationFieldRegistry).toEqual(E1);
+    h2.app.dispose();
+  });
+
+  it('S6 app 轴同构：假想 ≡ 写 root {provider:joycity} 后实读（domains/services 不受扰）', async () => {
+    const h2 = layerHarness();
+    const hyp = await h2.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'joycity' });
+    const cur = await h2.tk.loadApp();
+    const w = await h2.tk.writeAppIntegration({ ...(cur.integration ?? {}), provider: 'joycity' });
+    expect(w.written).toBe(true);
+    const act = await h2.tk.loadApp({ include: ['integrationFieldRegistry'] });
+    expect(act.integrationFieldRegistry).toEqual(hyp.integrationFieldRegistry);
+    expect(act.integrationFieldRegistry).toEqual(E2);
+    // I2：域节点/mirror 不受 root 写入波及
+    expect((await h2.tk.loadModule('module-parking')).integration).toEqual({ provider: 'wanda' });
+    h2.app.dispose();
+  });
+
+  // ── S7 边界 ──
+  it('S7-1/2/3/6 轴参严检：400 矩阵（fields 随参数名）+ 先于 404 + 边界正例 + 未请求缺席', async () => {
+    const h2 = layerHarness();
+    await expect(h2.tk.loadApp({ appProvider: 'wanda' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['appProvider'],
+    });
+    await expect(h2.tk.loadApp({ include: ['serviceResolutions'], appProvider: 'wanda' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['appProvider'],
+    });
+    await expect(h2.tk.loadApp({ include: [], appProvider: 'x' })).rejects.toMatchObject({ fields: ['appProvider'] });
+    await expect(h2.tk.loadModule('module-parking', { moduleProvider: 'x' })).rejects.toMatchObject({ fields: ['moduleProvider'] });
+    // 先于 404；表单键在场 → 放行至 404
+    await expect(h2.tk.loadModule('ghost', { moduleProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400,
+    });
+    await expect(h2.tk.loadModule('ghost', { include: ['integrationSchemas'], moduleProvider: 'x' })).rejects.toMatchObject({
+      code: 'MODULE_NOT_FOUND', httpStatus: 404,
+    });
+    // 边界正例：仅 integrationSchemas + 轴参 → 200 假想计算；registry 未请求 = 缺席（内嵌三律）
+    const ok = await h2.tk.loadModule('module-parking', { include: ['integrationSchemas'], moduleProvider: 'joycity' });
+    expect(ok.integrationSchemas?.provider).toBe('joycity');
+    expect('integrationFieldRegistry' in ok).toBe(false);
+    h2.app.dispose();
+  });
+
+  it('S7-4 空串 ≡ 缺席；错轴参数静默忽略', async () => {
+    const h2 = layerHarness();
+    const empty = await h2.tk.loadModule('module-parking', { include: ['integrationFieldRegistry'], moduleProvider: '' });
+    const absent = await h2.tk.loadModule('module-parking', { include: ['integrationFieldRegistry'] });
+    expect(empty.integrationFieldRegistry).toEqual(absent.integrationFieldRegistry);
+    expect(empty.integrationFieldRegistry).toEqual(E5);
+    // 错轴参数（变量绕过多余属性检查——运行时按名读取，appProvider 被无视）
+    const opts = { include: ['integrationFieldRegistry'], moduleProvider: 'joycity', appProvider: 'wanda' };
+    const wrongAxis = await h2.tk.loadModule('module-parking', opts);
+    expect(wrongAxis.integrationFieldRegistry).toEqual(E1);
+    h2.app.dispose();
+  });
+
+  it('S7-5 I2：假想态下文件镜像与求值恒实际态', async () => {
+    const h2 = layerHarness();
+    const v = await h2.tk.loadModule('module-parking', {
+      include: ['serviceResolutions', 'integrationSchemas', 'integrationFieldRegistry'],
+      moduleProvider: 'joycity',
+    });
+    expect(v.integration).toEqual({ provider: 'wanda' });
+    expect(v.providerBindings).toEqual([{ domain: 'parking', effective: 'wanda', layer: 'module' }]);
+    expect(v.configEditable).toBe(true);
+    expect(v.integrationFieldRegistry?.provider).toBe('joycity'); // 表单层重定向
+    expect(v.integrationSchemas?.provider).toBe('joycity');
+    expect(v.serviceResolutions?.resolutions['parking.query']?.provider).toBe('wanda'); // 求值恒实际
+    h2.app.dispose();
+  });
+
+  it('S7-7 null 两态：app 未绑定 / 可写未绑定 / D34 三形态（带 override 不豁免）', async () => {
+    // app 未绑定（root.provider 缺席——带空串轴参同此）
+    const h3 = layerHarness();
+    writeAppFile(
+      h3.app.appDir,
+      'config/integrations.json',
+      JSON.stringify({
+        instances: [{ id: 'mall-bj-01', name: '北京店' }],
+        domains: { parking: { provider: 'joycity' } },
+        services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
+      }),
+    );
+    expect((await h3.tk.loadApp({ include: ['integrationFieldRegistry'] })).integrationFieldRegistry).toBeNull();
+    expect(
+      (await h3.tk.loadApp({ include: ['integrationSchemas', 'integrationFieldRegistry'], appProvider: '' })).integrationSchemas,
+    ).toBeNull();
+    h3.app.dispose();
+
+    // 可写未绑定（无 domains 无 root.provider——无轴参 → null）
+    const h4 = layerHarness();
+    writeAppFile(
+      h4.app.appDir,
+      'config/integrations.json',
+      JSON.stringify({
+        instances: [{ id: 'mall-bj-01', name: '北京店' }],
+        services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
+      }),
+    );
+    const unbound = await h4.tk.loadModule('module-parking', { include: ['integrationFieldRegistry', 'integrationSchemas'] });
+    expect(unbound.integrationFieldRegistry).toBeNull();
+    expect(unbound.integrationSchemas).toBeNull();
+    expect(unbound.configEditable).toBe(true);
+    h4.app.dispose();
+
+    // D34 三形态（多域/零域/共享键——带 moduleProvider 仍 null）
+    const d34 = createTempApp('tbox-v46-d34-');
+    invalidateContractsResolver();
+    const store34 = joinStore(d34.appDir, 'contracts');
+    writeFakeContractsPackage(store34, { version: '0.9.0' });
+    linkContracts(d34.appDir, store34, { subdir: 'apps/server' });
+    const need = (service: string): { service: string; optional: boolean } => ({ service, optional: false });
+    const manifest34 = (name: string, services: Array<{ service: string; optional: boolean }>): string =>
+      JSON.stringify({ schemaVersion: 1, name, version: '0.1.0', kind: 'business', contributes: { services }, dependencies: { modules: [] }, env: [] });
+    writeAppFile(d34.appDir, 'packages/module-multi/tbox.module.json', manifest34('module-multi', [need('parking.query'), need('member.account')]));
+    writeAppFile(
+      d34.appDir,
+      'packages/module-zero/tbox.module.json',
+      JSON.stringify({ schemaVersion: 1, name: 'module-zero', version: '0.1.0', kind: 'business', contributes: {}, dependencies: { modules: [] }, env: [] }),
+    );
+    writeAppFile(d34.appDir, 'packages/module-a/tbox.module.json', manifest34('module-a', [need('parking.alpha')]));
+    writeAppFile(d34.appDir, 'packages/module-b/tbox.module.json', manifest34('module-b', [need('parking.beta')]));
+    const tk34 = createAppToolkit(d34.appDir);
+    for (const id of ['module-multi', 'module-zero', 'module-a']) {
+      const v = await tk34.loadModule(id, { include: ['integrationFieldRegistry', 'integrationSchemas'], moduleProvider: 'joycity' });
+      expect(v.integrationFieldRegistry, id).toBeNull();
+      expect(v.integrationSchemas, id).toBeNull();
+    }
+    d34.dispose();
+  });
+
+  it('S7-8 正例：未绑定 + override → 可计算（预览首次配置）；未知厂商 → 非 null 空集 + unsupplied 回填', async () => {
+    const h5 = layerHarness();
+    writeAppFile(
+      h5.app.appDir,
+      'config/integrations.json',
+      JSON.stringify({
+        instances: [{ id: 'mall-bj-01', name: '北京店' }],
+        services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
+      }),
+    );
+    const preview = await h5.tk.loadModule('module-parking', { include: ['integrationFieldRegistry'], moduleProvider: 'joycity' });
+    expect(preview.integrationFieldRegistry).toEqual(E1); // 无绑定亦可预览（scope = demand ∩ joycity 供给）
+    const appPreview = await h5.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'joycity' });
+    expect(appPreview.integrationFieldRegistry).toEqual(E2);
+    const ghost = await h5.tk.loadModule('module-parking', {
+      include: ['integrationFieldRegistry', 'integrationSchemas'],
+      moduleProvider: 'ghost-x',
+    });
+    expect(ghost.integrationFieldRegistry).toEqual(E4);
+    expect(ghost.integrationSchemas).toEqual({ provider: 'ghost-x', services: {} });
+    const ghostApp = await h5.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'ghost-x' });
+    expect(ghostApp.integrationFieldRegistry).toEqual({
+      provider: 'ghost-x', schemaless: [], unsupplied: [], additionalPropertiesAllowed: true, fields: [],
+    });
+    h5.app.dispose();
+  });
+
+  it('S7-9 最小正例：mock 零足迹 → 非 null 空集（factory→formViews→registry 全链）', async () => {
+    const h2 = harnessWithContracts();
+    const app = await h2.tk.loadApp({ include: ['integrationFieldRegistry'] });
+    expect(app.integrationFieldRegistry).toEqual({
+      provider: 'mock', schemaless: [], unsupplied: [], additionalPropertiesAllowed: true, fields: [],
+    });
+    h2.app.dispose();
+  });
+
+  // ── S8 双投影互证（依赖契约锁——旁路重取 serviceSchemas 破等式即刻红）──
+  it('S8 双投影互证：properties 键集 ≡ sources 反查 + schemaless 等价 + unsupplied 等式', async () => {
+    const h2 = layerHarness();
+    const v = await h2.tk.loadModule('module-parking', {
+      include: ['integrationSchemas', 'integrationFieldRegistry'],
+      moduleProvider: 'joycity',
+    });
+    const layer = v.integrationSchemas!;
+    const registry = v.integrationFieldRegistry!;
+    expect(registry.provider).toBe(layer.provider); // I1：同源同口径
+    for (const [s, entry] of Object.entries(layer.services)) {
+      const cfg = entry.configSchema;
+      if (cfg === null) {
+        expect(registry.schemaless, s).toContain(s);
+        continue;
+      }
+      expect(registry.schemaless, s).not.toContain(s);
+      const c = cfg as Record<string, unknown>;
+      const props = c.properties;
+      const declared = props && typeof props === 'object' && !Array.isArray(props) ? Object.keys(props) : []; // 同款守卫
+      const rev = registry.fields.filter((f) => f.sources.some((x) => x.service === s)).map((f) => f.key);
+      expect([...declared].sort(), s).toEqual([...rev].sort());
+    }
+    for (const s of registry.schemaless) expect(layer.services[s]?.configSchema).toBeNull();
+    // unsupplied ≡ demand − scope 键集
+    const demand = v.services.map((x) => x.service);
+    const scopeKeys = Object.keys(layer.services);
+    expect([...registry.unsupplied].sort()).toEqual(demand.filter((s) => !scopeKeys.includes(s)).sort());
+    h2.app.dispose();
+  });
+
+  it('S8 app 轴：unsupplied ≡ []（结构性：足迹 ⊆ 供给）', async () => {
+    const h2 = layerHarness();
+    const v = await h2.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'joycity' });
+    expect(v.integrationFieldRegistry?.unsupplied).toEqual([]);
+    h2.app.dispose();
+  });
+});
+
+/**
+ * B1 展示名链（模块 meta / 词汇 meta 单源 / resolveServiceDisplay 兜底链）：
+ * 兜底链 = 词汇 meta（slotMeta）> demand meta（catalog.services）> service id（逐字段回落）。
+ * fixture：词汇 meta 停车查询 vs demand meta 车位查询——断言词汇胜出（防漂移锁）。
+ */
+describe('B1 展示名链', () => {
+  /** 展示名 fixture 基座：词汇物化（3 槽 2 meta）+ 停车模块（带 meta + demand meta）+ demo 厂商 */
+  function displayHarness(): Harness {
+    const app = createTempApp('tbox-display-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, {
+      version: '0.9.0',
+      slots: ['parking.query', 'auth.alipay-login', 'mall.info'],
+      meta: {
+        'parking.query': { title: '停车查询', description: '费用报价、车场信息、可享权益' },
+        'auth.alipay-login': { title: '支付宝登录' },
+      },
+    });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    mkdirDeep(join(app.appDir, 'packages', 'module-parking'));
+    writeAppFile(
+      app.appDir,
+      'packages/module-parking/tbox.module.json',
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'module-parking',
+        version: '0.1.0',
+        kind: 'business',
+        title: '停车缴费',
+        description: '车辆查询与绑定、停车费用查询、缴费支付与开票',
+        contributes: {
+          // demand meta title=车位查询——应被词汇 meta 停车查询压过（词汇主源）
+          services: [{ service: 'parking.query', optional: false, title: '车位查询' }],
+        },
+        dependencies: { modules: [] },
+        env: [],
+      }),
+    );
+    mkdirDeep(join(app.appDir, 'packages', 'provider-demo'));
+    writeAppFile(
+      app.appDir,
+      'packages/provider-demo/tbox.module.json',
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'provider-demo',
+        version: '0.1.0',
+        kind: 'third-party',
+        title: '万达',
+        description: '万达厂商集成',
+        contributes: {
+          providers: {
+            slots: [{ service: 'parking.query', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'apikey' }],
+          },
+        },
+        dependencies: { modules: [] },
+        env: [],
+      }),
+    );
+    const tk = createAppToolkit(app.appDir);
+    return { app, tk };
+  }
+
+  it('T1 resolveServiceDisplay 三态：词汇 > demand > id；逐字段回落（词汇仅 description 时 demand title 可达）', () => {
+    const walk = {
+      slotMeta: {
+        'a.b': { title: '甲', description: '甲描述' },
+        'c.d': { description: '只有描述' },
+      },
+      catalog: {
+        services: {
+          'a.b': { title: '乙', description: '乙描述' },
+          'c.d': { title: '丙' },
+        },
+      },
+    } as unknown as WalkManifestsResult;
+    // 词汇全量在场 → 词汇胜出
+    expect(resolveServiceDisplay(walk, 'a.b')).toEqual({ title: '甲', description: '甲描述' });
+    // 词汇仅 description → title 回落 demand、description 取词汇（逐字段回落）
+    expect(resolveServiceDisplay(walk, 'c.d')).toEqual({ title: '丙', description: '只有描述' });
+    // 双缺席 → demand
+    expect(resolveServiceDisplay(walk, 'e.f')).toEqual({ title: 'e.f' });
+    // 双双缺席 → id 兜底（title 恒有值）
+    const bare = { slotMeta: {}, catalog: { services: {} } } as unknown as WalkManifestsResult;
+    expect(resolveServiceDisplay(bare, 'x.y')).toEqual({ title: 'x.y' });
+  });
+
+  it('T2 loadModulesView：模块 meta 填充；name 兜底', async () => {
+    const h2 = displayHarness();
+    const v = await h2.tk.loadModules();
+    const parking = v.modules.find((m) => m.id === 'module-parking');
+    expect(parking?.title).toBe('停车缴费');
+    expect(parking?.description).toBe('车辆查询与绑定、停车费用查询、缴费支付与开票');
+    // 无 meta 模块（provider 家族不在清单——用第二基座验证兜底）
+    const h3 = harnessWithContracts();
+    const bare = (await h3.tk.loadModules()).modules.find((m) => m.id === 'module-parking');
+    expect(bare?.title).toBe('module-parking');
+    expect(bare?.description).toBe('');
+    h3.app.dispose();
+    h2.app.dispose();
+  });
+
+  it('T3 loadModuleDetailView：meta 恒发；services[] 词汇优先（demand 车位查询被词汇停车查询压过——防漂移锁）', async () => {
+    const h2 = displayHarness();
+    const v = await h2.tk.loadModule('module-parking');
+    expect(v.title).toBe('停车缴费');
+    expect(v.description).toContain('停车费用查询');
+    const svc = v.services.find((s) => s.service === 'parking.query');
+    expect(svc?.title).toBe('停车查询');
+    expect(svc?.description).toBe('费用报价、车场信息、可享权益');
+    expect(svc?.required).toBe(true);
+    h2.app.dispose();
+  });
+
+  it('T-O3 词汇在场键集：resolutions 键集 = 词汇（退化态 = 既有 O3——无 slots 物化基座）', async () => {
+    const h2 = displayHarness();
+    const batch = await h2.tk.loadServiceResolutions();
+    expect(Object.keys(batch.resolutions).sort()).toEqual(['auth.alipay-login', 'mall.info', 'parking.query']);
+    h2.app.dispose();
+  });
+
+  it('T4 loadAppView 平台条目：title 走链恒发；词汇无 meta 槽 = id 兜底', async () => {
+    const h2 = displayHarness();
+    const v = await h2.tk.loadApp();
+    const byKey = Object.fromEntries(v.services.map((s) => [s.service, s]));
+    // 平台条目 = 词汇 − 占用（parking.query 被模块占用）
+    expect(Object.keys(byKey).sort()).toEqual(['auth.alipay-login', 'mall.info']);
+    expect(byKey['auth.alipay-login']?.title).toBe('支付宝登录');
+    expect(byKey['mall.info']?.title).toBe('mall.info');
+    expect(byKey['auth.alipay-login']?.required).toBe(false);
+    h2.app.dispose();
+  });
+
+  it('T5 loadServiceDetailView：词汇优先 + id 兜底恒有值', async () => {
+    const h2 = displayHarness();
+    expect((await h2.tk.loadService('parking.query')).title).toBe('停车查询');
+    expect((await h2.tk.loadService('mall.info')).title).toBe('mall.info');
+    h2.app.dispose();
+  });
+
+  it('T6 厂商 title 传播（walk 层首声明）+ /providers/:p services[] 走链', async () => {
+    const h2 = displayHarness();
+    const list = await h2.tk.loadProviders();
+    const wanda = list.providers.find((p) => p.provider === 'wanda');
+    expect(wanda?.title).toBe('万达');
+    expect(wanda?.description).toBe('万达厂商集成');
+    const detail = await h2.tk.loadProvider('wanda');
+    expect(detail.title).toBe('万达');
+    expect(detail.services['parking.query']?.title).toBe('停车查询');
+    expect(detail.services['parking.query']?.description).toBe('费用报价、车场信息、可享权益');
+    h2.app.dispose();
+  });
+});