@tbox.cn/app-toolkit 0.2.0 → 0.3.0

package/src/dto.ts

@@ -1,5 +1,5 @@
 /**
- * DTO 全量（api.md §3 字段级单源落源——28 类型；演进 additive-only，铁律 #8）。
+ * DTO 全量（api.md §3 字段级单源落源——36 类型；演进 additive-only，铁律 #8）。
  * agtcodingbox / tbox-ai-coding 经 `import type` 消费（L2 DTO 单源——API 层零类型镜像）。
  * 词汇七概念：app / module / service / instance / provider / integration / resolution。
  * 弃用词汇清单见 api.md §3 尾（component/slot/scope/configMode/…——防复活）。
@@ -20,13 +20,15 @@ export type BindingLayer = 'app' | 'module' | 'service' | 'instance';
 
 // ===== 需求轴（GET /modules · 静态）=====
 
-/** 纯模块清单（无 services——卡片展开走 /modules/:m） */
+/** 纯模块清单（无 services——卡片展开走 /modules/:m）；provider 家族包不在清单
+ *  （供给/实施载体非可配置业务模块——供给轴归 /providers；判定 = install id / 包名
+ *  basename 去 scope 后 `provider-` 前缀；已装 provider 详情 GET /modules/:m 仍 200） */
 export interface ModulesView {
   modules: ModuleDeclaration[];
 }
 
 export interface ModuleDeclaration {
-  /** install id（packages/ 目录名 / .tbox/app.json entry.id） */
+  /** install id（packages/ 目录名 / .tbox/app.json entry.id）——恒业务模块（provider 家族不在本清单） */
   id: string;
   /** 包名 */
   name: string;
@@ -62,6 +64,9 @@ export interface ModuleDetailView {
   serviceResolutions?: ServiceResolutionsView | null;
   /** v4.4 D32：include=integrationSchemas 层级富化（多域/零域/共享键/未绑定 → null） */
   integrationSchemas?: LayerIntegrationSchemas | null;
+  /** v4.6 D36：include=integrationFieldRegistry 集成字段注册表（null 语义镜像 integrationSchemas；
+   *  未知厂商/零足迹 → 非 null 空集 + unsupplied 回填——D37 轴参假想计算同此） */
+  integrationFieldRegistry?: IntegrationFieldRegistryView | null;
 }
 
 /** 模块域厂商绑定解析（v4.4 D34——静态文件事实；规则 ≡ 谓词 #7 域级，resolveDomainBinding 单源） */
@@ -82,6 +87,27 @@ export interface LayerIntegrationSchemas {
   services: Record<string, { configSchema: object | null }>;
 }
 
+/** v4.6 D36：集成字段注册表（层级表单服务端预计算——合并代数 R1/R2/R3 服务端单源；
+ *  消费 resolveLayerIntegrationSchemas 产物构造，禁旁路直取 serviceSchemas） */
+export interface IntegrationFieldRegistryView {
+  /** echo：本注册表计算口径（假想时 = 轴参值——D37） */
+  provider: string;
+  /** 作用域内 configSchema === null 的服务（UI「未提供参数模板」提示行） */
+  schemaless: string[];
+  /** module 轴 = demand − 该厂商供给（Set 去重保序）；app 轴恒 []（结构性：足迹 ⊆ 供给） */
+  unsupplied: string[];
+  /** 作用域内全部非 null schema 的 additionalProperties 均 ≠ false（聚合；空真） */
+  additionalPropertiesAllowed: boolean;
+  /** 逐 key 合并产物（首声明插入序 = scope 遍历序：app 字母序 / module demand 序） */
+  fields: Array<{
+    key: string;
+    /** null = 类型不可调和（R3/R2 异构/R1 enum 不等——冲突折叠，客户端 RawJson 保真） */
+    schema: object | null;
+    /** required 聚合 = sources.some(s => s.required)；conflict 字段照常聚合 */
+    sources: Array<{ service: string; required: boolean }>;
+  }>;
+}
+
 /** GET /app（应用静态视图：平台服务 + root 原值） */
 export interface AppView {
   /** 平台服务（v4.4 D29：服务词汇 − 模块占用——与模块 demand 同型 ServiceDemand[]；
@@ -93,6 +119,9 @@ export interface AppView {
   serviceResolutions?: ServiceResolutionsView | null;
   /** v4.4 D32：include=integrationSchemas 层级富化（root.provider 缺席 → null） */
   integrationSchemas?: LayerIntegrationSchemas | null;
+  /** v4.6 D36：include=integrationFieldRegistry 集成字段注册表（root.provider 缺席且无轴参 → null；
+   *  未知厂商/零足迹 → 非 null 空集——D37 轴参假想计算同此） */
+  integrationFieldRegistry?: IntegrationFieldRegistryView | null;
 }
 
 /** GET /services/:service（服务静态单体） */
@@ -103,6 +132,18 @@ export interface ServiceDetail extends ServiceDemand {
   integration: ServiceIntegrationNode | null;
   /** 供给该服务的厂商名单（catalog 静态切片——picker 数据源） */
   suppliedBy: string[];
+  /** v4.7 D38：include=integrationSchemas 生效绑定富化（三态：null 全链未绑定 /
+   *  绑定无可计算 schema / 含 schema；malformed 节点 → null——不放行域级联） */
+  integrationSchemas?: ServiceIntegrationSchemas | null;
+}
+
+/** 服务级生效绑定 schema（v4.7 D38 静态轴富化——零 contracts，永不 503；实例层无条件排除：
+ *  node 级口径 ≠ resolution 默认实例口径，api.md §4.4 注） */
+export interface ServiceIntegrationSchemas {
+  /** 生效厂商：显式（含内联声明名）?? domains[首段].provider ?? root.provider */
+  provider: string;
+  /** catalog 复合键（多 impl 声明序首个）> 内联 ref；miss（未知厂商/未供给/内联缺 ref）→ null（富化非门控） */
+  configSchema: object | null;
 }
 
 // ===== 求值轴 =====
@@ -359,7 +400,8 @@ export interface SaveResult {
   written: boolean;
   /** 恒 false 当 dryRun / no-diff / 应用未运行（onApplied 协作点回填） */
   restartScheduled: boolean;
-  /** 触碰文件清单（dryRun 恒 []） */
+  /** 触碰清单；dryRun = 将触碰预览（D35——与同 body 真实写逐字对称，含凭据工件路径；
+   *  no-diff 早退 = 预览零触碰） */
   files: string[];
   /** 凭据工件（0..n；dryRun = 将创建的工件——确定性 stem 派生预览） */
   credentials: Array<{ stem: string; ref: string; overwrote: boolean }>;

package/src/factory.ts

@@ -19,7 +19,7 @@ import { loadModulesView, loadModuleDetailView } from './views/modules.js';
 import { loadAppView } from './views/app.js';
 import { loadServiceDetailView } from './views/service-detail.js';
 import { loadServiceResolutionsView, loadServiceResolutionDetail } from './views/service-resolutions.js';
-import { loadAppIntegrationSchemas, loadModuleIntegrationSchemas } from './views/integration-schemas.js';
+import { loadAppFormViews, loadModuleFormViews, loadServiceIntegrationSchemas } from './views/integration-schemas.js';
 import { loadCredentialsView } from './views/credentials.js';
 import { loadCredentialTypesView } from './views/credential-types.js';
 import type { WalkManifestsResult } from './assembly/walk-manifests.js';
@@ -42,7 +42,9 @@ import type {
 
 /**
  * createAppToolkit（C4 工厂；v4.4——24 方法 = 11 读（含 credentials/credential-types 双端点）
- * + 4 写 + 9 迁移面；loadApp/loadModule/loadProvider 增 include 选项）。
+ * + 4 写 + 9 迁移面；loadApp/loadModule/loadProvider 增 include 选项；v4.6——loadApp/loadModule
+ * += 轴向假想绑定选项（appProvider/moduleProvider，D37）；表单双投影经 formViews 单点装配；
+ * v4.7——loadService 增 include 选项（服务级生效绑定 schema 单体））。
  * AppToolkit = AppToolkitRead & AppToolkitWrite & AppToolkitInternals——
  * Read+Write = HTTP 直通面 additive 冻结（L1 端点↔方法 1:1，L3 命名镜像：Integration=节点级 /
  * Config=文件级）；Internals = CLI/doctor/桥消费（自由演进）。
@@ -63,11 +65,14 @@ export interface AppToolkitOptions {
   onApplied?: () => void;
 }
 
-/** include 协议白名单（v4.4 D30/P15——键名 = 产出字段名 1:1；per 端点；注册表 additive-only） */
+/** include 协议白名单（v4.4 D30/P15——键名 = 产出字段名 1:1；per 端点；注册表 additive-only；
+ *  v4.6 D36 += integrationFieldRegistry：app/module 三键，provider 轴不加——YAGNI；
+ *  v4.7 D38 += service 键——服务级生效绑定 schema） */
 const INCLUDE_WHITELIST = {
-  app: ['serviceResolutions', 'integrationSchemas'],
-  module: ['serviceResolutions', 'integrationSchemas'],
+  app: ['serviceResolutions', 'integrationSchemas', 'integrationFieldRegistry'],
+  module: ['serviceResolutions', 'integrationSchemas', 'integrationFieldRegistry'],
   provider: ['integrationSchemas'],
+  service: ['integrationSchemas'],
 } as const;
 
 /** include 校验（P15 单点在 toolkit 方法内——壳层仅解析可重复参数，零校验纪律不变）：
@@ -87,12 +92,35 @@ function validateInclude(kind: keyof typeof INCLUDE_WHITELIST, include?: string[
   return new Set(include);
 }
 
+/** 表单层 include 键（D37 轴参严检依据——serviceResolutions 不算） */
+const FORM_INCLUDE_KEYS = ['integrationSchemas', 'integrationFieldRegistry'] as const;
+
+/** v4.6 D37 轴参严检（400 先于 404——镜像输入校验先行）：非空轴参需与表单 include 键同现；
+ *  缺席/空串 ≡ 按实际配置解析（I3——不触发严检）；错轴参数由壳层按名读取，天然静默忽略。 */
+function assertAxisProviderUsable(
+  paramName: 'appProvider' | 'moduleProvider',
+  value: string | undefined,
+  include: ReadonlySet<string>,
+): void {
+  if (typeof value !== 'string' || value.length === 0) return;
+  if (!FORM_INCLUDE_KEYS.some((k) => include.has(k))) {
+    throw new AppToolkitError(
+      'VALIDATION_FAILED',
+      400,
+      `参数 ${paramName} 需与表单 include 键（${FORM_INCLUDE_KEYS.join('、')}）同现——轴参仅重定向表单层双投影`,
+      [paramName],
+    );
+  }
+}
+
 /** ── HTTP 直通面（11 读；L1 镜像律：方法名 = load + URL 资源段；query → 选项字段 L4）── */
 export interface AppToolkitRead {
   loadModules(): Promise<ModulesView>;
-  loadModule(moduleId: string, o?: { include?: string[] }): Promise<ModuleDetailView>;
-  loadApp(o?: { include?: string[] }): Promise<AppView>;
-  loadService(service: string): Promise<ServiceDetail>;
+  /** v4.6 D37：moduleProvider = 轴向假想绑定（缺席/空串 ≡ 按实际配置解析；需与表单 include 键同现） */
+  loadModule(moduleId: string, o?: { include?: string[]; moduleProvider?: string }): Promise<ModuleDetailView>;
+  /** v4.6 D37：appProvider = 轴向假想绑定（缺席/空串 ≡ 按实际配置解析；需与表单 include 键同现） */
+  loadApp(o?: { include?: string[]; appProvider?: string }): Promise<AppView>;
+  loadService(service: string, o?: { include?: string[] }): Promise<ServiceDetail>;
   loadServiceResolutions(services?: string[]): Promise<ServiceResolutionsView>;
   loadServiceResolution(service: string): Promise<ServiceResolutionDetail>;
   loadProviders(): Promise<ProvidersView>;
@@ -201,8 +229,9 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
     // v4.4 D31：门控与内嵌分离——静态方法零门控分支；include=serviceResolutions 按
     // evaluation && strictValidation 双条件装配（<0.9/形态异常 → null，永不 503——技术方案 §2.4：
     // 仅判 strictValidation 会被「严格面在场+求值面缺席」畸形包击穿）
-    async loadModule(moduleId: string, o?: { include?: string[] }): Promise<ModuleDetailView> {
+    async loadModule(moduleId: string, o?: { include?: string[]; moduleProvider?: string }): Promise<ModuleDetailView> {
       const include = validateInclude('module', o?.include); // ① 输入校验先行（400 先于 404）
+      assertAxisProviderUsable('moduleProvider', o?.moduleProvider, include); // ①' D37 轴参严检（先于 404）
       const contracts = await resolveContractsForApp(appDir);
       const snap = snapshot(contracts);
       const view = loadModuleDetailView(snap, moduleId); // ② MODULE_NOT_FOUND
@@ -212,13 +241,17 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
               loadServiceResolutionsView(snap, issues, view.services.map((s) => s.service)))
           : null; // module = demand 服务过滤（≡ 批量 ?service= 语义；issues 恒全量）
       }
-      if (include.has('integrationSchemas')) {
-        view.integrationSchemas = loadModuleIntegrationSchemas(snap, moduleId);
+      if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
+        // v4.6 D37：表单层双投影同源一次计算（双取单算 + I1——假想重定向天然同步）
+        const form = loadModuleFormViews(snap, moduleId, o?.moduleProvider);
+        if (include.has('integrationSchemas')) view.integrationSchemas = form.integrationSchemas;
+        if (include.has('integrationFieldRegistry')) view.integrationFieldRegistry = form.integrationFieldRegistry;
       }
       return view;
     },
-    async loadApp(o?: { include?: string[] }): Promise<AppView> {
+    async loadApp(o?: { include?: string[]; appProvider?: string }): Promise<AppView> {
       const include = validateInclude('app', o?.include);
+      assertAxisProviderUsable('appProvider', o?.appProvider, include); // D37 轴参严检（先于任何计算）
       const contracts = await resolveContractsForApp(appDir);
       const snap = snapshot(contracts);
       const view = loadAppView(snap);
@@ -227,14 +260,23 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
           ? await predicateIssues().then((issues) => loadServiceResolutionsView(snap, issues)) // app = 全量键集
           : null;
       }
-      if (include.has('integrationSchemas')) {
-        view.integrationSchemas = loadAppIntegrationSchemas(snap);
+      if (include.has('integrationSchemas') || include.has('integrationFieldRegistry')) {
+        const form = loadAppFormViews(snap, o?.appProvider); // 双取单算 + I1（同 loadModule）
+        if (include.has('integrationSchemas')) view.integrationSchemas = form.integrationSchemas;
+        if (include.has('integrationFieldRegistry')) view.integrationFieldRegistry = form.integrationFieldRegistry;
       }
       return view;
     },
-    async loadService(service: string) {
+    // v4.7 D38：include 镜像 loadModule 三段式——① 输入校验 400 先于 404 ② 视图 ③ 静态富化（永不 503）
+    async loadService(service: string, o?: { include?: string[] }): Promise<ServiceDetail> {
+      const include = validateInclude('service', o?.include);
       const contracts = await resolveContractsForApp(appDir);
-      return loadServiceDetailView(snapshot(contracts), service);
+      const snap = snapshot(contracts); // 单快照——detail 与 include 装配共享
+      const view = loadServiceDetailView(snap, service);
+      if (include.has('integrationSchemas')) {
+        view.integrationSchemas = loadServiceIntegrationSchemas(snap, service);
+      }
+      return view;
     },
     async loadServiceResolutions(services?: string[]) {
       const contracts = await resolveContractsForApp(appDir);

package/src/index.ts

@@ -85,7 +85,7 @@ export { loadAppView } from './views/app.js';
 export { loadServiceDetailView } from './views/service-detail.js';
 export { loadProvidersView, loadProviderDetailView, loadProviderServiceDetailView } from './views/providers.js';
 export { loadServiceResolutionsView, loadServiceResolutionDetail, resolveServiceSummary } from './views/service-resolutions.js';
-export { loadAppIntegrationSchemas, loadModuleIntegrationSchemas, resolveLayerIntegrationSchemas } from './views/integration-schemas.js';
+export { loadAppIntegrationSchemas, loadModuleIntegrationSchemas, loadServiceIntegrationSchemas, resolveLayerIntegrationSchemas } from './views/integration-schemas.js';
 export { echoForRef, loadCredentialsView } from './views/credentials.js';
 export { loadCredentialTypesView } from './views/credential-types.js';
 export type { ViewContext, ViewSnapshot } from './views/context.js';
@@ -94,7 +94,7 @@ export type { ViewContext, ViewSnapshot } from './views/context.js';
 export { createAppToolkit } from './factory.js';
 export type { AppToolkit, AppToolkitRead, AppToolkitWrite, AppToolkitInternals, AppToolkitOptions } from './factory.js';
 
-// ── DTO（api.md §3 字段级单源——34 类型；agtcodingbox/tbox-ai-coding import type 消费）──
+// ── DTO（api.md §3 字段级单源——36 类型；agtcodingbox/tbox-ai-coding import type 消费）──
 export type {
   ServiceStatus,
   BindingLayer,
@@ -104,8 +104,10 @@ export type {
   ModuleDetailView,
   AppView,
   ServiceDetail,
+  ServiceIntegrationSchemas,
   ProviderBinding,
   LayerIntegrationSchemas,
+  IntegrationFieldRegistryView,
   CredentialsView,
   CredentialBindingEcho,
   CredentialTypesView,

package/src/integrations/credentials.ts

@@ -141,7 +141,7 @@ export function reconcileOrphanCredentials(appDir: string): OrphanIssue[] {
     issues.push({
       severity: 'warning',
       code: 'ORPHANED_CREDENTIAL',
-      message: `config/credentials/${stem}.json 不再被引用（凭据文件保留，可手动清理）`,
+      message: `${stemToFilePath(stem)} 不再被引用（凭据文件保留，可手动清理）`,
     });
   }
   return issues;

package/src/integrations/predicate.ts

@@ -481,7 +481,8 @@ export function evaluateIntegrationServices(
   //   不应被 B 厂商判死。引用面（v3）= root.provider ∪ domains.*.provider ∪ 槽级（含内联
   //   .provider）——terse 化后槽级双字段退场，引用面不上移即静默漏检（N2）。
   //   保守跳过条件（无法确证即不判死——误报会阻断部署）：任一引用厂商 configSchema 文件缺失，
-  //   或被绑定但零 configSchema 声明（如 mock local 供给——无 schema 知识）。
+  //   或被绑定但零 configSchema 声明（如 local 供给未声明 configSchema——无 schema 知识。
+  //   注：provider-mock 0.3.0 起全槽带 schema，mock 绑定下本检查已生效）。
   if (vendorConfigKeys) {
     const referenced = new Set<string>();
     let schemaIncomplete = false;

package/src/integrations/write.ts

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import Ajv from 'ajv';
 import { resolveContractsForApp } from '../core/contracts-resolver.js';
+import { stemToFilePath } from '../core/credential-format.js';
 import type { FileCache } from '../core/file-cache.js';
 import { writeAtomic } from '../core/fskit.js';
 import { SAFE_NAME_PATTERN } from '../core/module-schema.js';
@@ -36,8 +37,9 @@ import { AppToolkitError } from '../core/errors.js';
  *  7 严格整文档校验（contracts parseIntegrationsConfig——触发 = !noDiff ∥ 有凭据输入）
  *  8 凭据工件落盘（**后置于校验通过**——防「凭据已写 + zod 拒绝」不一致态；
  *    dryRun → writeCredentialArtifacts 零写盘 + existsSync 预览）
- *  9 finalize：written = integrations 实写 ∥ 凭据实写（**D-B2**）；files 分列两类路径；
- *    restartScheduled = written && onApplied（凭据影响 boot 装配——重启正当）；写后缓存失效
+ *  9 finalize（D35）：planned = 将触碰（files 预览单源——dryRun 响应 ≡ 同 body 真实写，files 逐字对称）；
+ *    written = 实写（!dryRun 派生，D-B2）；restartScheduled = written && onApplied（凭据影响 boot 装配——
+ *    重启正当）；写后缓存失效
  * 归一化：N1 模块节点 {} → 删 domains[键]；N3 服务节点 {} 不归一化（显式通配激活 = 合法 TIER0 态）；
  * N2 已随 ?instance= 退役。dryRun（PUT only）：复读完整管线不落盘不排程。
  * DELETE：节点移除 + 孤儿凭据写后对账（覆盖 DELETE 与 PUT 替换两类来源，只报告不清理——D9）。
@@ -245,11 +247,13 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
     appliedCredentials: AppliedCredential[],
     issues: IntegrationServiceIssue[],
     dryRun: boolean | undefined,
-    credentialsWritten: boolean,
   ): SaveResult {
-    // D-B2：written ⟺ 任一文件实写；files 分列（integrations.json + 凭据路径）；
-    // restartScheduled 跟随 written（凭据文件影响 boot 装配——重启正当）
-    const integrationsWritten = !dryRun && next !== null;
+    // D35 双轴派生：planned = 将触碰（files 预览单源——dryRun 响应 ≡ 同 body 真实写，files 逐字对称）；
+    // written = 实际落盘（!dryRun 派生——D-B2）；restartScheduled 跟随 written（凭据文件影响 boot 装配——重启正当）
+    const integrationsPlanned = next !== null;
+    const credentialsPlanned = appliedCredentials.length > 0;
+    const integrationsWritten = !dryRun && integrationsPlanned;
+    const credentialsWritten = !dryRun && credentialsPlanned;
     if (integrationsWritten) {
       writeAtomic(join(appDir, INTEGRATIONS_FILE), `${JSON.stringify(next, null, 2)}\n`);
       cache?.invalidate([join(appDir, INTEGRATIONS_FILE)]);
@@ -258,8 +262,8 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
     const restartScheduled = written && onApplied !== undefined;
     if (restartScheduled) onApplied?.();
     const files: string[] = [];
-    if (integrationsWritten) files.push(INTEGRATIONS_FILE);
-    if (credentialsWritten) files.push(...appliedCredentials.map((a) => `config/credentials/${a.stem}.json`));
+    if (integrationsPlanned) files.push(INTEGRATIONS_FILE);
+    if (credentialsPlanned) files.push(...appliedCredentials.map((a) => stemToFilePath(a.stem)));
     return {
       written,
       restartScheduled,
@@ -361,7 +365,7 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
       const dryRun = writeOpts.dryRun === true;
       const applied = writeCredentialArtifacts(appDir, plan, dryRun);
       issues.push(...registryCheck(next));
-      return finalize(noDiff ? null : next, applied, issues, writeOpts.dryRun, !dryRun && plan.length > 0);
+      return finalize(noDiff ? null : next, applied, issues, writeOpts.dryRun);
     },
 
     applyModule(moduleId: string, node: Record<string, unknown>, writeOpts: WriteOptions = {}): SaveResult {
@@ -417,7 +421,7 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
       }
       runStrictValidation(next, issues, `domains.${domainKey}.`);
       issues.push(...registryCheck(next));
-      return finalize(next, [], issues, writeOpts.dryRun, false);
+      return finalize(next, [], issues, writeOpts.dryRun);
     },
 
     applyService(service: string, node: Record<string, unknown>, writeOpts: WriteOptions = {}): SaveResult {
@@ -474,7 +478,7 @@ export function createWriteCore(appDir: string, opts: WriteCoreOptions = {}): Wr
       const dryRun = writeOpts.dryRun === true;
       const applied = writeCredentialArtifacts(appDir, plan, dryRun);
       issues.push(...registryCheck(next));
-      return finalize(noDiff ? null : next, applied, issues, writeOpts.dryRun, !dryRun && plan.length > 0);
+      return finalize(noDiff ? null : next, applied, issues, writeOpts.dryRun);
     },
 
     deleteService(service: string): SaveResult {

package/src/views/integration-schemas.ts

@@ -1,21 +1,32 @@
-import type { LayerIntegrationSchemas } from '../dto.js';
+import type { IntegrationFieldRegistryView, LayerIntegrationSchemas, ServiceIntegrationSchemas } from '../dto.js';
 import { isSupplied, type ViewSnapshot } from './context.js';
-import { readSchemaRef } from './providers.js';
-import { moduleDomainWritable, providerFootprint, resolveDomainBinding } from '../integrations/domain-binding.js';
+import { resolveServiceConfigSchema } from './providers.js';
+import { domainOfService, moduleDomainWritable, providerFootprint, resolveDomainBinding } from '../integrations/domain-binding.js';
+import { isControlledInlineProvider } from '../integrations/predicate.js';
 
 /**
- * 层级 config schema 计算视图（v4.4 D32——静态轴富化，零 contracts 求值）。
- * config 表单结构三形态同源（P10）：槽级组合单体（providers.ts）/ 层级内嵌（本文件——
- * /app、/modules/:m include）/ 供给轴批量（providers.ts include——切换态）。
+ * 层级/服务级 config schema 计算视图（v4.4 D32——静态轴富化，零 contracts 求值；v4.7 D38 服务级）。
+ * config 表单结构四形态同源（P10）：槽级组合单体（providers.ts）/ 层级内嵌（本文件——
+ * /app、/modules/:m include）/ 供给轴批量（providers.ts include——切换态）/ 服务级生效绑定
+ * （本文件 loadServiceIntegrationSchemas——/services/:s include）。
  *
  * 计算规则（D32 裁决）：禁交集——config 五层浅合并下「部分服务认识的字段」合法（谓词 #7
  * 并集键集同依据）；禁合成单一 schema——required/title 冲突的有损代数；产物 = 扁平映射，
  * 分组归客户端纯呈现。层级 schema = 表单引导**非写入门禁**（P16——写路径校验权威恒在谓词
  * #7 键集 + ajv 凭据链；root 级口径差：#7 = 引用厂商并集，表单 = 层生效厂商单厂商作用域）。
+ *
+ * v4.6（D36/D37 additive 精化）：**原始投影**（loadApp/loadModuleIntegrationSchemas）原样保留
+ * 为诊断面 / registry 输入；**消费投影** = buildIntegrationFieldRegistry（字段级合并代数
+ * R1/R2/R3 服务端单源，conflict 折叠 schema:null）；**轴向假想绑定** = formProviderOf
+ * （override ?? 实际解析——双投影同源同口径，formViews 装配层一次计算两投影）。
+ * 单源三锚：层级 schema 计算 = resolveLayerIntegrationSchemas / 生效厂商解析 = formProviderOf /
+ * 合并代数 = buildIntegrationFieldRegistry。
  */
 
-/** 核心纯函数：显式作用域（provider null → 整字段 null；services 逐项 serviceSchemas 复合键 +
- *  readSchemaRef——既有解析路径零新读；供给在场未声明 = null，mock 合法） */
+/** 核心纯函数：显式作用域（provider null → 整字段 null；services 逐项 resolveServiceConfigSchema
+ *  复合解析——v4.7 D38 收口，零新读取路径；供给在场未声明 = null，mock 合法） */
+export function resolveLayerIntegrationSchemas(snapshot: ViewSnapshot, provider: string, services: readonly string[]): LayerIntegrationSchemas;
+export function resolveLayerIntegrationSchemas(snapshot: ViewSnapshot, provider: string | null, services: readonly string[]): LayerIntegrationSchemas | null;
 export function resolveLayerIntegrationSchemas(
   snapshot: ViewSnapshot,
   provider: string | null,
@@ -24,30 +35,192 @@ export function resolveLayerIntegrationSchemas(
   if (provider === null) return null;
   const out: LayerIntegrationSchemas['services'] = {};
   for (const s of services) {
-    const entry = snapshot.walk.serviceSchemas[`${provider}\u0000${s}`];
-    out[s] = { configSchema: entry ? readSchemaRef(snapshot.appDir, entry.packageDir, entry.configSchema) : null };
+    out[s] = { configSchema: resolveServiceConfigSchema(snapshot, provider, s) };
   }
   return { provider, services: out };
 }
 
-/** app 级 loader：生效厂商 = root.provider（非空字符串，缺席 → 整字段 null——D32「未绑定」）；
- *  作用域 = 该厂商供给足迹全量（≠ AppView.services——root.config 流向包括模块服务在内的所有服务） */
-export function loadAppIntegrationSchemas(snapshot: ViewSnapshot): LayerIntegrationSchemas | null {
-  const p = (snapshot.integrations as { provider?: unknown } | null)?.provider;
-  const provider = typeof p === 'string' && p.length > 0 ? p : null;
-  if (provider === null) return null;
-  return resolveLayerIntegrationSchemas(snapshot, provider, providerFootprint(snapshot.catalog, provider));
+// ── v4.6 D36/D37：合并代数助手（内联——深相等判定基）──
+
+/** 稳定序列化（键序归一——R2 深相等 / R1 签名比较统一基；数组保序、对象键 sort） */
+function stableSerialize(v: unknown): string {
+  if (v === null || typeof v !== 'object') return JSON.stringify(v ?? null) as string;
+  if (Array.isArray(v)) return `[${v.map(stableSerialize).join(',')}]`;
+  const keys = Object.keys(v as Record<string, unknown>).sort();
+  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableSerialize((v as Record<string, unknown>)[k])}`).join(',')}}`;
 }
 
-/** module 级 loader：仅 writable 单域；生效厂商 = resolveDomainBinding（D32/R4 单源）；
- *  作用域 = demand ∩ 该厂商供给；多域/零域/共享键/未绑定 → 整字段 null（表单降级 = ExtraFields） */
-export function loadModuleIntegrationSchemas(snapshot: ViewSnapshot, moduleId: string): LayerIntegrationSchemas | null {
+/** enum 缺席哨兵（≠ 任何实际集签名——混布必不等） */
+const NO_ENUM = '\u0000no-enum';
+
+/** enum 集签名（去重排序——序不敏感） */
+function enumSig(sub: Record<string, unknown>): string {
+  const e = sub.enum;
+  if (!Array.isArray(e)) return NO_ENUM;
+  return `[${[...new Set(e.map(stableSerialize))].sort().join(',')}]`;
+}
+
+/** 顶层 type 签名（数组形态序敏感——严格全等）；非对象（含布尔子 schema）/ type 缺席 → null（R3） */
+function typeSig(sub: unknown): string | null {
+  if (!sub || typeof sub !== 'object' || Array.isArray(sub)) return null;
+  const t = (sub as Record<string, unknown>).type;
+  return t === undefined ? null : stableSerialize(t);
+}
+
+/** D36 合并代数单点（R1/R2/R3——唯一扩展点；保守降级：不可调和 → null，客户端 RawJson 保真） */
+function mergeFieldSources(sources: ReadonlyArray<{ subschema: unknown }>): object | null {
+  const sigs = sources.map((s) => typeSig(s.subschema));
+  if (sigs.some((s) => s === null) || new Set(sigs).size > 1) return null; // R3：非对象/type 缺席/type 不等
+  if (sigs[0] === '"object"') {
+    // R2：全源稳定序列化深相等 → 首源；异构 → null
+    const first = stableSerialize(sources[0].subschema);
+    return sources.every((s) => stableSerialize(s.subschema) === first) ? (sources[0].subschema as object) : null;
+  }
+  // R1：标量型——enum 集全等（含双无哨兵）→ 首源；不等/混布 → null
+  const es = new Set(sources.map((s) => enumSig(s.subschema as Record<string, unknown>)));
+  return es.size === 1 ? (sources[0].subschema as object) : null;
+}
+
+/** D36 registry 构造（纯函数——消费 resolveLayerIntegrationSchemas 产物，禁旁路直取 serviceSchemas）。
+ *  fields 收集零过滤（布尔/非对象子 schema 入列，判定全权归 mergeFieldSources——S8 互证等式由
+ *  收集定义结构性闭合）；schemaless 仅 configSchema === null（布尔/畸形整 schema 防御跳过——
+ *  不入 schemaless、零参与聚合；D32 运行时畸形，非契约面）。 */
+export function buildIntegrationFieldRegistry(
+  layer: LayerIntegrationSchemas,
+  o?: { unsupplied?: string[] },
+): IntegrationFieldRegistryView {
+  const schemaless: string[] = [];
+  let additionalPropertiesAllowed = true;
+  const buckets = new Map<string, Array<{ service: string; subschema: unknown; required: boolean }>>();
+  for (const [service, entry] of Object.entries(layer.services)) {
+    // 插入序 = scope 遍历序（app 字母序 / module demand 序）——fields 首声明序由此保证
+    const schema = entry.configSchema;
+    if (schema === null) {
+      schemaless.push(service);
+      continue;
+    }
+    if (!schema || typeof schema !== 'object' || Array.isArray(schema)) continue;
+    const s = schema as Record<string, unknown>;
+    if (s.additionalProperties === false) additionalPropertiesAllowed = false;
+    const props = s.properties;
+    if (!props || typeof props !== 'object' || Array.isArray(props)) continue; // ≡ 谓词 collectPropertyKeys 守卫
+    const required = Array.isArray(s.required) ? s.required : [];
+    for (const key of Object.keys(props)) {
+      const bucket = buckets.get(key) ?? [];
+      bucket.push({ service, subschema: (props as Record<string, unknown>)[key], required: required.includes(key) });
+      buckets.set(key, bucket);
+    }
+  }
+  const fields: IntegrationFieldRegistryView['fields'] = [];
+  for (const [key, sources] of buckets) {
+    fields.push({
+      key,
+      schema: mergeFieldSources(sources),
+      sources: sources.map(({ service, required }) => ({ service, required })),
+    });
+  }
+  return {
+    provider: layer.provider,
+    schemaless,
+    unsupplied: [...(o?.unsupplied ?? [])],
+    additionalPropertiesAllowed,
+    fields,
+  };
+}
+
+/** D37 生效厂商解析单源（实际/假想同径）：override（非空串）?? 实际解析。
+ *  空串归一（I3）单点；module 轴 D34 不可写/不在册 → null（override 不豁免——预览服务于保存）。 */
+export function formProviderOf(
+  axis: 'app' | 'module',
+  snapshot: ViewSnapshot,
+  moduleId?: string,
+  override?: string,
+): string | null {
+  const ovr = typeof override === 'string' && override.length > 0 ? override : undefined;
+  if (axis === 'app') {
+    if (ovr !== undefined) return ovr;
+    const p = (snapshot.integrations as { provider?: unknown } | null)?.provider;
+    return typeof p === 'string' && p.length > 0 ? p : null;
+  }
   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;
-  const provider = resolveDomainBinding(snapshot.integrations, w.domainKey).provider;
-  if (provider === null) return null;
+  if (!w.writable) return null; // D34 不豁免
+  if (ovr !== undefined) return ovr;
+  return resolveDomainBinding(snapshot.integrations, w.domainKey).provider;
+}
+
+/** D36/D37 表单层双投影（I1：同源同口径一次计算——双取单算 by construction） */
+export interface LayerFormViews {
+  integrationSchemas: LayerIntegrationSchemas | null;
+  integrationFieldRegistry: IntegrationFieldRegistryView | null;
+}
+
+/** 防御双 null（module 不在册/不可写/未绑定、app 未绑定——F3） */
+const NULL_FORM_VIEWS: LayerFormViews = { integrationSchemas: null, integrationFieldRegistry: null };
+
+/** 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) };
+}
+
+/** module 轴装配：仅 writable 单域（D34）；scope = demand ∩ 该厂商供给；unsupplied 同点派生
+ *  （demand − 供给，Set 去重保序——manifest demand 不去重防御）。 */
+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);
-  return resolveLayerIntegrationSchemas(snapshot, provider, demand.filter((s) => isSupplied(snapshot.catalog, provider, s)));
+  const supplied = (s: string): boolean => isSupplied(snapshot.catalog, provider, s);
+  const layer = resolveLayerIntegrationSchemas(snapshot, provider, demand.filter(supplied));
+  return {
+    integrationSchemas: layer,
+    integrationFieldRegistry: buildIntegrationFieldRegistry(layer, {
+      unsupplied: [...new Set(demand.filter((s) => !supplied(s)))],
+    }),
+  };
+}
+
+/** app 级 loader（v4.6 委托化——签名零改动，公开面保持；假想态归 loadAppFormViews override 参） */
+export function loadAppIntegrationSchemas(snapshot: ViewSnapshot): LayerIntegrationSchemas | null {
+  return loadAppFormViews(snapshot).integrationSchemas;
+}
+
+/** module 级 loader（v4.6 委托化——同上；多域/零域/共享键/未绑定 → 整字段 null，表单降级 = ExtraFields） */
+export function loadModuleIntegrationSchemas(snapshot: ViewSnapshot, moduleId: string): LayerIntegrationSchemas | null {
+  return loadModuleFormViews(snapshot, moduleId).integrationSchemas;
+}
+
+/** 服务级 loader（v4.7 D38）：四分支穷举（node.provider = 文件 services[s].provider 逐字原值；
+ *  实例层无条件排除——node 级口径）；非空三分支归约一次复合解析。
+ *  ① undefined/'' → resolveDomainBinding 域级联（域 + 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 污染坏节点） */
+export function loadServiceIntegrationSchemas(
+  snapshot: ViewSnapshot,
+  service: string,
+): ServiceIntegrationSchemas | null {
+  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
+      ? null
+      : { provider: binding.provider, configSchema: resolveServiceConfigSchema(snapshot, binding.provider, service) };
+  }
+  if (typeof p === 'string') {
+    return { provider: p, configSchema: resolveServiceConfigSchema(snapshot, p, service) };
+  }
+  if (isControlledInlineProvider(p)) {
+    const decl = p as { provider: string; configSchema?: string };
+    return { provider: decl.provider, configSchema: resolveServiceConfigSchema(snapshot, decl.provider, service, decl.configSchema) };
+  }
+  return null;
 }