@tbox.cn/app-toolkit 0.4.0 → 0.6.0

package/src/integrations/write.ts

@@ -19,8 +19,9 @@ import {
 import type { IntegrationServiceIssue } from './predicate.js';
 import { checkInstanceKeys } from './predicate.js';
 import { isKnownService } from './read.js';
-import { displayOwnerName, moduleDomainWritable } from './domain-binding.js';
+import { moduleOwnershipWritable } from './module-binding.js';
 import { AppToolkitError } from '../core/errors.js';
+import { MODULE_INTEGRATION_NODE_KEYS } from '../dto.js';
 
 /**
  * 写核心（C3-4 write；FX-1c 管线重排——F3 九步定序 + D-B2 语义 + F4 输入扩位）：
@@ -231,7 +232,8 @@ export interface WriteCore {
   warmup(): Promise<void>;
   /** PUT /app/integration（root 节点全集） */
   applyApp(node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
-  /** PUT /modules/:module/integration（domains 换算；N1 {} 删域键；v4.4 D34 写守卫单源） */
+  /** PUT /modules/:module/integration（v6 modules[owner] 集成位；键集纪律见 MODULE_INTEGRATION_NODE_KEYS；
+   *  N1 {} 清 provider/config 保 resources；moduleOwnershipWritable 写守卫单源） */
   applyModule(moduleId: string, node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
   /** PUT /services/:service/integration（整节点含 instances map；N3 {} 不归一化；v4.4 A2 身份判据） */
   applyService(service: string, node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
@@ -259,6 +261,10 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
       cache?.invalidate([join(appDir, INTEGRATIONS_FILE)]);
     }
     const written = integrationsWritten || credentialsWritten;
+    // 孤儿凭据写后对账（api.md §4.13 承诺追平——「覆盖 DELETE 与 PUT 替换两类来源」；三 PUT 写路径
+    // finalize 单点收口，未来第四写方法自动继承）。dryRun（written 蕴含 !dryRun）与 no-diff
+    // （finalize 前短路 return）天然跳过；applyModule modules 节无凭据键——对账恒零新增，无害捎带。
+    if (written) issues.push(...reconcileOrphanCredentials(appDir));
     const restartScheduled = written && onApplied !== undefined;
     if (restartScheduled) onApplied?.();
     const files: string[] = [];
@@ -336,7 +342,7 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
           message: 'config/integrations.json 缺席——已物化骨架（写时自动初始化；R13 语义翻转提示）',
         });
       }
-      // root 全量替换（D14 无例外语义）：缺席根键删除（services/domains/modules 域不在根键集——随 base 保留），
+      // root 全量替换（D14 无例外语义）：缺席根键删除（services/modules 域不在根键集——随 base 保留；v6 domains 键已退役），
       // node 全键置入（未知键交严格 zod 拒——fail-visible；B10：原实现 spread+merge 残留 stale 根键）
       const next: Record<string, unknown> = { ...base };
       for (const k of APP_INTEGRATION_NODE_KEYS) if (!(k in node)) delete next[k];
@@ -370,37 +376,27 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
 
     applyModule(moduleId: string, node: Record<string, unknown>, writeOpts: WriteOptions = {}): SaveResult {
       assertSafeNames(node, 'root');
-      // D34 写守卫（v4.4，moduleDomainWritable 单源）：404（模块在册）→ 400（多域/零域/共享键
-      // 三分支）→ 既有管线。守卫先于 no-op 短路——多域/零域/共享键模块 PUT {} 清域同 400
-      // （「写路径拒绝歧义操作」含清除；P13/P17）。
-      const { modules, catalog } = walkManifests(appDir, cache);
+      // v6 写守卫（moduleOwnershipWritable 单源）：404（模块在册）→ 400（zero-ownership——
+      // 模块级集成位作用于 declare.owns 服务，零归属模块无配置位）→ 既有管线。
+      // 守卫先于 no-op 短路——零归属模块 PUT {} 清位同 400（「写路径拒绝歧义操作」含清除）。
+      const { modules, catalog, ownership } = walkManifests(appDir, cache);
       const mod = modules.find((m) => m.id === moduleId);
       if (!mod) {
         throw new AppToolkitError('MODULE_NOT_FOUND', 404, `模块 ${moduleId} 非已装模块`);
       }
-      const w = moduleDomainWritable({ modules, catalog }, mod);
+      const w = moduleOwnershipWritable({ modules, catalog, ownership }, mod);
       if (!w.writable) {
-        if (w.reason === 'multi-domain') {
-          throw new AppToolkitError(
-            'VALIDATION_FAILED',
-            400,
-            `模块 ${moduleId} 跨 ${w.domainKeys.length} 个域（${w.domainKeys.join('、')}）——模块级统一配置仅支持单域模块，请按服务级配置（编辑各服务行）`,
-          );
-        }
-        if (w.reason === 'zero-domain') {
-          throw new AppToolkitError('VALIDATION_FAILED', 400, `模块 ${moduleId} 无服务需求声明，无域配置位`);
-        }
         throw new AppToolkitError(
           'VALIDATION_FAILED',
           400,
-          `域键 ${w.domainKey} 由 ${w.coOwners.map((o) => displayOwnerName(modules, o)).join('、')} 共用——写通道拒绝歧义操作，请按服务级配置`,
+          `模块 ${moduleId} 未声明任何 declare.owns——无模块级配置位（模块级 provider/config 作用于归属服务）`,
         );
       }
-      const domainKey = w.domainKey;
       const issues: IntegrationServiceIssue[] = [];
       const current = loadConfig(appDir, cache);
+      // N2 语义（v6）：空节点 = 清 provider/config 两键，resources 随既有节点保全；
+      // 文件缺席 + 空节点 = no-op（幂等）
       if (current === null && Object.keys(node).length === 0) {
-        // 空文件清空域 = no-op（N1 幂等）
         return { written: false, restartScheduled: false, files: [], credentials: [], issues };
       }
       if (current === null) {
@@ -411,15 +407,39 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
         });
       }
       const base: Record<string, unknown> = current ?? { services: {} };
-      const domains = { ...((base.domains as Record<string, unknown>) ?? {}) };
-      const next: Record<string, unknown> = { ...base, domains };
-      // N1：模块节点 {} → 删 domains[键]（清域）；其余 = 域键全量替换
-      if (Object.keys(node).length === 0) delete domains[domainKey];
-      else domains[domainKey] = { ...node };
+      const modulesNode = { ...((base.modules as Record<string, unknown>) ?? {}) };
+      const existing = { ...((modulesNode[moduleId] as Record<string, unknown> | undefined) ?? {}) };
+      // 键集纪律：node 内仅接受 MODULE_INTEGRATION_NODE_KEYS 成员（未知键交严格 zod 拒——fail-visible）
+      for (const k of Object.keys(node)) {
+        if (!(MODULE_INTEGRATION_NODE_KEYS as readonly string[]).includes(k)) {
+          throw new AppToolkitError(
+            'VALIDATION_FAILED',
+            400,
+            `模块集成位仅接受 ${MODULE_INTEGRATION_NODE_KEYS.join('/')} 键（收到 ${k}）`,
+            [k],
+          );
+        }
+      }
+      // 全量替换（键集内）：缺席键删除；空对象/空串值 = 删除（≡ 缺席——模块节点不留空键）；
+      // PUT {} = 清 provider/config，resources 恒随 existing 保全（N2：清集成位不杀资源绑定）
+      const nextNode: Record<string, unknown> = { ...existing };
+      for (const k of MODULE_INTEGRATION_NODE_KEYS) {
+        const v = node[k];
+        const isEmptyish = v === undefined || v === null || v === ''
+          || (typeof v === 'object' && !Array.isArray(v) && Object.keys(v as object).length === 0);
+        if (isEmptyish) delete nextNode[k];
+        else nextNode[k] = v;
+      }
+      if (Object.keys(nextNode).length === 0) {
+        delete modulesNode[moduleId];
+      } else {
+        modulesNode[moduleId] = nextNode;
+      }
+      const next: Record<string, unknown> = { ...base, modules: modulesNode };
       if (deepEqual(current, next)) {
         return { written: false, restartScheduled: false, files: [], credentials: [], issues };
       }
-      runStrictValidation(next, issues, `domains.${domainKey}.`);
+      runStrictValidation(next, issues, `modules.${moduleId}.`);
       issues.push(...registryCheck(next));
       return finalize(next, [], issues, writeOpts.dryRun);
     },

package/src/views/app.ts

@@ -5,21 +5,21 @@ import { moduleOccupiedServices, resolveServiceDisplay, type ViewSnapshot } from
 /**
  * 应用静态投影（views/app；C4；FX-1c B10——root 节点投影修；v4.4 D29——services 双端点同型）。
  * /app = 平台服务 + root 节点原值（纯静态）：services = 服务词汇 − 模块占用
- * （ServiceDemand[]——平台条目 required 恒 false、title/description 缺席，D29）；
+ * （ServiceDemand[]——平台条目 required 恒 false、name/description 缺席，D29）；
  * 平台服务状态不在此（→ /service-resolutions）；模块服务不在此（→ /modules/:m）。
  * integration = **root 节点投影**（APP_INTEGRATION_NODE_KEYS——D21/L1：GET 预填 ≡ PUT body；
- * 文件另含 services/domains/modules 域键，不进 root 节点投影——原实现整文件透传，
+ * 文件另含 services/modules 域键，不进 root 节点投影——原实现整文件透传，
  * PUT 回会级联写回域键）；文件缺席 = null，文件在场 → 投影对象（可为空）。
  */
 
 export function loadAppView(snapshot: ViewSnapshot): AppView {
   const occupied = moduleOccupiedServices(snapshot.walk);
-  // 平台条目展示名走链（B1）：词汇 meta > demand meta > id——title 恒发（id 兜底内聚）
+  // 平台条目展示名走链（B1）：词汇 meta > demand meta > id——name 恒发（id 兜底内聚）
   const services: ServiceDemand[] = snapshot.walk.vocabulary
     .filter((s) => !occupied.has(s))
     .map((s) => {
       const display = resolveServiceDisplay(snapshot.walk, s);
-      return { service: s, title: display.title, ...(display.description !== undefined ? { description: display.description } : {}), required: false };
+      return { service: s, name: display.name, ...(display.description !== undefined ? { description: display.description } : {}), required: false };
     });
   const config = snapshot.integrations;
   let integration: AppView['integration'] = null;

package/src/views/context.ts

@@ -1,12 +1,11 @@
 import { readIntegrationsConfig } from '../integrations/read.js';
-import { domainOfService } from '../integrations/domain-binding.js';
 import { walkManifests, type WalkCatalog, type WalkManifestsResult } from '../assembly/walk-manifests.js';
 import type { FileCache } from '../core/file-cache.js';
 import type { ResolvedContracts } from '../core/contracts-resolver.js';
 
 /**
  * 视图装配共享上下文（五投影共用；目录枚举零缓存——walkManifests 每次调用执行）。
- * 域前缀换算（service → 首点段）自 v4.4 F1 迁 integrations/domain-binding.ts（本文件 re-export 保导入路径）。
+ * v6：域前缀换算退役（domainOfService 随归属模型退场）——模块占用判定改 declare 三键直读。
  */
 
 export interface ViewContext {
@@ -20,32 +19,34 @@ export interface ViewSnapshot {
   catalog: WalkCatalog;
   integrations: Record<string, unknown> | null;
   contracts: ResolvedContracts;
+  /** 文件读原语透传（可选——resources 台账惰性读等 stat 指纹缓存消费；缺席 = 调用方直读） */
+  cache?: FileCache;
 }
 
-export { domainOfService };
-
 /** 读取视图输入快照（每方法调用独立——Freshness Contract 单位 = 方法调用） */
 export async function loadViewSnapshot(ctx: ViewContext): Promise<ViewSnapshot> {
   const walk = walkManifests(ctx.appDir, ctx.cache);
   const integrations = await readIntegrationsConfig(ctx.appDir, ctx.cache);
   const { resolveContractsForApp } = await import('../core/contracts-resolver.js');
   const contracts = await resolveContractsForApp(ctx.appDir);
-  return { appDir: ctx.appDir, walk, catalog: walk.catalog, integrations, contracts };
+  return { appDir: ctx.appDir, walk, catalog: walk.catalog, integrations, contracts, ...(ctx.cache ? { cache: ctx.cache } : {}) };
 }
 
 /** 同步快照（调用方已持有 contracts 时——避免重复解析） */
 export function loadViewSnapshotSync(ctx: ViewContext, contracts: ResolvedContracts): ViewSnapshot {
   const walk = walkManifests(ctx.appDir, ctx.cache);
   const integrations = readIntegrationsConfig(ctx.appDir, ctx.cache);
-  return { appDir: ctx.appDir, walk, catalog: walk.catalog, integrations, contracts };
+  return { appDir: ctx.appDir, walk, catalog: walk.catalog, integrations, contracts, ...(ctx.cache ? { cache: ctx.cache } : {}) };
 }
 
-/** 模块占用服务集（demand 侧——平台服务 = 词汇 − 本集） */
+/** 模块占用服务集（v6——demand ∪ supply ∪ owns：归属模型下「平台服务」= 无主服务；
+ *  mall-core owns auth.alipay-login → 移出 AppView.services 平台条目，入其模块页 ownedServices） */
 export function moduleOccupiedServices(walk: WalkManifestsResult): Set<string> {
   const occupied = new Set<string>();
   for (const mod of walk.modules) {
-    for (const need of mod.descriptor.contributes.services ?? []) occupied.add(need.service);
-    for (const slot of mod.descriptor.contributes.providers?.slots ?? []) occupied.add(slot.service);
+    for (const own of mod.descriptor.declare.owns ?? []) occupied.add(own.service);
+    for (const need of mod.descriptor.declare.consumes ?? []) occupied.add(need.service);
+    for (const slot of mod.descriptor.declare.providers?.slots ?? []) occupied.add(slot.service);
   }
   return occupied;
 }
@@ -66,22 +67,22 @@ export function suppliedByVendors(catalog: WalkCatalog, service: string): string
   return vendors.sort();
 }
 
-/** 服务展示名解析结果（title 恒有值——id 兜底内聚） */
+/** 服务展示名解析结果（name 恒有值——id 兜底内聚；v7 词汇统一 title→name） */
 export interface ServiceDisplay {
-  title: string;
+  name: string;
   description?: string;
 }
 
 /**
  * 服务展示名单源（B1）：词汇 meta（slotMeta——contracts-mall 词汇锁保证 mall 域覆盖）
  * > demand meta（catalog.services——域外槽兜底；首声明聚合）> service id。逐字段回落——
- * 词汇条目仅含 description 时 demand title 仍可达（外部契约包部分 meta 前向容错）。
+ * 词汇条目仅含 description 时 demand name 仍可达（外部契约包部分 meta 前向容错）。
  * 四视图唯一消费点（/modules/:m services、/app 平台条目、/services/:s、/providers/:p services）。
  */
 export function resolveServiceDisplay(walk: WalkManifestsResult, service: string): ServiceDisplay {
   const vocab = walk.slotMeta[service];
   const demand = walk.catalog.services[service];
-  const title = vocab?.title ?? demand?.title ?? service;
+  const name = vocab?.name ?? demand?.name ?? service;
   const description = vocab?.description ?? demand?.description;
-  return { title, ...(description !== undefined ? { description } : {}) };
+  return { name, ...(description !== undefined ? { description } : {}) };
 }

package/src/views/integration-schemas.ts

@@ -1,7 +1,7 @@
 import type { IntegrationFieldRegistryView, LayerIntegrationSchemas, ServiceIntegrationSchemas } from '../dto.js';
 import { isSupplied, type ViewSnapshot } from './context.js';
 import { resolveServiceConfigSchema } from './providers.js';
-import { domainOfService, moduleDomainWritable, providerFootprint, resolveDomainBinding } from '../integrations/domain-binding.js';
+import { moduleOwnershipWritable, providerFootprint, resolveModuleBinding } from '../integrations/module-binding.js';
 import { isControlledInlineProvider } from '../integrations/predicate.js';
 
 /**
@@ -117,6 +117,12 @@ export function buildIntegrationFieldRegistry(
       key,
       schema: mergeFieldSources(sources),
       sources: sources.map(({ service, required }) => ({ service, required })),
+      // G 批：x-tbox-global 聚合旗标（sources.some——subschema 属性标记直读，零新增 IO；
+      // 任一来源声明即 true——并集口径与 required 聚合同族）
+      global: sources.some(
+        (s) => !!s.subschema && typeof s.subschema === 'object'
+          && (s.subschema as Record<string, unknown>)['x-tbox-global'] === true,
+      ),
     });
   }
   return {
@@ -129,7 +135,7 @@ export function buildIntegrationFieldRegistry(
 }
 
 /** D37 生效厂商解析单源（实际/假想同径）：override（非空串）?? 实际解析。
- *  空串归一（I3）单点；module 轴 D34 不可写/不在册 → null（override 不豁免——预览服务于保存）。 */
+ *  空串归一（I3）单点；module 轴 v6 零归属 → null（override 不豁免——预览服务于保存）。 */
 export function formProviderOf(
   axis: 'app' | 'module',
   snapshot: ViewSnapshot,
@@ -144,10 +150,10 @@ export function formProviderOf(
   }
   const mod = snapshot.walk.modules.find((m) => m.id === moduleId);
   if (!mod) return null; // 视图已先行 404，此处防御
-  const w = moduleDomainWritable(snapshot.walk, mod);
-  if (!w.writable) return null; // D34 不豁免
+  const w = moduleOwnershipWritable(snapshot.walk, mod);
+  if (!w.writable) return null; // v6 零归属不豁免
   if (ovr !== undefined) return ovr;
-  return resolveDomainBinding(snapshot.integrations, w.domainKey).provider;
+  return resolveModuleBinding(snapshot.integrations, mod.id).provider;
 }
 
 /** D36/D37 表单层双投影（I1：同源同口径一次计算——双取单算 by construction） */
@@ -159,29 +165,39 @@ export interface LayerFormViews {
 /** 防御双 null（module 不在册/不可写/未绑定、app 未绑定——F3） */
 const NULL_FORM_VIEWS: LayerFormViews = { integrationSchemas: null, integrationFieldRegistry: null };
 
+/** G 批表单收窄（消费投影单点）：app/module 轴 registry.fields 只留 global===true——
+ *  未声明键落 ExtraFields 语义（P16 复合可见面：layer.properties 仍全量，字段级代数不受扰）。
+ *  schemaless/unsupplied/additionalPropertiesAllowed 描述服务/Schema 面，不随字段过滤。 */
+function narrowToGlobal(registry: IntegrationFieldRegistryView): IntegrationFieldRegistryView {
+  return { ...registry, fields: registry.fields.filter((f) => f.global) };
+}
+
 /** app 轴装配：scope = 供给足迹全量（≠ AppView.services——root.config 流向包括模块服务在内的所有服务）；
  *  unsupplied 恒 []（结构性：足迹 ⊆ 供给）。未知厂商/零足迹 → 非 null 空集（镜像 D32 mock 语义）。 */
 export function loadAppFormViews(snapshot: ViewSnapshot, appProvider?: string): LayerFormViews {
   const provider = formProviderOf('app', snapshot, undefined, appProvider);
   if (provider === null) return NULL_FORM_VIEWS;
   const layer = resolveLayerIntegrationSchemas(snapshot, provider, providerFootprint(snapshot.catalog, provider));
-  return { integrationSchemas: layer, integrationFieldRegistry: buildIntegrationFieldRegistry(layer) };
+  return { integrationSchemas: layer, integrationFieldRegistry: narrowToGlobal(buildIntegrationFieldRegistry(layer)) };
 }
 
-/** module 轴装配：仅 writable 单域（D34）；scope = demand ∩ 该厂商供给；unsupplied 同点派生
- *  （demand − 供给，Set 去重保序——manifest demand 不去重防御）。 */
+/** module 轴装配：仅 writable（v6 owns>0）；scope = ownedServices ∩ 该厂商供给（v6——模块
+ *  config 流向归属服务）；unsupplied 同点派生（ownedServices − 供给，Set 去重保序——
+ *  declare.owns 不去重防御）。 */
 export function loadModuleFormViews(snapshot: ViewSnapshot, moduleId: string, moduleProvider?: string): LayerFormViews {
   const provider = formProviderOf('module', snapshot, moduleId, moduleProvider);
   const mod = snapshot.walk.modules.find((m) => m.id === moduleId);
   if (provider === null || !mod) return NULL_FORM_VIEWS;
-  const demand = (mod.descriptor.contributes.services ?? []).map((s) => s.service);
+  const owned = (mod.descriptor.declare.owns ?? []).map((o) => o.service);
   const supplied = (s: string): boolean => isSupplied(snapshot.catalog, provider, s);
-  const layer = resolveLayerIntegrationSchemas(snapshot, provider, demand.filter(supplied));
+  const layer = resolveLayerIntegrationSchemas(snapshot, provider, owned.filter(supplied));
   return {
     integrationSchemas: layer,
-    integrationFieldRegistry: buildIntegrationFieldRegistry(layer, {
-      unsupplied: [...new Set(demand.filter((s) => !supplied(s)))],
-    }),
+    integrationFieldRegistry: narrowToGlobal(
+      buildIntegrationFieldRegistry(layer, {
+        unsupplied: [...new Set(owned.filter((s) => !supplied(s)))],
+      }),
+    ),
   };
 }
 
@@ -195,25 +211,47 @@ export function loadModuleIntegrationSchemas(snapshot: ViewSnapshot, moduleId: s
   return loadModuleFormViews(snapshot, moduleId).integrationSchemas;
 }
 
+/** 服务级生效绑定（v6 级联）：显式 ?? modules[ownerOf[s]].provider ?? root.provider。
+ *  服务无主 → 仅 root（平台槽语义）。 */
+function serviceLevelBindingProvider(snapshot: ViewSnapshot, service: string): string | null {
+  const owner = snapshot.walk.ownership[service];
+  if (owner !== undefined) {
+    return resolveModuleBinding(snapshot.integrations, owner).provider;
+  }
+  const p = (snapshot.integrations as { provider?: unknown } | null)?.provider;
+  return typeof p === 'string' && p.length > 0 ? p : null;
+}
+
 /** 服务级 loader（v4.7 D38）：四分支穷举（node.provider = 文件 services[s].provider 逐字原值；
  *  实例层无条件排除——node 级口径）；非空三分支归约一次复合解析。
- *  ① undefined/'' → resolveDomainBinding 域级联（域 + root 双缺 → 整字段 null）
+ *  ① undefined/'' → 模块级联（v6：modules[ownerOf[s]] → root 双缺 → 整字段 null）
  *  ② 非空 string → bare：catalog miss（未知厂商/未供给）→ configSchema:null 不 404（富化非门控）
  *  ③ 受控内联（isControlledInlineProvider 单源）→ 名 = p.provider；catalog 复合键 > p.configSchema ref
  *     （H9 逃逸 400 照抛——readInlineSchema 共享路径）
  *  ④ 其余（null/数组/原始值/坏对象）→ 整字段 null（≡ 谓词 #5 INLINE_PROVIDER_INVALID 同判——
- *     不放行域级联，防错误 schema 污染坏节点） */
+ *     不放行域级联，防错误 schema 污染坏节点）
+ *  v5.1 D39：serviceProvider = 服务轴向假想绑定（缺席/空串 ≡ 按实际解析——I3 归一单点在此头部，
+ *  registry 侧不重复归一）；非空轴参 → 短路 bare 解析（镜像 formProviderOf「输入替换非分支复制」先例：
+ *  任一原分支改写 provider 为 X 后实读都进 bare 分支，同构承诺 by construction）。短路在节点读取之前——
+ *  豁免链三分支（D39 与 D38 四分支的有意分歧：预览与坏文件解耦）：malformed（分支④）不污染假想 /
+ *  内联 ref 不读取（假想态无 H9 逃逸 400；catalog 命中的 manifest 声明路径照读，与节点声明的
+ *  用户可控路径不同性）/ 全链未绑定时假想仍非 null（服务轴恒可写，无 module 轴零归属对应物）。 */
 export function loadServiceIntegrationSchemas(
   snapshot: ViewSnapshot,
   service: string,
+  serviceProvider?: string,
 ): ServiceIntegrationSchemas | null {
+  const ovr = typeof serviceProvider === 'string' && serviceProvider.length > 0 ? serviceProvider : undefined;
+  if (ovr !== undefined) {
+    return { provider: ovr, configSchema: resolveServiceConfigSchema(snapshot, ovr, service) };
+  }
   const p = (snapshot.integrations as { services?: Record<string, { provider?: unknown }> } | null)
     ?.services?.[service]?.provider;
   if (p === undefined || p === '') {
-    const binding = resolveDomainBinding(snapshot.integrations, domainOfService(service));
-    return binding.provider === null
+    const provider = serviceLevelBindingProvider(snapshot, service);
+    return provider === null
       ? null
-      : { provider: binding.provider, configSchema: resolveServiceConfigSchema(snapshot, binding.provider, service) };
+      : { provider, configSchema: resolveServiceConfigSchema(snapshot, provider, service) };
   }
   if (typeof p === 'string') {
     return { provider: p, configSchema: resolveServiceConfigSchema(snapshot, p, service) };
@@ -224,3 +262,23 @@ export function loadServiceIntegrationSchemas(
   }
   return null;
 }
+
+/** G 批：服务轴字段注册表（D38 四分支链复用——消费 loadServiceIntegrationSchemas 单源；
+ *  伪层 {provider, services: {[s]: {configSchema}}} → buildIntegrationFieldRegistry——
+ *  fields = 该 schema 全部字段带 global 旗标；configSchema null → schemaless=[service]
+ *  非 null 空集；schemas 整体 null（全链未绑定/坏节点）→ registry null——镜像 D38 语义）。
+ *  v5.1 D39：serviceProvider = 服务轴向假想绑定，纯透传（I1 单源——归一与短路都在链函数头部；
+ *  轴参仅重定向表单层投影，global 旗标全量透传语义不变）。 */
+export function loadServiceFieldRegistry(
+  snapshot: ViewSnapshot,
+  service: string,
+  serviceProvider?: string,
+): IntegrationFieldRegistryView | null {
+  const schemas = loadServiceIntegrationSchemas(snapshot, service, serviceProvider);
+  if (schemas === null) return null;
+  const layer: LayerIntegrationSchemas = {
+    provider: schemas.provider,
+    services: { [service]: { configSchema: schemas.configSchema } },
+  };
+  return buildIntegrationFieldRegistry(layer);
+}

package/src/views/modules.ts

@@ -1,18 +1,71 @@
-import type { ModuleDeclaration, ModuleDetailView, ProviderBinding, ServiceDemand } from '../dto.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { ModuleDeclaration, ModuleBinding, ModuleDetailView, ModuleResourceEcho, ModuleResourcesEcho, ServiceDemand } from '../dto.js';
 import { AppToolkitError } from '../core/errors.js';
-import { moduleDomainWritable, resolveDomainBinding } from '../integrations/domain-binding.js';
+import { moduleOwnershipWritable, resolveModuleBinding } from '../integrations/module-binding.js';
 import { resolveServiceDisplay, type ViewSnapshot } from './context.js';
 
 /**
  * 需求轴/模块静态投影（views/modules；C4）。静态端点结构性零求值（铁律 #3——
  * 无 resolution/issues/contracts 键，永不 503）。
- * v4.4 D34：domainKeys/providerBindings/configEditable 显式化；integration 仅单域
- * （writable）时在场——多域/零域/共享键无单键落点；多域回退兜底键机器拆除
- * （派生统一 = domainOfService 去重集合，moduleDomainWritable 单源）。
+ * v6 所有权模型：ownedServices（declare.owns 展平）/ binding 单数（resolveModuleBinding）/
+ * configEditable = owns>0（moduleOwnershipWritable 单源）；integration = modules[install id]
+ * 集成位投影（provider/config；resources 走独立只读字段，见投影 resourcesOf——N2 读半边）。
+ * v5 domainKeys/providerBindings 退役。
  * 2026-09-16 双缺陷批：loadModulesView 排除 provider 家族包（供给/实施载体非可配置
  * 业务模块）——walk 声明集与 loadModuleDetailView 不变（装包仍合法，详情保持 200）。
  */
 
+/** knowledge.json 台账路径（与 toolkit readIntegrationsConfig 同源锚定 appDir/config/——
+ *  TBOX_INTEGRATIONS_FILE 为 SDK 运行时逃生舱，视图不跟随，既有分叉见 dto ModuleResourceEcho 注） */
+const KNOWLEDGE_REGISTRY_FILE = join('config', 'knowledge.json');
+
+/**
+ * modules[install id].resources 只读投影（N2 读半边；文件镜像 L1 + ref 台账展开态）：
+ * - 无模块键/无资源节 → null（DTO null 语义：无资源 ≠ 空表）；
+ * - `datasetId` 直填 → resolvedDatasetId = 该值（镜像 SDK resolveKnowledge：并存时 datasetId 优先）；
+ * - `ref` → 同目录 knowledge.json 台账命中 = 台账 datasetId；未命中/台账缺失/解析失败 = null
+ *   （镜像 SDK resolveKnowledge miss-warn 降级语义，资源缺席走模块占位回退）；
+ * - 非 knowledge 型资源（未来 additive）原样透传 type，resolvedDatasetId = null。
+ */
+function resourcesOf(snapshot: ViewSnapshot, moduleId: string, modulesNode: Record<string, unknown>): ModuleResourcesEcho | null {
+  const raw = modulesNode[moduleId] as { resources?: Record<string, unknown> } | undefined;
+  const resources = raw?.resources;
+  if (!resources || typeof resources !== 'object' || Array.isArray(resources)) return null;
+  const registryPath = join(snapshot.appDir, KNOWLEDGE_REGISTRY_FILE);
+  // 台账惰性读（stat 指纹缓存；缺席/坏文件 = 空表——展开态 null，与 SDK loadKnowledgeRegistry fail-soft 同语义）
+  let bases: Record<string, { datasetId?: unknown }> = {};
+  if (existsSync(registryPath)) {
+    try {
+      const parsed = (snapshot.cache?.read(registryPath, (raw: string) => JSON.parse(raw) as unknown) ?? JSON.parse(readFileSync(registryPath, 'utf8'))) as {
+        knowledge_bases?: Record<string, { datasetId?: unknown }>;
+      };
+      bases = parsed.knowledge_bases ?? {};
+    } catch {
+      bases = {};
+    }
+  }
+  const out: ModuleResourcesEcho = {};
+  for (const [id, spec] of Object.entries(resources)) {
+    if (!spec || typeof spec !== 'object' || Array.isArray(spec)) continue;
+    const s = spec as Record<string, unknown>;
+    const type = s.type === 'knowledge' ? 'knowledge' : String(s.type ?? 'knowledge');
+    const direct = typeof s.datasetId === 'string' && s.datasetId !== '' ? s.datasetId : undefined;
+    const ref = typeof s.ref === 'string' && s.ref !== '' ? s.ref : undefined;
+    const resolved = direct ?? (ref !== undefined && typeof bases[ref]?.datasetId === 'string' ? (bases[ref].datasetId as string) : null);
+    const echo: ModuleResourceEcho = {
+      type: type as ModuleResourceEcho['type'],
+      ...(direct !== undefined ? { datasetId: direct } : {}),
+      ...(ref !== undefined ? { ref } : {}),
+      resolvedDatasetId: resolved,
+      ...(typeof s.topK === 'number' ? { topK: s.topK } : {}),
+      ...(typeof s.scoreThreshold === 'number' ? { scoreThreshold: s.scoreThreshold } : {}),
+    };
+    out[id] = echo;
+  }
+  return Object.keys(out).length > 0 ? out : null;
+}
+
 /** 家族名归一（cli deriveModuleId 同源语义——依赖方向禁 import，故内联）：
  *  `@tbox.cn/app-provider-x` / `@app/provider-y` / `provider-z` → `provider-*` */
 function familyName(s: string): string {
@@ -27,52 +80,67 @@ function isProviderFamily(mod: { id: string; pkg: string }): boolean {
   return familyName(mod.id).startsWith('provider-') || familyName(mod.pkg).startsWith('provider-');
 }
 
-/** GET /modules：纯模块清单（demand 不在——卡片展开 = GET /modules/:m；provider 家族包不在清单） */
-export function loadModulesView(snapshot: ViewSnapshot): { modules: ModuleDeclaration[] } {
+/** GET /modules：纯模块清单（demand 不在——卡片展开 = GET /modules/:m；provider 家族包不在清单；
+ *  hidden 模块默认过滤——includeHidden = true 可见并携带 hidden: true 徽标） */
+export function loadModulesView(
+  snapshot: ViewSnapshot,
+  opts: { includeHidden?: boolean } = {},
+): { modules: ModuleDeclaration[] } {
   const modules: ModuleDeclaration[] = snapshot.walk.modules
     .filter((mod) => !isProviderFamily(mod))
+    .filter((mod) => opts.includeHidden === true || mod.descriptor.hidden !== true)
     .map((mod) => ({
       id: mod.id,
-      name: mod.descriptor.name,
-      // 模块 meta（B1 additive）：manifest title/description——兜底 name / ''（视图层灌值）
-      title: mod.descriptor.title ?? mod.descriptor.name,
+      // v7 词汇统一：name = 展示名（manifest name；兜底 id——恒有值）
+      name: mod.descriptor.name ?? mod.descriptor.id,
       description: mod.descriptor.description ?? '',
+      ...(mod.descriptor.hidden === true ? { hidden: true } : {}),
     }))
     .sort((a, b) => a.id.localeCompare(b.id));
   return { modules };
 }
 
-/** GET /modules/:module：模块静态一站式（integration 节点原值 + demand；PUT 读对偶） */
+/** GET /modules/:module：模块静态一站式（modules[install id] 集成位原值 + demand；PUT 读对偶） */
 export function loadModuleDetailView(snapshot: ViewSnapshot, moduleId: string): ModuleDetailView {
   const mod = snapshot.walk.modules.find((m) => m.id === moduleId);
   if (!mod) {
     throw new AppToolkitError('MODULE_NOT_FOUND', 404, `模块 ${moduleId} 非已装模块`);
   }
-  const services: ServiceDemand[] = (mod.descriptor.contributes.services ?? []).map((need) => {
+  const services: ServiceDemand[] = (mod.descriptor.declare.consumes ?? []).map((need) => {
     // 展示名单源走链（B1）：词汇 meta > demand meta > id——词汇主源防 manifest demand 漂移
     const display = resolveServiceDisplay(snapshot.walk, need.service);
     return {
       service: need.service,
-      title: display.title,
+      name: display.name,
       ...(display.description !== undefined ? { description: display.description } : {}),
       required: need.optional === false,
     };
   });
-  const w = moduleDomainWritable(snapshot.walk, mod);
-  const domains = (snapshot.integrations as { domains?: Record<string, unknown> } | null)?.domains ?? {};
-  // integration = domains[换算键] 节点原值（D21 编辑预填源）；未配置 = null；多域/零域/共享键 = null（D34）
-  const integration = w.writable ? ((domains[w.domainKey] as ModuleDetailView['integration']) ?? null) : null;
-  const providerBindings: ProviderBinding[] = w.domainKeys.map((d) => {
-    const binding = resolveDomainBinding(snapshot.integrations, d);
-    return { domain: d, effective: binding.provider, layer: binding.layer };
-  });
+  const w = moduleOwnershipWritable(snapshot.walk, mod);
+  const modulesNode = (snapshot.integrations as { modules?: Record<string, unknown> } | null)?.modules ?? {};
+  // integration = modules[install id] 集成位投影（D21 编辑预填源；provider/config 两键——
+  // resources 不投影不写，N2）；未配置 = null
+  const rawNode = modulesNode[moduleId] as Record<string, unknown> | undefined;
+  const integration: ModuleDetailView['integration'] = rawNode
+    ? {
+        ...(typeof rawNode.provider === 'string' ? { provider: rawNode.provider } : {}),
+        ...(rawNode.config && typeof rawNode.config === 'object' && !Array.isArray(rawNode.config)
+          ? { config: rawNode.config as Record<string, unknown> }
+          : {}),
+      }
+    : null;
+  const binding: ModuleBinding = resolveModuleBinding(snapshot.integrations, moduleId);
   return {
-    // 模块 meta（B1 additive）——兜底与 /modules 同语义
-    title: mod.descriptor.title ?? mod.descriptor.name,
+    // v7 词汇统一：name = 展示名（兜底与 /modules 同语义——manifest name ?? id）
+    name: mod.descriptor.name ?? mod.descriptor.id,
     description: mod.descriptor.description ?? '',
-    domainKeys: [...w.domainKeys],
+    ...(mod.descriptor.hidden === true ? { hidden: true } : {}),
+    // v6：ownedServices（declare.owns 展平排序）——N13：展示名走 resolveServiceDisplay 链，不重复携带
+    ownedServices: w.ownedServices,
     integration,
-    providerBindings,
+    // 模块资源只读镜像（N2 读半边——knowledge.json 台账 ref 展开态随行）
+    resources: resourcesOf(snapshot, moduleId, modulesNode),
+    binding: { provider: binding.provider, layer: binding.layer },
     configEditable: w.writable,
     services,
   };

package/src/views/providers.ts

@@ -22,7 +22,7 @@ export function loadProvidersView(snapshot: ViewSnapshot): ProvidersView {
       local: entries.every((e) => e.local === true),
       owner: entries[0].owner,
       // 厂商展示元数据（B1 walk 层传播——首条目 = 首声明，与 owner 同语义）
-      ...(entries[0].title ? { title: entries[0].title } : {}),
+      ...(entries[0].name ? { name: entries[0].name } : {}),
       ...(entries[0].description ? { description: entries[0].description } : {}),
     });
   }
@@ -43,10 +43,10 @@ export function loadProviderDetailView(snapshot: ViewSnapshot, provider: string,
       bucket.implementations.push({ implementation: entry.implementation, credentialType: entry.credentialType });
     }
   }
-  // 服务展示名走链（B1）：词汇 meta > demand meta > id（title 恒发）
+  // 服务展示名走链（B1）：词汇 meta > demand meta > id（name 恒发）
   for (const [service, bucket] of Object.entries(services)) {
     const display = resolveServiceDisplay(snapshot.walk, service);
-    bucket.title = display.title;
+    bucket.name = display.name;
     if (display.description !== undefined) bucket.description = display.description;
   }
   if (include?.has('integrationSchemas')) {
@@ -59,8 +59,8 @@ export function loadProviderDetailView(snapshot: ViewSnapshot, provider: string,
     provider,
     local: entries.every((e) => e.local === true),
     owner: entries[0].owner,
-    // 厂商展示元数据（B1 walk 层传播——首条目透传）
-    ...(entries[0].title ? { title: entries[0].title } : {}),
+    // 厂商展示元数据（B1 walk 层传播——首条目透传；v7 title→name）
+    ...(entries[0].name ? { name: entries[0].name } : {}),
     ...(entries[0].description ? { description: entries[0].description } : {}),
     services,
   };

package/src/views/service-detail.ts

@@ -21,7 +21,7 @@ export function loadServiceDetailView(snapshot: ViewSnapshot, service: string):
   const display = resolveServiceDisplay(snapshot.walk, service);
   return {
     service,
-    title: display.title,
+    name: display.name,
     ...(display.description !== undefined ? { description: display.description } : {}),
     required: demand ? !demand.optional : false,
     // defaults 唯一落位（manifest 预填）