@tbox.cn/app-toolkit 0.1.0 → 0.3.0

package/tests/views.test.ts

@@ -4,6 +4,9 @@ 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 } from '../src/assembly/walk-manifests.js';
+import { buildIntegrationFieldRegistry, loadModuleFormViews, loadModuleIntegrationSchemas } from '../src/views/integration-schemas.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';
 
@@ -19,11 +22,17 @@ interface Harness {
   tk: AppToolkit;
 }
 
-function harnessWithContracts(opts: { version?: string; withStrict?: boolean } = {}): Harness {
+function harnessWithContracts(
+  opts: { version?: string; withStrict?: boolean; missingEvaluationExports?: boolean } = {},
+): Harness {
   const app = createTempApp('tbox-views-');
   invalidateContractsResolver();
   const store = joinStore(app.appDir, 'contracts');
-  writeFakeContractsPackage(store, { version: opts.version ?? '0.9.0', withStrict: opts.withStrict ?? true });
+  writeFakeContractsPackage(store, {
+    version: opts.version ?? '0.9.0',
+    withStrict: opts.withStrict ?? true,
+    missingEvaluationExports: opts.missingEvaluationExports,
+  });
   linkContracts(app.appDir, store, { subdir: 'apps/server' });
   // 应用结构：parking 模块（packages/ 约定发现）+ 注册表两实例 + integrations.json
   mkdirDeep(join(app.appDir, 'packages', 'module-parking'));
@@ -70,6 +79,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;
 
@@ -95,13 +257,14 @@ describe('views/工厂（O 矩阵核心族）', () => {
     const appView = await h.tk.loadApp();
     expect(Object.keys(appView)).toEqual(['services', 'integration']);
     const mod = await h.tk.loadModule('module-parking');
-    expect(Object.keys(mod)).toEqual(['integration', 'services']);
+    // v4.4 D34：domainKeys/providerBindings/configEditable 显式化（include 两键可选缺席——F4）
+    expect(Object.keys(mod)).toEqual(['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 反例联动）
   });
 
-  it('O8 P14 三处等价：map 值 ≡ 单体 resolution 摘要基（单源函数结构保证）', async () => {
+  it('O8 P14 等价：map 值 ≡ 单体 resolution 摘要基（单源函数结构保证；v4.4 内嵌两处见 I4）', async () => {
     const batch = await h.tk.loadServiceResolutions();
     const single = await h.tk.loadServiceResolution('parking.query');
     const entry = batch.resolutions['parking.query'];
@@ -172,7 +335,7 @@ describe('views/工厂（O 矩阵核心族）', () => {
     wild.app.dispose();
   });
 
-  it('N1 命名对齐：13 行映射表 × 工厂方法 typeof（L1 改名漂移即红）', async () => {
+  it('N1 命名对齐：15 行映射表 × 工厂方法 typeof（L1 改名漂移即红——v4.4 15 端点）', async () => {
     for (const row of URL_METHOD_MAP) {
       const fn = (h.tk as unknown as Record<string, unknown>)[row.method];
       expect(typeof fn, row.method).toBe('function');
@@ -193,23 +356,23 @@ 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 清域（模块 {} 删 domains 键）', async () => {
+  it('写时自动初始化（R13 语义翻转提示）+ N1 清域（模块 {} 删域键）', async () => {
     h.app.dispose();
     const fresh = createTempApp('tbox-views-fresh-');
     invalidateContractsResolver();
     const store = joinStore(fresh.appDir, 'contracts');
-    writeFakeContractsPackage(store, { version: '0.9.0' });
+    writeFakeContractsPackage(store, { version: '0.9.0', slots: ['auth.alipay-login'] });
     linkContracts(fresh.appDir, store, { subdir: 'apps/server' });
     const tk = createAppToolkit(fresh.appDir);
     // 缺席文件首写 → 骨架物化 + R13 warning
@@ -315,14 +478,18 @@ describe('views/工厂（O 矩阵核心族）', () => {
       credentialRef: 'secret://wanda-parking.query',
       layer: 'service',
     });
-    expect(inst?.credential).toEqual({
+    // v4.4 D33 删净：instances[].credential 移除（凭据掩码归 GET /credentials——求值路径零凭据 I/O）
+    expect(inst && 'credential' in inst).toBe(false);
+    // 本位 ref（服务级 credentialRef）掩码经 GET /credentials 回显
+    const credView = await tk.loadCredentials();
+    expect(credView.services['parking.query']?.credential).toEqual({
       type: 'wanda-c-signed-v1',
       ref: 'secret://wanda-parking.query',
       file: 'config/credentials/wanda-parking.query.json',
       masked: { appKey: 'SE****', appSecret: 'SE****' },
     });
     // O4 零真值：序列化后 grep 断言
-    const serialized = JSON.stringify(detail);
+    const serialized = JSON.stringify({ detail, credView });
     expect(serialized).not.toContain('SECRET-APP-KEY');
     expect(serialized).not.toContain('SECRET-APP-SECRET');
     // inheritance 实例层 = 默认实例口径（FX-2c）：无实例级声明 → 继承位（provider 缺席）
@@ -367,7 +534,8 @@ describe('O6/O7/O10/O14（FX-3 补全）', () => {
     const combo = await tk.loadProviderService('joycity', 'parking.query');
     expect(combo.implementations).toHaveLength(2);
     expect(combo.integrationSchemas.configSchema).toEqual({ type: 'object', properties: { baseUrl: { type: 'string' } } });
-    expect(combo.integrationSchemas.credentialSchema).toBeNull(); // 供给在场未声明 credentialSchema → null（非 404）
+    // v4.4 D33：credentialSchema 删净（结构归 GET /credential-types——组合单体纯 config）
+    expect('credentialSchema' in combo.integrationSchemas).toBe(false);
     app.dispose();
   });
 
@@ -425,3 +593,1107 @@ describe('O6/O7/O10/O14（FX-3 补全）', () => {
     }
   });
 });
+
+describe('A2 错误面（P-4 notes 优先 / P-5 畸形包 503）', () => {
+  it('M1 导入失败 message 含构建指引且不再误报未安装（P-4 notes 优先）', 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' });
+    const tk = createAppToolkit(app.appDir);
+    await expect(tk.loadServiceResolutions()).rejects.toThrow(/构建产物导入失败/);
+    await expect(tk.loadServiceResolutions()).rejects.not.toThrow(/未安装/);
+    app.dispose();
+  });
+
+  it('M2 <0.9 message 对齐 api.md 信封（需 ≥0.9.0——resolver note 文案）', 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' });
+    const tk = createAppToolkit(app.appDir);
+    await expect(tk.loadServiceResolutions()).rejects.toThrow(/需 ≥0\.9\.0/);
+    app.dispose();
+  });
+
+  it('M3 畸形包（求值面缺席）+ 无 config → 503 非 500（P-5——predicateIssues 早退绕过 assertFn 的唯一后续拦截点）', 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(/工厂门控应先行拦截/);
+    app.dispose();
+  });
+});
+
+describe('D34 多域模块钉死（v4.4 F3）', () => {
+  it('D1 单域回归：domainKeys/providerBindings/configEditable 装配 + integration 原值', async () => {
+    const h2 = harnessWithContracts();
+    const mod = await h2.tk.loadModule('module-parking');
+    expect(mod.domainKeys).toEqual(['parking']);
+    expect(mod.configEditable).toBe(true);
+    expect(mod.providerBindings).toEqual([{ domain: 'parking', effective: 'wanda', layer: 'module' }]);
+    expect(mod.integration).toEqual({ provider: 'wanda' });
+    h2.app.dispose();
+  });
+
+  it('D2 多域模块：GET integration null + providerBindings 双条 + PUT 400 分支①（含 {} 清域）', async () => {
+    const app = createTempApp('tbox-d2-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(
+      app.appDir,
+      'packages/module-multi/tbox.module.json',
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'module-multi',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'member.account', optional: false }] },
+        dependencies: { modules: [] },
+        env: [],
+      }),
+    );
+    const tk = createAppToolkit(app.appDir);
+    const mod = await tk.loadModule('module-multi');
+    expect(mod.domainKeys).toEqual(['member', 'parking']);
+    expect(mod.integration).toBeNull();
+    expect(mod.configEditable).toBe(false);
+    expect(mod.providerBindings).toEqual([
+      { domain: 'member', effective: null, layer: null },
+      { domain: 'parking', effective: null, layer: null },
+    ]);
+    await expect(tk.writeModuleIntegration('module-multi', { provider: 'wanda' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED',
+      httpStatus: 400,
+      message: expect.stringContaining('跨 2 个域（member、parking）'),
+    });
+    await expect(tk.writeModuleIntegration('module-multi', {})).rejects.toMatchObject({ code: 'VALIDATION_FAILED' });
+    app.dispose();
+  });
+
+  it('D3 零域模块：domainKeys [] + PUT 400 分支②', async () => {
+    const app = createTempApp('tbox-d3-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(
+      app.appDir,
+      'packages/module-zero/tbox.module.json',
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'module-zero',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: {},
+        dependencies: { modules: [] },
+        env: [],
+      }),
+    );
+    const tk = createAppToolkit(app.appDir);
+    const mod = await tk.loadModule('module-zero');
+    expect(mod.domainKeys).toEqual([]);
+    expect(mod.providerBindings).toEqual([]);
+    expect(mod.integration).toBeNull();
+    await expect(tk.writeModuleIntegration('module-zero', { provider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED',
+      httpStatus: 400,
+      message: expect.stringContaining('无服务需求声明'),
+    });
+    app.dispose();
+  });
+
+  it('D4 域键共享（P13）：双方 configEditable false + PUT 400 分支③（他方同域异服务——并集计数）', async () => {
+    const app = createTempApp('tbox-d4-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    const manifest = (name: string, service: string): string =>
+      JSON.stringify({
+        schemaVersion: 1,
+        name,
+        version: '0.1.0',
+        kind: 'business',
+        contributes: { services: [{ service, optional: false }] },
+        dependencies: { modules: [] },
+        env: [],
+      });
+    writeAppFile(app.appDir, 'packages/module-a/tbox.module.json', manifest('module-a', 'parking.alpha'));
+    writeAppFile(app.appDir, 'packages/module-b/tbox.module.json', manifest('module-b', 'parking.beta'));
+    const tk = createAppToolkit(app.appDir);
+    const a = await tk.loadModule('module-a');
+    const b = await tk.loadModule('module-b');
+    expect(a.configEditable).toBe(false);
+    expect(b.configEditable).toBe(false);
+    await expect(tk.writeModuleIntegration('module-a', { provider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED',
+      httpStatus: 400,
+      message: expect.stringContaining('由 module-a、module-b 共用'),
+    });
+    app.dispose();
+  });
+
+  it('D5 死键扫尾：moduleDomainKey/moduleDomainKeyOf 全链删除（源文件内容断言）', () => {
+    const read = (rel: string): string => readFileSync(fileURLToPath(new URL(rel, import.meta.url)), 'utf8');
+    expect(read('../src/views/modules.ts')).not.toContain('moduleDomainKeyOf');
+    expect(read('../src/integrations/write.ts')).not.toContain('moduleDomainKey');
+    expect(read('../src/index.ts')).not.toContain('moduleDomainKeyOf');
+  });
+});
+
+describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
+  it('I1 include 正例：app/module 双键内嵌 + 未请求缺席（内嵌三律）+ issues 恒全量', async () => {
+    const h2 = harnessWithContracts();
+    const appInc = await h2.tk.loadApp({ include: ['serviceResolutions', 'integrationSchemas'] });
+    expect(Object.keys(appInc.serviceResolutions!.resolutions).sort()).toEqual(['auth.alipay-login', 'parking.query']);
+    // harness 无供给 manifest → mock 足迹空（供给在场未声明形态由 S 系列覆盖）
+    expect(appInc.integrationSchemas).toEqual({ provider: 'mock', services: {} });
+    const modInc = await h2.tk.loadModule('module-parking', { include: ['serviceResolutions'] });
+    expect(Object.keys(modInc.serviceResolutions!.resolutions)).toEqual(['parking.query']); // demand 过滤
+    const batch = await h2.tk.loadServiceResolutions();
+    expect(modInc.serviceResolutions!.issues).toEqual(batch.issues); // 恒全量（不随过滤收窄）
+    // 未请求 → 字段缺席（D30 三律：未请求 = 缺席）
+    const plain = await h2.tk.loadApp();
+    expect('serviceResolutions' in plain).toBe(false);
+    expect('integrationSchemas' in plain).toBe(false);
+    h2.app.dispose();
+  });
+
+  it('I2 未知/越权键 400 + 校验先于 404 + 重复键去重（P15）', async () => {
+    const h2 = harnessWithContracts();
+    await expect(h2.tk.loadApp({ include: ['bogus'] })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['include'],
+    });
+    // 越权：provider 白名单仅 integrationSchemas——且 400 先于 PROVIDER_NOT_FOUND
+    await expect(h2.tk.loadProvider('wanda', { include: ['serviceResolutions'] })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['include'],
+    });
+    // 校验先于 MODULE_NOT_FOUND
+    await expect(h2.tk.loadModule('ghost', { include: ['bogus'] })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400,
+    });
+    const ok = await h2.tk.loadApp({ include: ['serviceResolutions', 'serviceResolutions'] });
+    expect(ok.serviceResolutions).not.toBeNull();
+    h2.app.dispose();
+  });
+
+  it('I3 degrade：<0.9 → null 永不 503；形态异常包（严格面在场求值面缺席）→ null（双条件）', async () => {
+    const low = harnessWithContracts({ version: '0.8.2', withStrict: false });
+    expect((await low.tk.loadApp({ include: ['serviceResolutions'] })).serviceResolutions).toBeNull();
+    expect((await low.tk.loadApp({ include: ['integrationSchemas'] })).integrationSchemas).toEqual({ provider: 'mock', services: {} }); // 静态轴富化零 contracts
+    low.app.dispose();
+    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 });
+    malformed.app.dispose();
+  });
+
+  it('I4 P14 四处等价：批量 / 单体摘要基 / app 内嵌 / module 内嵌（deep-equal 含 layer）', async () => {
+    const h2 = layerHarness();
+    const batch = await h2.tk.loadServiceResolutions();
+    const appInc = await h2.tk.loadApp({ include: ['serviceResolutions'] });
+    const modInc = await h2.tk.loadModule('module-parking', { include: ['serviceResolutions'] });
+    expect(Object.keys(modInc.serviceResolutions!.resolutions).sort()).toEqual(['parking.payment', 'parking.query']); // demand = 双服务
+    for (const s of ['parking.query', 'parking.payment']) {
+      const single = await h2.tk.loadServiceResolution(s);
+      const { instances, inheritance, ...base } = single.resolution;
+      void instances;
+      void inheritance;
+      expect(batch.resolutions[s], s).toEqual(base);
+      expect(appInc.serviceResolutions!.resolutions[s], `app:${s}`).toEqual(base);
+      expect(modInc.serviceResolutions!.resolutions[s], `module:${s}`).toEqual(base);
+    }
+    h2.app.dispose();
+  });
+
+  it('I5 layer 一致性：Entry.layer ≡ inheritance 逆序首个有 provider 层；未配置双缺席', async () => {
+    const h2 = layerHarness();
+    const batch = await h2.tk.loadServiceResolutions();
+    for (const [s, entry] of Object.entries(batch.resolutions)) {
+      const single = await h2.tk.loadServiceResolution(s);
+      const expected = [...single.resolution.inheritance].reverse().find((i) => i.provider !== undefined)?.layer ?? null;
+      if (entry.provider === undefined) {
+        expect(entry.layer, `${s} 双缺席`).toBeUndefined();
+      } else {
+        expect(entry.layer, s).toEqual(expected);
+      }
+    }
+    // parking.payment 未配置（slot 缺席）→ provider/layer 双缺席（无孤儿态）
+    expect(batch.resolutions['parking.payment']?.provider).toBeUndefined();
+    expect(batch.resolutions['parking.payment']?.layer).toBeUndefined();
+    // parking.query 槽级 wanda → layer 'service'
+    expect(batch.resolutions['parking.query']).toMatchObject({ status: 'ok', provider: 'wanda', layer: 'service' });
+    h2.app.dispose();
+  });
+
+  it('S1 模块级层级 schema：demand ∩ 供给 + schema 文件原文（D32）+ 缺省缺席', async () => {
+    const h2 = layerHarness();
+    const mod = await h2.tk.loadModule('module-parking', { include: ['integrationSchemas'] });
+    expect(mod.integrationSchemas).toEqual({
+      provider: 'wanda', // resolveDomainBinding 单源（domains.parking）
+      services: {
+        'parking.query': { configSchema: h2.schemas.query },
+        'parking.payment': { configSchema: h2.schemas.parking },
+      },
+    });
+    const plain = await h2.tk.loadModule('module-parking');
+    expect('integrationSchemas' in plain).toBe(false);
+    h2.app.dispose();
+  });
+
+  it('S2 应用级：供给足迹全量（≠ AppView.services）+ root.provider 缺席 → null', async () => {
+    const h2 = layerHarness();
+    const appInc = await h2.tk.loadApp({ include: ['integrationSchemas'] });
+    expect(appInc.integrationSchemas).toEqual({
+      provider: 'wanda',
+      services: {
+        'parking.query': { configSchema: h2.schemas.query },
+        'parking.payment': { configSchema: h2.schemas.parking },
+      },
+    });
+    h2.app.dispose();
+    // root.provider 缺席 → null（未绑定——表单降级 ExtraFields）
+    const h3 = layerHarness();
+    writeAppFile(
+      h3.app.appDir,
+      'config/integrations.json',
+      JSON.stringify({
+        instances: [{ id: 'mall-bj-01', name: '北京店' }],
+        domains: { parking: { provider: 'wanda' } },
+        services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
+      }),
+    );
+    expect((await h3.tk.loadApp({ include: ['integrationSchemas'] })).integrationSchemas).toBeNull();
+    h3.app.dispose();
+  });
+
+  it('S3 切换态批量：loadProvider include=integrationSchemas（供给轴逐服务）+ 未请求缺席', async () => {
+    const h2 = layerHarness();
+    const detail = await h2.tk.loadProvider('wanda', { include: ['integrationSchemas'] });
+    expect(detail.services['parking.query']?.integrationSchemas).toEqual({ configSchema: h2.schemas.query });
+    expect(detail.services['parking.payment']?.integrationSchemas).toEqual({ configSchema: h2.schemas.parking });
+    const plain = await h2.tk.loadProvider('wanda');
+    expect(plain.services['parking.query'] && 'integrationSchemas' in plain.services['parking.query']).toBe(false);
+    h2.app.dispose();
+  });
+
+  it('S4 多域模块 integrationSchemas → 整字段 null（D32——表单降级 ExtraFields）', async () => {
+    const app = createTempApp('tbox-s4-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(
+      app.appDir,
+      'packages/module-multi/tbox.module.json',
+      JSON.stringify({
+        schemaVersion: 1,
+        name: 'module-multi',
+        version: '0.1.0',
+        kind: 'business',
+        contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'member.account', optional: false }] },
+        dependencies: { modules: [] },
+        env: [],
+      }),
+    );
+    const tk = createAppToolkit(app.appDir);
+    const mod = await tk.loadModule('module-multi', { include: ['integrationSchemas'] });
+    expect(mod.integrationSchemas).toBeNull();
+    expect(mod.serviceResolutions).toBeUndefined(); // 未请求
+    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();
+  });
+});