@tbox.cn/app-toolkit 0.4.0 → 0.6.0

package/tests/views.test.ts

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { createAppToolkit, type AppToolkit } from '../src/factory.js';
 import { invalidateContractsResolver } from '../src/core/contracts-resolver.js';
 import { walkManifests, type WalkManifestsResult } from '../src/assembly/walk-manifests.js';
-import { buildIntegrationFieldRegistry, loadModuleFormViews, loadModuleIntegrationSchemas } from '../src/views/integration-schemas.js';
+import { buildIntegrationFieldRegistry, loadModuleFormViews, loadModuleIntegrationSchemas, loadServiceFieldRegistry, loadServiceIntegrationSchemas } from '../src/views/integration-schemas.js';
 import { resolveServiceDisplay } from '../src/views/context.js';
 import type { ViewSnapshot } from '../src/views/context.js';
 import { URL_METHOD_MAP } from './naming-alignment.test.js';
@@ -42,11 +42,12 @@ function harnessWithContracts(
     'packages/module-parking/tbox.module.json',
     JSON.stringify({
       schemaVersion: 1,
-      name: 'module-parking',
+      id: 'module-parking',
       version: '0.1.0',
       kind: 'business',
-      contributes: {
-        services: [{ service: 'parking.query', optional: false, title: '车位查询' }],
+      declare: {
+        owns: [{ service: 'parking.query' }],
+        consumes: [{ service: 'parking.query', optional: false, name: '车位查询' }],
       },
       dependencies: { modules: [] },
       env: [],
@@ -62,7 +63,7 @@ function harnessWithContracts(
         { id: 'mall-sh-01', name: '上海店' },
       ],
       defaultInstanceId: 'mall-bj-01',
-      domains: { parking: { provider: 'wanda' } },
+      modules: { 'module-parking': { provider: 'wanda' } },
       services: {
         'parking.query': { provider: { provider: 'my-custom-api', credentialType: '-' }, implementation: 'my-custom-parking@1' },
         'auth.alipay-login': {},
@@ -104,9 +105,12 @@ function layerHarness(): {
     ].join(' '),
   });
   linkContracts(app.appDir, store, { subdir: 'apps/server' });
+  // G 批：fixture 全字段标 x-tbox-global（表单收窄过滤后 E1/E2/E5 字段面逐字不变）；
+  // wanda parking.json 另含未标记键 parkLotId（P16 负例——layer.properties 在场、registry.fields 不收）
+  const g = (sub: Record<string, unknown>): Record<string, unknown> => ({ ...sub, 'x-tbox-global': true });
   const schemas = {
-    query: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
-    parking: { type: 'object', properties: { mallId: { type: 'string' } } },
+    query: { type: 'object', properties: { baseUrl: g({ type: 'string', format: 'uri' }) }, required: ['baseUrl'] },
+    parking: { type: 'object', properties: { mallId: g({ type: 'string' }), parkLotId: { type: 'string', title: '车场组' } } },
   };
   // v4.6 joycity 代数 fixture：R1（baseUrl 双无 enum / env 同集异序 / envMixed 混布）/
   // R2（options 深相等 / meta 异构）/ R3（lotId string≠integer / timeout number≠integer / untyped 无 type）/
@@ -115,14 +119,14 @@ function layerHarness(): {
     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' },
+        baseUrl: { 'x-tbox-global': true, type: 'string', format: 'uri' },
+        lotId: { 'x-tbox-global': true, type: 'string' },
+        env: { 'x-tbox-global': true, type: 'string', enum: ['dev', 'staging', 'prod'] },
+        envMixed: { 'x-tbox-global': true, type: 'string', enum: ['a', 'b'] },
+        meta: { 'x-tbox-global': true, type: 'object', properties: { region: { 'x-tbox-global': true, type: 'string' } } },
+        options: { 'x-tbox-global': true, type: 'object', properties: { x: { 'x-tbox-global': true, type: 'string' } } },
+        untyped: { 'x-tbox-global': true, description: 'x' },
+        timeout: { 'x-tbox-global': true, type: 'number' },
       },
       required: ['baseUrl', 'lotId'],
     },
@@ -130,15 +134,15 @@ function layerHarness(): {
       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' },
+        apiKey: { 'x-tbox-global': true, type: 'string' },
+        baseUrl: { 'x-tbox-global': true, type: 'string' },
+        lotId: { 'x-tbox-global': true, type: 'integer' },
+        env: { 'x-tbox-global': true, type: 'string', enum: ['prod', 'dev', 'staging'] },
+        envMixed: { 'x-tbox-global': true, type: 'string' },
+        meta: { 'x-tbox-global': true, type: 'object', properties: { zone: { 'x-tbox-global': true, type: 'number' } } },
+        options: { 'x-tbox-global': true, type: 'object', properties: { x: { 'x-tbox-global': true, type: 'string' } } },
+        untyped: { 'x-tbox-global': true, type: 'string' },
+        timeout: { 'x-tbox-global': true, type: 'integer' },
       },
       required: ['apiKey', 'options'],
     },
@@ -148,10 +152,10 @@ function layerHarness(): {
     'packages/provider-w/tbox.module.json',
     JSON.stringify({
       schemaVersion: 1,
-      name: 'provider-w',
+      id: 'provider-w',
       version: '0.1.0',
       kind: 'business',
-      contributes: {
+      declare: {
         providers: {
           slots: [
             { service: 'parking.query', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/query.json' },
@@ -171,10 +175,10 @@ function layerHarness(): {
     'packages/provider-j/tbox.module.json',
     JSON.stringify({
       schemaVersion: 1,
-      name: 'provider-j',
+      id: 'provider-j',
       version: '0.1.0',
       kind: 'business',
-      contributes: {
+      declare: {
         providers: {
           slots: [
             { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/query.json' },
@@ -194,10 +198,10 @@ function layerHarness(): {
     'packages/provider-p/tbox.module.json',
     JSON.stringify({
       schemaVersion: 1,
-      name: 'provider-p',
+      id: 'provider-p',
       version: '0.1.0',
       kind: 'business',
-      contributes: {
+      declare: {
         providers: {
           slots: [{ service: 'parking.payment', provider: 'partial', implementation: 'partial-payment@1', credentialType: 'partial-c' }],
         },
@@ -211,10 +215,13 @@ function layerHarness(): {
     'packages/module-parking/tbox.module.json',
     JSON.stringify({
       schemaVersion: 1,
-      name: 'module-parking',
+      id: 'module-parking',
       version: '0.1.0',
       kind: 'business',
-      contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'parking.payment', optional: true }] },
+      declare: {
+        owns: [{ service: 'parking.query' }, { service: 'parking.payment' }],
+        consumes: [{ service: 'parking.query', optional: false }, { service: 'parking.payment', optional: true }],
+      },
       dependencies: { modules: [] },
       env: [],
     }),
@@ -226,13 +233,103 @@ function layerHarness(): {
       provider: 'wanda',
       instances: [{ id: 'mall-bj-01', name: '北京店' }],
       defaultInstanceId: 'mall-bj-01',
-      domains: { parking: { provider: 'wanda' } },
+      modules: { 'module-parking': { provider: 'wanda' } },
       services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
     }),
   );
   return { app, tk: createAppToolkit(app.appDir), schemas, joycity };
 }
 
+/** E 系列基座（v4.7 D38 引入；v5.1 D39 提升至模块层共用——原 D38 describe 内定义）：wanda 双槽
+ *  （layerHarness 形态）+ joycity 双 impl（O6 形态）+ config/schemas/ok.json（O15 形态）+
+ *  module-parking demand。schema 内容互异防断言串扰：
+ *  wQuery={baseUrl} / wParking={mallId} / joycity@1={joycityUrl} / joycity@2={endpointV2} / ok={okEndpoint}。
+ *  每用例独立 eHarness()——fixture 全新 temp app，零 file-cache stat 指纹串扰（不取重写+bumpMtime 方案）。
+ *  供给矩阵：wanda 供给 {parking.query, parking.payment}；joycity 仅供给 {parking.query}
+ *  （provider-multi 双 impl 皆 query）——D39 用例 (厂商 × 服务) 选型须对照本矩阵。 */
+function eHarness(): {
+  app: TempApp;
+  tk: AppToolkit;
+  schemas: { wQuery: object; wParking: object; joycity1: object; joycity2: object; ok: object };
+} {
+  const app = createTempApp('tbox-d38-');
+  invalidateContractsResolver();
+  const store = join(app.appDir, 'contracts');
+  writeFakeContractsPackage(store, { version: '0.9.0' });
+  linkContracts(app.appDir, store, { subdir: 'apps/server' });
+  const schemas = {
+    wQuery: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
+    wParking: { type: 'object', properties: { mallId: { type: 'string' } } },
+    joycity1: { type: 'object', properties: { joycityUrl: { type: 'string' } } },
+    joycity2: { type: 'object', properties: { endpointV2: { type: 'string' } } },
+    ok: { type: 'object', properties: { okEndpoint: { type: 'string' } } },
+  };
+  writeAppFile(
+    app.appDir,
+    'packages/provider-w/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      id: 'provider-w',
+      version: '0.1.0',
+      kind: 'business',
+      declare: {
+        providers: {
+          slots: [
+            { service: 'parking.query', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/query.json' },
+            { service: 'parking.payment', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'wanda-c', configSchema: 'schemas/parking.json' },
+          ],
+        },
+      },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(app.appDir, 'packages/provider-w/schemas/query.json', JSON.stringify(schemas.wQuery));
+  writeAppFile(app.appDir, 'packages/provider-w/schemas/parking.json', JSON.stringify(schemas.wParking));
+  writeAppFile(
+    app.appDir,
+    'packages/provider-multi/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      id: 'provider-multi',
+      version: '0.1.0',
+      kind: 'business',
+      declare: {
+        providers: {
+          slots: [
+            { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/query.json' },
+            { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@2', credentialType: 'joycity-c', configSchema: 'schemas/query2.json' },
+          ],
+        },
+      },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  writeAppFile(app.appDir, 'packages/provider-multi/schemas/query.json', JSON.stringify(schemas.joycity1));
+  writeAppFile(app.appDir, 'packages/provider-multi/schemas/query2.json', JSON.stringify(schemas.joycity2));
+  writeAppFile(app.appDir, 'config/schemas/ok.json', JSON.stringify(schemas.ok));
+  writeAppFile(
+    app.appDir,
+    'packages/module-parking/tbox.module.json',
+    JSON.stringify({
+      schemaVersion: 1,
+      id: 'module-parking',
+      version: '0.1.0',
+      kind: 'business',
+      declare: { owns: [{ service: 'parking.query' }], consumes: [{ service: 'parking.query', optional: false }] },
+      dependencies: { modules: [] },
+      env: [],
+    }),
+  );
+  return { app, tk: createAppToolkit(app.appDir), schemas };
+}
+
+/** integrations.json 单次写入（每用例独立 harness——零缓存串扰） */
+function writeIntegrations(appDir: string, config: Record<string, unknown>): void {
+  writeAppFile(appDir, 'config/integrations.json', JSON.stringify(config));
+}
+
 describe('views/工厂（O 矩阵核心族）', () => {
   let h: Harness;
 
@@ -259,8 +356,9 @@ 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）
-    // B1 additive：模块 meta title/description 前置（恒发——兜底 name/''）
-    expect(Object.keys(mod)).toEqual(['title', 'description', 'domainKeys', 'integration', 'providerBindings', 'configEditable', 'services']);
+    // v7 词汇统一：模块展示名 name 前置（恒发——兜底 id）
+    // resources 只读镜像（N2 读半边——基座 integrations modules 节无 resources → null 仍恒发）
+    expect(Object.keys(mod)).toEqual(['name', 'description', 'ownedServices', 'integration', 'resources', 'binding', 'configEditable', 'services']);
     const svc = await h.tk.loadService('parking.query');
     expect(Object.keys(svc).some((k) => ['resolution', 'issues', 'contracts'].includes(k))).toBe(false);
     // 静态端点在 <0.9 下照常（永不 503——O13 反例联动）
@@ -513,8 +611,8 @@ describe('O6/O7/O10/O14（FX-3 补全）', () => {
       'packages/provider-multi/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'provider-multi',
-        contributes: {
+        id: 'provider-multi',
+        declare: {
           providers: {
             slots: [
               { service: 'parking.query', provider: 'joycity', implementation: 'joycity-parking@1', credentialType: 'joycity-c', configSchema: 'schemas/query.json' },
@@ -585,8 +683,11 @@ describe('O6/O7/O10/O14（FX-3 补全）', () => {
       // api.md §5 表
       'CREDENTIAL_FILE_MISSING', 'CREDENTIAL_TYPE_MISMATCH', 'IMPL_WITHOUT_PROVIDER', 'INSTANCE_SUPPLY_UNMATCHED',
       'SCHEMA_FILE_MISSING', 'DOMAIN_CONFIG_UNUSED', 'DOMAIN_CONFIG_INVALID', 'INSTANCE_KEY_NOT_REGISTERED',
-      'REALM_SWITCH_HINT', 'WILDCARD_ALIGNMENT', 'VENDOR_NOT_INSTALLED', 'BINDING_UNRESOLVED', 'DOMAIN_KEY_UNMATCHED',
+      'REALM_SWITCH_HINT', 'WILDCARD_ALIGNMENT', 'VENDOR_NOT_INSTALLED', 'BINDING_UNRESOLVED',
       'RESOURCE_TYPE_UNKNOWN', 'RESOURCE_NOT_DECLARED',
+      // v6 additive（api.md §5 表已收口）：MODULE_CONFIG_DEAD / #17 GLOBAL_FIELD_UNDECLARED；
+      // v6 退役：DOMAIN_KEY_UNMATCHED（#14——domains 键退场）
+      'MODULE_CONFIG_DEAD', 'GLOBAL_FIELD_UNDECLARED',
       // 谓词头映射表 additive（检查族编号映射：#3/#4/#5 内联/#13/v4）
       'SLOT_NOT_DECLARED', 'SLOT_NOT_CONFIGURED', 'INLINE_PROVIDER_INVALID', 'MULTI_INSTANCE_NO_DEFAULT', 'INSTANCE_DISABLED',
     ]);
@@ -636,18 +737,18 @@ describe('A2 错误面（P-4 notes 优先 / P-5 畸形包 503）', () => {
   });
 });
 
-describe('D34 多域模块钉死（v4.4 F3）', () => {
-  it('D1 单域回归：domainKeys/providerBindings/configEditable 装配 + integration 原值', async () => {
+describe('v6 所有权族（D34 多域钉死退役 → ownedServices/binding 单数重写）', () => {
+  it('D1 单槽回归：ownedServices/binding/configEditable 装配 + integration 集成位原值', async () => {
     const h2 = harnessWithContracts();
     const mod = await h2.tk.loadModule('module-parking');
-    expect(mod.domainKeys).toEqual(['parking']);
+    expect(mod.ownedServices).toEqual(['parking.query']);
     expect(mod.configEditable).toBe(true);
-    expect(mod.providerBindings).toEqual([{ domain: 'parking', effective: 'wanda', layer: 'module' }]);
+    expect(mod.binding).toEqual({ provider: 'wanda', layer: 'module' });
     expect(mod.integration).toEqual({ provider: 'wanda' });
     h2.app.dispose();
   });
 
-  it('D2 多域模块：GET integration null + providerBindings 双条 + PUT 400 分支①（含 {} 清域）', async () => {
+  it('D2 多域归属合法化（v6 正例化——跨域 owns 单键落位）：binding 单值作用全 owned + PUT 全量替换', async () => {
     const app = createTempApp('tbox-d2-');
     invalidateContractsResolver();
     const store = joinStore(app.appDir, 'contracts');
@@ -658,33 +759,30 @@ describe('D34 多域模块钉死（v4.4 F3）', () => {
       'packages/module-multi/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'module-multi',
+        id: 'module-multi',
         version: '0.1.0',
         kind: 'business',
-        contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'member.account', optional: false }] },
+        declare: { owns: [{ service: 'parking.query' }, { service: 'member.account' }], consumes: [{ service: 'parking.query', 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.ownedServices).toEqual(['member.account', 'parking.query']);
     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' });
+    expect(mod.configEditable).toBe(true);
+    expect(mod.binding).toEqual({ provider: null, layer: null });
+    // v6 写通道：多域归属合法——模块级 provider 单值落 modules[module-multi]
+    const r = await tk.writeModuleIntegration('module-multi', { provider: 'wanda' });
+    expect(r.written).toBe(true);
+    const mod2 = await tk.loadModule('module-multi');
+    expect(mod2.integration).toEqual({ provider: 'wanda' });
+    expect(mod2.binding).toEqual({ provider: 'wanda', layer: 'module' });
     app.dispose();
   });
 
-  it('D3 零域模块：domainKeys [] + PUT 400 分支②', async () => {
+  it('D3 零归属模块：ownedServices [] + configEditable false + PUT 400（zero-ownership）', async () => {
     const app = createTempApp('tbox-d3-');
     invalidateContractsResolver();
     const store = joinStore(app.appDir, 'contracts');
@@ -695,63 +793,95 @@ describe('D34 多域模块钉死（v4.4 F3）', () => {
       'packages/module-zero/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'module-zero',
+        id: 'module-zero',
         version: '0.1.0',
         kind: 'business',
-        contributes: {},
+        declare: {},
         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.ownedServices).toEqual([]);
+    expect(mod.binding).toEqual({ provider: null, layer: null });
     expect(mod.integration).toBeNull();
     await expect(tk.writeModuleIntegration('module-zero', { provider: 'x' })).rejects.toMatchObject({
       code: 'VALIDATION_FAILED',
       httpStatus: 400,
-      message: expect.stringContaining('无服务需求声明'),
+      message: expect.stringContaining('未声明任何 declare.owns'),
     });
     app.dispose();
   });
 
-  it('D4 域键共享（P13）：双方 configEditable false + PUT 400 分支③（他方同域异服务——并集计数）', async () => {
+  it('D4 v6 互斥归属：双模块 owns 同服务 → OWNERSHIP_CONFLICT（先声明胜出）+ 双方可写（归属冲突≠写禁）', 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 =>
+    const manifest = (id: string, service: string): string =>
       JSON.stringify({
         schemaVersion: 1,
-        name,
+        id,
         version: '0.1.0',
         kind: 'business',
-        contributes: { services: [{ service, optional: false }] },
+        declare: { owns: [{ service }], consumes: [{ 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'));
+    writeAppFile(app.appDir, 'packages/module-b/tbox.module.json', manifest('module-b', 'parking.alpha'));
     const tk = createAppToolkit(app.appDir);
+    const walk = tk.walkManifests();
+    // 先声明胜出（packages/ 目录字母序：module-a 先）
+    expect(walk.ownership['parking.alpha']).toBe('module-a');
+    // N4 执法分层：冲突 = declarationIssues error（doctor 面向第三方组合态执法；写通道不拒——归属冲突非写禁）
+    const conflict = walk.declarationIssues.find((i) => i.code === 'OWNERSHIP_CONFLICT');
+    expect(conflict).toBeDefined();
+    expect(conflict!.severity).toBe('error');
+    expect(conflict!.message).toContain('module-b');
+    // 双方 configEditable 均 true（owns>0 唯一判据——v6 无 shared-key 写禁）
     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 共用'),
+    expect(a.configEditable).toBe(true);
+    expect(b.configEditable).toBe(true);
+    app.dispose();
+  });
+
+  it('D6 偏斜态 503 第四分支（P1 标记门）：v5 contracts 假件（无 OWNERSHIP_BINDING_V6）+ v6 toolkit → 503', async () => {
+    const app = createTempApp('tbox-d6-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0', withMarker: false });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    writeAppFile(app.appDir, 'packages/module-parking/tbox.module.json', JSON.stringify({
+      schemaVersion: 1, id: 'module-parking', version: '0.1.0', kind: 'business',
+      declare: { owns: [{ service: 'parking.query' }] },
+    }));
+    const tk = createAppToolkit(app.appDir);
+    // 写路径门控（求值轴同此门——assertContractsUsable 单点）
+    await expect(tk.writeModuleIntegration('module-parking', { provider: 'wanda' })).rejects.toMatchObject({
+      code: 'CONTRACTS_NOT_RESOLVED',
+      httpStatus: 503,
+      message: expect.stringContaining('OWNERSHIP_BINDING_V6'),
     });
+    await expect(tk.loadServiceResolutions()).rejects.toMatchObject({ code: 'CONTRACTS_NOT_RESOLVED', httpStatus: 503 });
+    // 静态端点照常（永不 503——门控 policy at edge 只拦求值/写/migrate）
+    const mod = await tk.loadModule('module-parking');
+    expect(mod.ownedServices).toEqual(['parking.query']);
     app.dispose();
   });
 
-  it('D5 死键扫尾：moduleDomainKey/moduleDomainKeyOf 全链删除（源文件内容断言）', () => {
+  it('D5 死键扫尾：providerBindings/moduleDomainWritable/domain-binding 全链删除（源文件内容断言）', () => {
     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');
+    const exists = (rel: string): boolean => readFileSync(fileURLToPath(new URL(rel, import.meta.url)), 'utf8').length >= 0;
+    void exists;
+    expect(read('../src/views/modules.ts')).not.toContain('providerBindings:');
+    expect(read('../src/integrations/write.ts')).not.toContain('moduleDomain');
+    expect(read('../src/index.ts')).not.toContain('domain-binding');
+    // v6 新面在场（正向锚）
+    expect(read('../src/integrations/module-binding.ts')).toContain('moduleOwnershipWritable');
   });
 });
 
@@ -845,7 +975,7 @@ describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
     const h2 = layerHarness();
     const mod = await h2.tk.loadModule('module-parking', { include: ['integrationSchemas'] });
     expect(mod.integrationSchemas).toEqual({
-      provider: 'wanda', // resolveDomainBinding 单源（domains.parking）
+      provider: 'wanda', // resolveModuleBinding 单源（modules['module-parking']）
       services: {
         'parking.query': { configSchema: h2.schemas.query },
         'parking.payment': { configSchema: h2.schemas.parking },
@@ -874,7 +1004,7 @@ describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
       'config/integrations.json',
       JSON.stringify({
         instances: [{ id: 'mall-bj-01', name: '北京店' }],
-        domains: { parking: { provider: 'wanda' } },
+        modules: { 'module-parking': { provider: 'wanda' } },
         services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
       }),
     );
@@ -903,10 +1033,10 @@ describe('v4.4 include 协议 + Entry.layer + 层级 schema（F4/F5）', () => {
       'packages/module-multi/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'module-multi',
+        id: 'module-multi',
         version: '0.1.0',
         kind: 'business',
-        contributes: { services: [{ service: 'parking.query', optional: false }, { service: 'member.account', optional: false }] },
+        declare: { owns: [{ service: 'parking.query' }], consumes: [{ service: 'parking.query', optional: false }, { service: 'member.account', optional: false }] },
         dependencies: { modules: [] },
         env: [],
       }),
@@ -930,10 +1060,10 @@ describe('模块清单 provider 家族排除（2026-09-16 双缺陷批——供
       'packages/provider-custom/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'provider-custom',
+        id: 'provider-custom',
         version: '0.1.0',
         kind: 'business',
-        contributes: { providers: { slots: [] }, services: [] },
+        declare: { providers: { slots: [] }, consumes: [], owns: [] },
         dependencies: { modules: [] },
         env: [],
       }),
@@ -951,8 +1081,8 @@ describe('模块清单 provider 家族排除（2026-09-16 双缺陷批——供
       join('node_modules', '@tbox.cn', 'app-provider-mock', 'tbox.module.json'),
       JSON.stringify({
         schemaVersion: 1,
-        name: 'provider-mock',
-        contributes: {
+        id: 'provider-mock',
+        declare: {
           providers: { slots: [{ service: 'parking.query', provider: 'mock', implementation: 'mock-parking@1', credentialType: '-' }] },
         },
       }),
@@ -970,11 +1100,11 @@ describe('模块清单 provider 家族排除（2026-09-16 双缺陷批——供
     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.ownedServices).toEqual([]);
     expect(custom.configEditable).toBe(false);
     expect(custom.services).toEqual([]);
     const mock = await h2.tk.loadModule('vendor-mock');
-    expect(mock.domainKeys).toEqual([]);
+    expect(mock.ownedServices).toEqual([]);
     // 供给轴不受影响：provider-mock 槽位照常进 catalog（清单排除不伤聚合）
     const providers = await h2.tk.loadProviders();
     expect(providers.providers.map((p) => p.provider)).toContain('mock');
@@ -983,93 +1113,6 @@ describe('模块清单 provider 家族排除（2026-09-16 双缺陷批——供
 });
 
 describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
-  /** E 系列基座：wanda 双槽（layerHarness 形态）+ joycity 双 impl（O6 形态）+ config/schemas/ok.json
-   *  （O15 形态）+ module-parking demand。schema 内容互异防断言串扰：
-   *  wQuery={baseUrl} / wParking={mallId} / joycity@1={joycityUrl} / joycity@2={endpointV2} / ok={okEndpoint}。
-   *  每用例独立 eHarness()——fixture 全新 temp app，零 file-cache stat 指纹串扰（不取重写+bumpMtime 方案）。 */
-  function eHarness(): {
-    app: TempApp;
-    tk: AppToolkit;
-    schemas: { wQuery: object; wParking: object; joycity1: object; joycity2: object; ok: object };
-  } {
-    const app = createTempApp('tbox-d38-');
-    invalidateContractsResolver();
-    const store = join(app.appDir, 'contracts');
-    writeFakeContractsPackage(store, { version: '0.9.0' });
-    linkContracts(app.appDir, store, { subdir: 'apps/server' });
-    const schemas = {
-      wQuery: { type: 'object', properties: { baseUrl: { type: 'string', format: 'uri' } }, required: ['baseUrl'] },
-      wParking: { type: 'object', properties: { mallId: { type: 'string' } } },
-      joycity1: { type: 'object', properties: { joycityUrl: { type: 'string' } } },
-      joycity2: { type: 'object', properties: { endpointV2: { type: 'string' } } },
-      ok: { type: 'object', properties: { okEndpoint: { type: 'string' } } },
-    };
-    writeAppFile(
-      app.appDir,
-      'packages/provider-w/tbox.module.json',
-      JSON.stringify({
-        schemaVersion: 1,
-        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' } } });
@@ -1139,12 +1182,12 @@ describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
 
   it('E6 域级联（分支①）+ ghost 域厂商诚实态', async () => {
     const h = eHarness();
-    writeIntegrations(h.app.appDir, { domains: { parking: { provider: 'wanda' } }, services: { 'parking.query': {} } });
+    writeIntegrations(h.app.appDir, { modules: { 'module-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': {} } });
+    writeIntegrations(h2.app.appDir, { modules: { 'module-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();
@@ -1216,10 +1259,10 @@ describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
   });
 
   it('E14 malformed → 整字段 null（不落域级联——分支回归锚）', async () => {
-    // ① 坏对象（缺 credentialType）——配 domains 佐证未走域级联
+    // ① 坏对象（缺 credentialType）——配 modules 佐证未走模块级联
     const h = eHarness();
     writeIntegrations(h.app.appDir, {
-      domains: { parking: { provider: 'wanda' } },
+      modules: { 'module-parking': { provider: 'wanda' } },
       services: { 'parking.query': { provider: { provider: 'my-api' } } },
     });
     const bad = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
@@ -1227,7 +1270,7 @@ describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
     // ② provider: null（谓词 #5 同判 INLINE_PROVIDER_INVALID——坏形态非缺席）
     const h2 = eHarness();
     writeIntegrations(h2.app.appDir, {
-      domains: { parking: { provider: 'wanda' } },
+      modules: { 'module-parking': { provider: 'wanda' } },
       services: { 'parking.query': { provider: null } },
     });
     const nul = await h2.tk.loadService('parking.query', { include: ['integrationSchemas'] });
@@ -1239,7 +1282,7 @@ describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
   it('E15 provider 空串 → 走域级联（非 null）', async () => {
     const h = eHarness();
     writeIntegrations(h.app.appDir, {
-      domains: { parking: { provider: 'wanda' } },
+      modules: { 'module-parking': { provider: 'wanda' } },
       services: { 'parking.query': { provider: '' } },
     });
     const view = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
@@ -1248,6 +1291,170 @@ describe('v4.7 服务级 include（D38——生效绑定单体）', () => {
   });
 });
 
+/**
+ * v5.1 D39 测试族（服务轴向假想绑定——?serviceProvider= 表单双投影重定向）。
+ * 供给矩阵（eHarness）：wanda 供给 {parking.query, parking.payment}；joycity 仅供给
+ * {parking.query}（provider-multi 双 impl 皆 query）——用例 (厂商 × 服务) 选型须对照本矩阵：
+ * catalog-miss 形态（D39-7）与豁免链正例（D39-6）不得混淆供给边界。每用例独立 eHarness
+ * （零 file-cache stat 指纹串扰）；D39-8/D39-9 用 layerHarness（x-tbox-global 标记 fixture）。
+ */
+describe('v5.1 D39（服务轴向假想绑定 serviceProvider）', () => {
+  it('D39-1 假想 happy + I1：双投影切 joycity 且 provider 一致 + 单键边界正例', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const both = ['integrationSchemas', 'integrationFieldRegistry'];
+    const v = await h.tk.loadService('parking.query', { include: both, serviceProvider: 'joycity' });
+    // I1：双投影同源同口径（fields = joycity schema 字段——catalog 复合键声明序首个 = @1 的 joycityUrl）
+    expect(v.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h.schemas.joycity1 });
+    expect(v.integrationFieldRegistry?.provider).toBe('joycity');
+    expect(v.integrationFieldRegistry!.fields.map((f) => f.key)).toEqual(['joycityUrl']);
+    // 单键边界正例：仅 integrationSchemas + 轴参 → 200 假想计算；registry 未请求 = 缺席（S7-1 尾部先例）
+    const only = await h.tk.loadService('parking.query', { include: ['integrationSchemas'], serviceProvider: 'joycity' });
+    expect(only.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h.schemas.joycity1 });
+    expect('integrationFieldRegistry' in only).toBe(false);
+    h.app.dispose();
+  });
+
+  it('D39-2 I2 锁：integration/suppliedBy/defaults 恒实际态', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda', config: { baseUrl: 'https://w.example' } } } });
+    const base = await h.tk.loadService('parking.query');
+    const v = await h.tk.loadService('parking.query', { include: ['integrationSchemas', 'integrationFieldRegistry'], serviceProvider: 'joycity' });
+    expect(v.integration).toEqual(base.integration); // 文件逐字原值不被重定向（预览不产生「已保存」误导）
+    expect(v.suppliedBy).toEqual(base.suppliedBy); // catalog 静态切片恒实际
+    expect(v.defaults).toEqual(base.defaults); // manifest 预填恒实际
+    expect(v.integrationSchemas?.provider).toBe('joycity'); // 对照：表单层已重定向
+    h.app.dispose();
+  });
+
+  it('D39-3 I3 锁 + 错轴静默忽略：空串 ≡ 缺席 ≡ 实际；appProvider/moduleProvider 被无视', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const empty = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'], serviceProvider: '' });
+    const absent = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'] });
+    expect(empty.integrationFieldRegistry).toEqual(absent.integrationFieldRegistry);
+    // 错轴参数（变量绕过多余属性检查——运行时按名读取，appProvider/moduleProvider 被无视；S7-4 先例镜像）
+    const opts = { include: ['integrationFieldRegistry'], serviceProvider: '', appProvider: 'joycity', moduleProvider: 'joycity' };
+    const wrongAxis = await h.tk.loadService('parking.query', opts);
+    expect(wrongAxis.integrationFieldRegistry).toEqual(absent.integrationFieldRegistry);
+    h.app.dispose();
+  });
+
+  it('D39-4 轴参严检矩阵：400 先于 404（镜像 S7-1 形态）', async () => {
+    const h = eHarness();
+    await expect(h.tk.loadService('parking.query', { serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['serviceProvider'],
+    });
+    await expect(h.tk.loadService('parking.query', { include: [], serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['serviceProvider'],
+    });
+    // 先于 404：ghost 服务 + 无表单键轴参 → 400（非 SERVICE_NOT_FOUND）；表单键在场 → 放行至 404
+    await expect(h.tk.loadService('ghost', { serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'VALIDATION_FAILED', httpStatus: 400, fields: ['serviceProvider'],
+    });
+    await expect(h.tk.loadService('ghost', { include: ['integrationSchemas'], serviceProvider: 'x' })).rejects.toMatchObject({
+      code: 'SERVICE_NOT_FOUND', httpStatus: 404,
+    });
+    h.app.dispose();
+  });
+
+  it('D39-5 同构承诺锁：假想 ≡ PUT 改写 provider 后实读（双投影；S6 写通道先例）', async () => {
+    const h = eHarness();
+    const both = ['integrationSchemas', 'integrationFieldRegistry'];
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const hyp = await h.tk.loadService('parking.query', { include: both, serviceProvider: 'joycity' });
+    // 状态演进全经 toolkit 写通道——写后本实例缓存即刻失效，免外部写缓存关注
+    const cur = await h.tk.loadService('parking.query');
+    const w = await h.tk.writeServiceIntegration('parking.query', { ...cur.integration!, provider: 'joycity' });
+    expect(w.written).toBe(true);
+    const act = await h.tk.loadService('parking.query', { include: both });
+    expect(act.integrationSchemas).toEqual(hyp.integrationSchemas);
+    expect(act.integrationFieldRegistry).toEqual(hyp.integrationFieldRegistry);
+    h.app.dispose();
+  });
+
+  it('D39-6 假想豁免链三分支：malformed 不污染 / 内联不读取无 H9 / 未绑定仍非 null', async () => {
+    // ① malformed 节点（E14 形态）+ 假想 → 非 null（短路在节点读取之前——坏形态只影响实际态投影）
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, {
+      modules: { 'module-parking': { provider: 'wanda' } },
+      services: { 'parking.query': { provider: { provider: 'my-api' } } },
+    });
+    const bad = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'], serviceProvider: 'joycity' });
+    expect(bad.integrationFieldRegistry).not.toBeNull();
+    expect(bad.integrationFieldRegistry!.provider).toBe('joycity');
+    // 实际态对照：同坏节点无轴参 → 整字段 null（E14 双态互证——预览与坏文件解耦）
+    const badActual = await h.tk.loadService('parking.query', { include: ['integrationSchemas'] });
+    expect(badActual.integrationSchemas).toBeNull();
+    h.app.dispose();
+    // ② 内联 ref 逃逸节点（E4 形态）+ 假想 → 无 H9 400（短路不读节点内联 ref——换厂商即离开内联）
+    const h2 = eHarness();
+    writeIntegrations(h2.app.appDir, {
+      services: { 'parking.query': { provider: { provider: 'my-api', credentialType: '-', configSchema: 'config/schemas-evil/x.json' } } },
+    });
+    const inline = await h2.tk.loadService('parking.query', { include: ['integrationSchemas'], serviceProvider: 'joycity' });
+    expect(inline.integrationSchemas).toEqual({ provider: 'joycity', configSchema: h2.schemas.joycity1 });
+    h2.app.dispose();
+    // ③ 全链未绑定（E8 形态）+ 假想 → 仍非 null（服务轴恒可写——无 module 轴零归属豁免形态）；
+    //    wanda 供给 payment（供给矩阵）→ mallId 字段在场
+    const h3 = eHarness();
+    writeIntegrations(h3.app.appDir, { services: { 'parking.payment': {} } });
+    const unbound = await h3.tk.loadService('parking.payment', { include: ['integrationFieldRegistry'], serviceProvider: 'wanda' });
+    // fields[].schema = 字段子 schema（非整文件 schema——G 批锁 :1777 同型）
+    expect(unbound.integrationFieldRegistry).toEqual({
+      provider: 'wanda', schemaless: [], unsupplied: [], additionalPropertiesAllowed: true,
+      fields: [{ key: 'mallId', schema: { type: 'string' }, sources: [{ service: 'parking.payment', required: false }], global: false }],
+    });
+    h3.app.dispose();
+  });
+
+  it('D39-7 catalog miss：假想未知厂商 → 非 null 空集（schemaless=[service]）', async () => {
+    const h = eHarness();
+    writeIntegrations(h.app.appDir, { services: { 'parking.query': { provider: 'wanda' } } });
+    const v = await h.tk.loadService('parking.query', { include: ['integrationSchemas', 'integrationFieldRegistry'], serviceProvider: 'ghost-vendor' });
+    expect(v.integrationSchemas).toEqual({ provider: 'ghost-vendor', configSchema: null });
+    expect(v.integrationFieldRegistry).toEqual({
+      provider: 'ghost-vendor', schemaless: ['parking.query'], unsupplied: [], additionalPropertiesAllowed: true, fields: [],
+    });
+    h.app.dispose();
+  });
+
+  it('D39-8 global 旗标假想透传：标记位如实（layerHarness——true 正例 + 未标记 false 不过滤）', async () => {
+    const h = layerHarness();
+    // joycity 供给 parking.query → 假想后 fields = joycity query schema 字段（fixture 全标记 → global:true）
+    const joy = await h.tk.loadService('parking.query', { include: ['integrationFieldRegistry'], serviceProvider: 'joycity' });
+    expect(joy.integrationFieldRegistry!.provider).toBe('joycity');
+    expect(joy.integrationFieldRegistry!.fields.length).toBeGreaterThan(0);
+    expect(joy.integrationFieldRegistry!.fields.every((f) => f.global)).toBe(true);
+    // wanda 供给 parking.payment → mallId global:true / parkLotId global:false 在场（服务轴不过滤——G 批语义假想不变）；
+    // payment 先配置入词汇（P9：契约包 ∪ 已配置——layerHarness 初始 integrations.json 未配置 payment；
+    // 覆盖写后 payment 节点 {} 实际态级联双缺 → null，假想 wanda 短路仍非 null——豁免链③同型，S7-7 外部写先例）
+    writeAppFile(h.app.appDir, 'config/integrations.json', JSON.stringify({ services: { 'parking.payment': {} } }));
+    const wan = await h.tk.loadService('parking.payment', { include: ['integrationFieldRegistry'], serviceProvider: 'wanda' });
+    expect(wan.integrationFieldRegistry!.fields.map((f) => f.key).sort()).toEqual(['mallId', 'parkLotId']);
+    expect(wan.integrationFieldRegistry!.fields.find((f) => f.key === 'mallId')!.global).toBe(true);
+    expect(wan.integrationFieldRegistry!.fields.find((f) => f.key === 'parkLotId')!.global).toBe(false);
+    h.app.dispose();
+  });
+
+  it('D39-9 单源锁：loadServiceFieldRegistry(snap,s,X) ≡ buildIntegrationFieldRegistry over 链函数', async () => {
+    const h = layerHarness();
+    const { loadViewSnapshotSync } = await import('../src/views/context.js');
+    const snap = loadViewSnapshotSync({ appDir: h.app.appDir }, await h.tk.resolveContracts());
+    const X = 'joycity';
+    const reg = loadServiceFieldRegistry(snap, 'parking.query', X);
+    const schemas = loadServiceIntegrationSchemas(snap, 'parking.query', X);
+    expect(schemas).not.toBeNull();
+    // 结构性断言（依赖契约锁——registry 旁路重取 schema 破 I1 即刻红；S8 同族意图）
+    const manual = buildIntegrationFieldRegistry({
+      provider: schemas!.provider,
+      services: { 'parking.query': { configSchema: schemas!.configSchema } },
+    });
+    expect(reg).toEqual(manual);
+    h.app.dispose();
+  });
+});
+
 /**
  * v4.6 D36/D37 测试族（S5 接续 S1-S4）：S5a 纯代数（直调合成 layer 字面量，零 fs）/
  * S5b 接线序 + 等价锁 / S6 同构（假想 ≡ 写后实读）/ S7 边界（400·null 两态·I2·空集）/
@@ -1264,15 +1471,15 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     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)] },
+      { key: 'baseUrl', schema: { type: 'string', format: 'uri', 'x-tbox-global': true }, global: true, sources: [src('parking.query', true), src('parking.payment', false)] },
+      { key: 'lotId', schema: null, global: true, sources: [src('parking.query', true), src('parking.payment', false)] },
+      { key: 'env', schema: { type: 'string', enum: ['dev', 'staging', 'prod'], 'x-tbox-global': true }, global: true, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'envMixed', schema: null, global: true, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'meta', schema: null, global: true, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'options', schema: { type: 'object', properties: { x: { type: 'string', 'x-tbox-global': true } }, 'x-tbox-global': true }, global: true, sources: [src('parking.query', false), src('parking.payment', true)] },
+      { key: 'untyped', schema: null, global: true, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'timeout', schema: null, global: true, sources: [src('parking.query', false), src('parking.payment', false)] },
+      { key: 'apiKey', schema: { type: 'string', 'x-tbox-global': true }, global: true, sources: [src('parking.payment', true)] },
     ],
   };
 
@@ -1283,15 +1490,15 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     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)] },
+      { key: 'apiKey', schema: { type: 'string', 'x-tbox-global': true }, global: true, sources: [src('parking.payment', true)] },
+      { key: 'baseUrl', schema: { type: 'string', 'x-tbox-global': true }, global: true, sources: [src('parking.payment', false), src('parking.query', true)] },
+      { key: 'lotId', schema: null, global: true, sources: [src('parking.payment', false), src('parking.query', true)] },
+      { key: 'env', schema: { type: 'string', enum: ['prod', 'dev', 'staging'], 'x-tbox-global': true }, global: true, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'envMixed', schema: null, global: true, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'meta', schema: null, global: true, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'options', schema: { type: 'object', properties: { x: { type: 'string', 'x-tbox-global': true } }, 'x-tbox-global': true }, global: true, sources: [src('parking.payment', true), src('parking.query', false)] },
+      { key: 'untyped', schema: null, global: true, sources: [src('parking.payment', false), src('parking.query', false)] },
+      { key: 'timeout', schema: null, global: true, sources: [src('parking.payment', false), src('parking.query', false)] },
     ],
   };
 
@@ -1301,15 +1508,15 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
   /** 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]） */
+  /** E5：实际态（无轴参，wanda；scope = [query, payment]）——parkLotId 未标记 global 被表单收窄（G 批负例） */
   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)] },
+      { key: 'baseUrl', schema: { type: 'string', format: 'uri', 'x-tbox-global': true }, global: true, sources: [src('parking.query', true)] },
+      { key: 'mallId', schema: { type: 'string', 'x-tbox-global': true }, global: true, sources: [src('parking.payment', false)] },
     ],
   };
 
@@ -1391,7 +1598,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
 
   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)] });
+    expect(single.fields[0]).toEqual({ key: 'only', schema: { type: 'string', enum: ['z'] }, global: false, 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' } } } },
@@ -1447,7 +1654,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     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 先）
+    expect(appInc.integrationFieldRegistry?.fields[1].schema).toEqual({ type: 'string', 'x-tbox-global': true }); // 首源漂移（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'] });
@@ -1485,7 +1692,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     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
+    // ② 跟随应用级（root.provider=wanda）≡ 清模块位（N1 删 modules['module-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', {});
@@ -1498,7 +1705,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     h2.app.dispose();
   });
 
-  it('S6 app 轴同构：假想 ≡ 写 root {provider:joycity} 后实读（domains/services 不受扰）', async () => {
+  it('S6 app 轴同构：假想 ≡ 写 root {provider:joycity} 后实读（modules/services 不受扰）', async () => {
     const h2 = layerHarness();
     const hyp = await h2.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'joycity' });
     const cur = await h2.tk.loadApp();
@@ -1557,7 +1764,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
       moduleProvider: 'joycity',
     });
     expect(v.integration).toEqual({ provider: 'wanda' });
-    expect(v.providerBindings).toEqual([{ domain: 'parking', effective: 'wanda', layer: 'module' }]);
+    expect(v.binding).toEqual({ provider: 'wanda', layer: 'module' });
     expect(v.configEditable).toBe(true);
     expect(v.integrationFieldRegistry?.provider).toBe('joycity'); // 表单层重定向
     expect(v.integrationSchemas?.provider).toBe('joycity');
@@ -1573,7 +1780,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
       'config/integrations.json',
       JSON.stringify({
         instances: [{ id: 'mall-bj-01', name: '北京店' }],
-        domains: { parking: { provider: 'joycity' } },
+        modules: { 'module-parking': { provider: 'joycity' } },
         services: { 'parking.query': { provider: 'wanda', implementation: 'wanda-parking@1' } },
       }),
     );
@@ -1583,7 +1790,7 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     ).toBeNull();
     h3.app.dispose();
 
-    // 可写未绑定（无 domains 无 root.provider——无轴参 → null）
+    // 可写未绑定（无 modules 位无 root.provider——无轴参 → null）
     const h4 = layerHarness();
     writeAppFile(
       h4.app.appDir,
@@ -1599,29 +1806,39 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     expect(unbound.configEditable).toBe(true);
     h4.app.dispose();
 
-    // D34 三形态（多域/零域/共享键——带 moduleProvider 仍 null）
+    // v6 形态（D34 三形态退役）：零归属 → null（带 moduleProvider 仍 null——不豁免）；
+    // 多域/跨域归属合法化 → 非 null（override 可计算；unsupplied 回填非供给归属槽）
     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: [] });
+    const manifest34 = (id: string, services: Array<{ service: string; optional: boolean }>): string =>
+      JSON.stringify({ schemaVersion: 1, id, version: '0.1.0', kind: 'business', declare: { owns: services.map((x) => ({ service: x.service })), consumes: 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: [] }),
+      JSON.stringify({ schemaVersion: 1, id: 'module-zero', version: '0.1.0', kind: 'business', declare: {}, 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();
-    }
+    // 零归属：null（唯一 null 形态——override 不豁免）
+    const zero = await tk34.loadModule('module-zero', { include: ['integrationFieldRegistry', 'integrationSchemas'], moduleProvider: 'joycity' });
+    expect(zero.integrationFieldRegistry).toBeNull();
+    expect(zero.integrationSchemas).toBeNull();
+    expect(zero.configEditable).toBe(false);
+    // 多域归属：可写（owns>0）——override joycity 供给 parking.query（member.account → unsupplied）
+    const multi = await tk34.loadModule('module-multi', { include: ['integrationFieldRegistry', 'integrationSchemas'], moduleProvider: 'joycity' });
+    expect(multi.configEditable).toBe(true);
+    expect(multi.integrationSchemas?.provider).toBe('joycity');
+    // d34 fixture 无 provider 包 → joycity 零供给 → 双 owned 全回填（manifest owns 序）
+    expect(multi.integrationFieldRegistry?.unsupplied).toEqual(['parking.query', 'member.account']);
+    // 跨域归属：scope = owns ∩ 供给 = []（parking.alpha 非 joycity 供给）→ 非 null 空集 + unsupplied 全回填
+    const a = await tk34.loadModule('module-a', { include: ['integrationFieldRegistry'], moduleProvider: 'joycity' });
+    expect(a.integrationFieldRegistry).toEqual({ provider: 'joycity', schemaless: [], unsupplied: ['parking.alpha'], additionalPropertiesAllowed: true, fields: [] });
     d34.dispose();
   });
 
@@ -1682,7 +1899,13 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
       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());
+      // G 批收窄互证：表单键 ⊆ 声明键，且声明侧标记键 ≡ 表单键（未标记键落 ExtraFields——不进 fields）
+      const marked = declared.filter((k) => {
+        const sub = (props as Record<string, Record<string, unknown>>)[k];
+        return !!sub && sub['x-tbox-global'] === true;
+      });
+      expect(rev.every((k) => declared.includes(k)), s).toBe(true);
+      expect([...marked].sort(), s).toEqual([...rev].sort());
     }
     for (const s of registry.schemaless) expect(layer.services[s]?.configSchema).toBeNull();
     // unsupplied ≡ demand − scope 键集
@@ -1692,6 +1915,39 @@ describe('v4.6 D36/D37（integrationFieldRegistry + 轴向假想绑定）', () =
     h2.app.dispose();
   });
 
+  it('G 批收窄负例（P16 复合可见面）：未标记键在 layer.properties 在场、registry.fields 不收（wanda 实际态 parkLotId）', async () => {
+    const h2 = layerHarness();
+    const v = await h2.tk.loadModule('module-parking', { include: ['integrationSchemas', 'integrationFieldRegistry'] });
+    const layer = v.integrationSchemas!;
+    const registry = v.integrationFieldRegistry!;
+    expect(layer.provider).toBe('wanda');
+    const parkingProps = (layer.services['parking.payment'].configSchema as Record<string, Record<string, unknown>>).properties as Record<string, Record<string, unknown>>;
+    expect(parkingProps.mallId['x-tbox-global']).toBe(true);
+    expect(parkingProps.parkLotId).toBeDefined(); // 原始投影在场
+    expect(parkingProps.parkLotId['x-tbox-global']).toBeUndefined();
+    expect(registry.fields.some((f) => f.key === 'parkLotId')).toBe(false); // 表单收窄不收
+    expect(registry.fields.some((f) => f.key === 'mallId')).toBe(true);
+    // app 轴同律（足迹含 query——baseUrl 标记在场）
+    const appV = await h2.tk.loadApp({ include: ['integrationSchemas', 'integrationFieldRegistry'] });
+    expect(appV.integrationFieldRegistry!.fields.some((f) => f.key === 'baseUrl')).toBe(true);
+    h2.app.dispose();
+  });
+
+  it('G 批服务轴不过滤锁：loadServiceFieldRegistry 全字段带旗标（unmarked → global:false 在场）', async () => {
+    const h2 = layerHarness();
+    const snap = (await import('../src/views/context.js')).loadViewSnapshotSync({ appDir: h2.app.appDir }, await h2.tk.resolveContracts());
+    const reg = loadServiceFieldRegistry(snap, 'parking.payment');
+    expect(reg).not.toBeNull();
+    const keys = reg!.fields.map((f) => f.key).sort();
+    expect(keys).toEqual(['mallId', 'parkLotId']); // 服务轴全量（未标记也入列——旗标 false 如实）
+    const lot = reg!.fields.find((f) => f.key === 'parkLotId')!;
+    expect(lot.global).toBe(false);
+    expect(lot.schema).toEqual({ type: 'string', title: '车场组' }); // 无标记污染
+    const mall = reg!.fields.find((f) => f.key === 'mallId')!;
+    expect(mall.global).toBe(true);
+    h2.app.dispose();
+  });
+
   it('S8 app 轴：unsupplied ≡ []（结构性：足迹 ⊆ 供给）', async () => {
     const h2 = layerHarness();
     const v = await h2.tk.loadApp({ include: ['integrationFieldRegistry'], appProvider: 'joycity' });
@@ -1715,8 +1971,8 @@ describe('B1 展示名链', () => {
       version: '0.9.0',
       slots: ['parking.query', 'auth.alipay-login', 'mall.info'],
       meta: {
-        'parking.query': { title: '停车查询', description: '费用报价、车场信息、可享权益' },
-        'auth.alipay-login': { title: '支付宝登录' },
+        'parking.query': { name: '停车查询', description: '费用报价、车场信息、可享权益' },
+        'auth.alipay-login': { name: '支付宝登录' },
       },
     });
     linkContracts(app.appDir, store, { subdir: 'apps/server' });
@@ -1726,14 +1982,15 @@ describe('B1 展示名链', () => {
       'packages/module-parking/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'module-parking',
+        id: 'module-parking',
         version: '0.1.0',
         kind: 'business',
-        title: '停车缴费',
+        name: '停车缴费',
         description: '车辆查询与绑定、停车费用查询、缴费支付与开票',
-        contributes: {
-          // demand meta title=车位查询——应被词汇 meta 停车查询压过（词汇主源）
-          services: [{ service: 'parking.query', optional: false, title: '车位查询' }],
+        declare: {
+          owns: [{ service: 'parking.query' }],
+          // demand meta name=车位查询——应被词汇 meta 停车查询压过（词汇主源）
+          consumes: [{ service: 'parking.query', optional: false, name: '车位查询' }],
         },
         dependencies: { modules: [] },
         env: [],
@@ -1745,12 +2002,12 @@ describe('B1 展示名链', () => {
       'packages/provider-demo/tbox.module.json',
       JSON.stringify({
         schemaVersion: 1,
-        name: 'provider-demo',
+        id: 'provider-demo',
         version: '0.1.0',
         kind: 'third-party',
-        title: '万达',
+        name: '万达',
         description: '万达厂商集成',
-        contributes: {
+        declare: {
           providers: {
             slots: [{ service: 'parking.query', provider: 'wanda', implementation: 'wanda-parking@1', credentialType: 'apikey' }],
           },
@@ -1766,49 +2023,89 @@ describe('B1 展示名链', () => {
   it('T1 resolveServiceDisplay 三态：词汇 > demand > id；逐字段回落（词汇仅 description 时 demand title 可达）', () => {
     const walk = {
       slotMeta: {
-        'a.b': { title: '甲', description: '甲描述' },
+        'a.b': { name: '甲', description: '甲描述' },
         'c.d': { description: '只有描述' },
       },
       catalog: {
         services: {
-          'a.b': { title: '乙', description: '乙描述' },
-          'c.d': { title: '丙' },
+          'a.b': { name: '乙', description: '乙描述' },
+          'c.d': { name: '丙' },
         },
       },
     } as unknown as WalkManifestsResult;
     // 词汇全量在场 → 词汇胜出
-    expect(resolveServiceDisplay(walk, 'a.b')).toEqual({ title: '甲', description: '甲描述' });
+    expect(resolveServiceDisplay(walk, 'a.b')).toEqual({ name: '甲', description: '甲描述' });
     // 词汇仅 description → title 回落 demand、description 取词汇（逐字段回落）
-    expect(resolveServiceDisplay(walk, 'c.d')).toEqual({ title: '丙', description: '只有描述' });
+    expect(resolveServiceDisplay(walk, 'c.d')).toEqual({ name: '丙', description: '只有描述' });
     // 双缺席 → demand
-    expect(resolveServiceDisplay(walk, 'e.f')).toEqual({ title: 'e.f' });
+    expect(resolveServiceDisplay(walk, 'e.f')).toEqual({ name: 'e.f' });
     // 双双缺席 → id 兜底（title 恒有值）
     const bare = { slotMeta: {}, catalog: { services: {} } } as unknown as WalkManifestsResult;
-    expect(resolveServiceDisplay(bare, 'x.y')).toEqual({ title: 'x.y' });
+    expect(resolveServiceDisplay(bare, 'x.y')).toEqual({ name: '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?.name).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?.name).toBe('module-parking');
     expect(bare?.description).toBe('');
     h3.app.dispose();
     h2.app.dispose();
   });
 
+  it('T2b loadModulesView：hidden 模块默认过滤；includeHidden 可见 + 徽标；detail 恒 200 不滤', async () => {
+    const app = createTempApp('tbox-hidden-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    const manifest = (id: string, name: string, extra: Record<string, unknown> = {}): string =>
+      JSON.stringify({
+        schemaVersion: 1,
+        id,
+        version: '0.1.0',
+        kind: 'business',
+        name,
+        declare: { owns: [], consumes: [] },
+        dependencies: { modules: [] },
+        env: [],
+        ...extra,
+      });
+    mkdirSync(join(app.appDir, 'packages', 'module-visible'), { recursive: true });
+    writeAppFile(app.appDir, 'packages/module-visible/tbox.module.json', manifest('module-visible', '可见模块'));
+    mkdirSync(join(app.appDir, 'packages', 'module-secret'), { recursive: true });
+    writeAppFile(app.appDir, 'packages/module-secret/tbox.module.json', manifest('module-secret', '隐藏模块', { hidden: true }));
+
+    const tk = createAppToolkit(app.appDir);
+    // 默认：hidden 模块不进清单（可见模块无 hidden 键——additive 纪律）
+    const def = await tk.loadModules();
+    expect(def.modules.map((m) => m.id)).toEqual(['module-visible']);
+    expect(def.modules[0]).not.toHaveProperty('hidden');
+    // includeHidden = true：可见并携带 hidden: true 徽标
+    const inc = await tk.loadModules({ includeHidden: true });
+    expect(inc.modules.map((m) => m.id).sort()).toEqual(['module-secret', 'module-visible']);
+    expect(inc.modules.find((m) => m.id === 'module-secret')?.hidden).toBe(true);
+    expect(inc.modules.find((m) => m.id === 'module-visible')).not.toHaveProperty('hidden');
+    // detail 端点恒 200 不滤——视图携带 hidden 徽标
+    const detail = await tk.loadModule('module-secret');
+    expect(detail.name).toBe('隐藏模块');
+    expect(detail.hidden).toBe(true);
+    app.dispose();
+  });
+
   it('T3 loadModuleDetailView：meta 恒发；services[] 词汇优先（demand 车位查询被词汇停车查询压过——防漂移锁）', async () => {
     const h2 = displayHarness();
     const v = await h2.tk.loadModule('module-parking');
-    expect(v.title).toBe('停车缴费');
+    expect(v.name).toBe('停车缴费');
     expect(v.description).toContain('停车费用查询');
     const svc = v.services.find((s) => s.service === 'parking.query');
-    expect(svc?.title).toBe('停车查询');
+    expect(svc?.name).toBe('停车查询');
     expect(svc?.description).toBe('费用报价、车场信息、可享权益');
     expect(svc?.required).toBe(true);
     h2.app.dispose();
@@ -1821,22 +2118,63 @@ describe('B1 展示名链', () => {
     h2.app.dispose();
   });
 
+  // ── v7 双键寻址（factory 级——resolve-key 单点经七方法入口；id 优先/展示名兜底/多命中 404）──
+
+  it('v7-DK1 模块双键：展示名「停车缴费」≡ id module-parking（同一视图）；读侧 id 恒优先', async () => {
+    const h2 = displayHarness();
+    const byName = await h2.tk.loadModule('停车缴费');
+    const byId = await h2.tk.loadModule('module-parking');
+    expect(byName.name).toBe(byId.name);
+    expect(byName.ownedServices).toEqual(byId.ownedServices);
+    h2.app.dispose();
+  });
+
+  it('v7-DK2 服务双键：展示名「停车查询」→ parking.query（词汇 meta 源）；含 include 富化同键', async () => {
+    const h2 = displayHarness();
+    const byName = await h2.tk.loadService('停车查询');
+    expect(byName.service).toBe('parking.query');
+    expect(byName.name).toBe('停车查询');
+    h2.app.dispose();
+  });
+
+  it('v7-DK3 多展示名命中 → 404 带候选（两模块同名；fail-visible 不静默取首）', async () => {
+    const app = createTempApp('tbox-dk3-');
+    invalidateContractsResolver();
+    const store = joinStore(app.appDir, 'contracts');
+    writeFakeContractsPackage(store, { version: '0.9.0' });
+    linkContracts(app.appDir, store, { subdir: 'apps/server' });
+    const manifest = (id: string): string =>
+      JSON.stringify({ schemaVersion: 1, id, name: '同名模块', version: '0.1.0', kind: 'business', declare: {}, dependencies: { modules: [] }, env: [] });
+    writeAppFile(app.appDir, 'packages/module-a/tbox.module.json', manifest('module-a'));
+    writeAppFile(app.appDir, 'packages/module-b/tbox.module.json', manifest('module-b'));
+    const tk = createAppToolkit(app.appDir);
+    await expect(tk.loadModule('同名模块')).rejects.toMatchObject({
+      code: 'MODULE_NOT_FOUND',
+      httpStatus: 404,
+      message: expect.stringContaining('id=module-a'),
+    });
+    await expect(tk.loadModule('同名模块')).rejects.toMatchObject({
+      message: expect.stringContaining('改用模块 id'),
+    });
+    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']?.name).toBe('支付宝登录');
+    expect(byKey['mall.info']?.name).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');
+    expect((await h2.tk.loadService('parking.query')).name).toBe('停车查询');
+    expect((await h2.tk.loadService('mall.info')).name).toBe('mall.info');
     h2.app.dispose();
   });
 
@@ -1844,11 +2182,11 @@ describe('B1 展示名链', () => {
     const h2 = displayHarness();
     const list = await h2.tk.loadProviders();
     const wanda = list.providers.find((p) => p.provider === 'wanda');
-    expect(wanda?.title).toBe('万达');
+    expect(wanda?.name).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.name).toBe('万达');
+    expect(detail.services['parking.query']?.name).toBe('停车查询');
     expect(detail.services['parking.query']?.description).toBe('费用报价、车场信息、可享权益');
     h2.app.dispose();
   });