@tbox.cn/app-toolkit 0.1.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;
@@ -34,13 +36,13 @@ export interface ModuleDeclaration {
   description: string;
 }
 
-/** 服务需求声明（模块 demand 单元；defaults 唯一落位 ServiceDetail） */
+/** 服务需求声明（模块 demand 单元 / 平台服务条目——v4.4 D29 双端点同型；defaults 唯一落位 ServiceDetail） */
 export interface ServiceDemand {
   service: string;
   /** manifest demand meta；缺席 UI 回退 service id */
   title?: string;
   description?: string;
-  /** demand optional !== false（多模块 OR 聚合见 resolution echo） */
+  /** demand optional === false（多模块 OR 聚合见 resolution echo；平台服务条目恒 false） */
   required: boolean;
 }
 
@@ -48,18 +50,78 @@ export interface ServiceDemand {
 
 /** GET /modules/:module（模块静态一站式 · PUT 读对偶） */
 export interface ModuleDetailView {
-  /** domains[换算键] 节点原值；未配置 = null */
+  /** v4.4 D34：demand 服务首段去重（排序；1..N；零域 = []） */
+  domainKeys: string[];
+  /** domains[换算键] 节点原值；未配置 = null；v4.4 D34：仅单域（writable）时在场——多域/零域/共享键无单键落点 */
   integration: ModuleIntegrationNode | null;
+  /** v4.4 D34：每域一条厂商绑定解析（单域 = 单元素；零域 = []；resolveDomainBinding 单源） */
+  providerBindings: ProviderBinding[];
+  /** v4.4 D34：单域 && 域键无跨模块共享（moduleDomainWritable 单源——读标志与写守卫共用） */
+  configEditable: boolean;
   /** 本模块 demand（卡片展开 + 编辑器静态上下文自足） */
   services: ServiceDemand[];
+  /** v4.4 D31：include=serviceResolutions 内嵌（demand 服务过滤 ≡ 批量 ?service= 语义；<0.9/形态异常 → null——永不 503） */
+  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 单源） */
+export interface ProviderBinding {
+  /** 域键（= domainKeys 成员；多域模块每域一条） */
+  domain: string;
+  /** domains[domain].provider ?? root.provider（双缺 = null） */
+  effective: string | null;
+  /** 生效来源层（双缺 = null） */
+  layer: 'module' | 'app' | null;
+}
+
+/** 层级 config schema 计算（v4.4 D32——静态轴富化，零 contracts） */
+export interface LayerIntegrationSchemas {
+  /** 层生效厂商（resolveDomainBinding 单源） */
+  provider: string;
+  /** 模块级 = 本模块 demand ∩ 该厂商供给；应用级 = 供给足迹全量（configSchema = raw draft 2020-12 原文；供给在场未声明 = null） */
+  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 {
-  /** 平台服务 id（服务词汇 − 模块占用；owner/标题 UI 按首点段派生） */
-  services: string[];
+  /** 平台服务（v4.4 D29：服务词汇 − 模块占用——与模块 demand 同型 ServiceDemand[]；
+   *  title/description 缺席 = UI 回退 service id；required 恒 false——平台服务无 demand 源） */
+  services: ServiceDemand[];
   /** root 节点原值；文件缺席 = null */
   integration: AppIntegrationNode | null;
+  /** v4.4 D31：include=serviceResolutions 内嵌（全量键集 ≡ 批量无参；<0.9/形态异常 → null——永不 503） */
+  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（服务静态单体） */
@@ -70,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;
 }
 
 // ===== 求值轴 =====
@@ -91,6 +165,9 @@ export interface ServiceResolutionEntry {
   statusMessage?: string;
   /** 最特异声明层厂商名（跨层事实） */
   provider?: string;
+  /** v4.4：provider 来源声明层（默认实例口径，与 status 同轴）；恒 = provider 字段来源层
+   *  （ok/binding-unresolved 取声明层；未配置双缺席）；≡ 单体 inheritance 链逆序首个有 provider 的层 */
+  layer?: BindingLayer;
   /** provider 在场时在场：(provider, service) ∈ 供给关系 */
   supplied?: boolean;
   /** owner 模块 install id；平台服务/孤儿缺席 */
@@ -194,8 +271,7 @@ export interface ResolvedInstance {
   statusMessage?: string;
   /** 该实例合并结果 */
   effective?: EffectiveBinding;
-  /** 掩码回显 */
-  credential?: CredentialEcho;
+  // v4.4 D33：credential（掩码回显）删净——凭据状态归 GET /credentials（求值路径零凭据文件 I/O）
 }
 
 // ===== 供给轴（静态）=====
@@ -222,7 +298,11 @@ export interface ProviderDetail {
    *  多元素 = 升级窗口，UI 出 impl 选择器，PUT 显式钉版） */
   services: Record<
     string,
-    { implementations: Array<{ implementation: string; credentialType: string }> }
+    {
+      implementations: Array<{ implementation: string; credentialType: string }>;
+      /** v4.4 F5：include=integrationSchemas 切换态批量（纯 config——凭据结构归 /credential-types） */
+      integrationSchemas?: { configSchema: object | null };
+    }
   >;
 }
 
@@ -230,16 +310,47 @@ export interface ProviderDetail {
 export interface ProviderServiceDetail {
   provider: string;
   service: string;
-  /** ★ 恒数组（通常 1） */
+  /** ★ 恒数组（通常 1）；credentialType 保留（/credential-types 寻址键） */
   implementations: Array<{ implementation: string; credentialType: string }>;
-  /** 厂商集成该服务的表单 schema（integration 域专属） */
+  /** 厂商集成该服务的表单 schema（integration 域专属）——v4.4 D33 纯 config（credentialSchema 删净） */
   integrationSchemas: {
     /** raw draft 2020-12 原文零转换；供给在场未声明 = null（mock 合法）；解析自默认 impl */
     configSchema: object | null;
-    credentialSchema: object | null;
   };
 }
 
+// ===== 凭据域（v4.4 D33 独立端点）=====
+
+/** GET /credentials：绑定位全量掩码回显（应用状态轴；GET 永无真值） */
+export interface CredentialsView {
+  /** root 位；byInstance 键集 = 注册表 ids ∩ 有 ref（无 ref 的注册实例不出现；未注册 ref 跳过不虚报） */
+  app: CredentialBindingEcho;
+  /** 键集 = 已配置服务；byInstance 键集 = 节点 instances map 全键（含 '*'）——键域不对称 = 文件语义忠实镜像 */
+  services: Record<string, CredentialBindingEcho>;
+}
+
+/** 一个形状两处（镜像文件层「标量 + ByInstance」模式） */
+export interface CredentialBindingEcho {
+  /** 本位 credentialRef（root.credentialRef / services[s].credentialRef）；ref 缺席/文件缺失 → null */
+  credential: CredentialEcho | null;
+  /** 覆盖位（credentialRefByInstance / instances[k].credentialRef） */
+  byInstance: Record<string, CredentialEcho | null>;
+}
+
+/** GET /credential-types[?provider=]：凭据结构清单（供给轴静态；?provider= 过滤语义 ≡ ?service=） */
+export interface CredentialTypesView {
+  types: CredentialTypeEntry[];
+}
+
+export interface CredentialTypeEntry {
+  /** '-' = 无凭据语义（mock/local——UI 判 '-' 不渲染凭据表单） */
+  credentialType: string;
+  /** 声明来源包名 */
+  owner: string;
+  /** raw draft 2020-12 原文；未声明 = null（ExtraFields 自由键值同轨） */
+  credentialSchema: object | null;
+}
+
 // ===== 通用 =====
 
 export interface EffectiveBinding {
@@ -289,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,10 +19,15 @@ 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 { 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';
 import type {
   AppIntegrationNode,
   AppView,
+  CredentialTypesView,
+  CredentialsView,
   ModuleDetailView,
   ModuleIntegrationNode,
   ProviderDetail,
@@ -36,15 +41,19 @@ import type {
 } from './dto.js';
 
 /**
- * createAppToolkit（C4 工厂）：22 方法 = 9 读（HTTP 直通）+ 4 写（HTTP 直通）+ 9 迁移面（Internals）。
+ * createAppToolkit（C4 工厂；v4.4——24 方法 = 11 读（含 credentials/credential-types 双端点）
+ * + 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/桥消费（自由演进）。
  *
  * **门控断言单点（policy at edge）**：求值（2）+ 写（4）+ ensureMockBindings / writeIntegrationsConfig /
  * evaluateIntegrationServices 入口 assertContractsUsable——strictValidation === false → 503
- * CONTRACTS_NOT_RESOLVED（message 三分支）；静态方法不门控（永不 503——铁律 #3）；
- * integrations/ views/ 机制层保持纯函数。
+ * CONTRACTS_NOT_RESOLVED；静态方法不门控（永不 503——铁律 #3）；**include 装配为条件分支非门控**
+ * （D31——serviceResolutions 按 evaluation && strictValidation 双条件装配，<0.9/形态异常 → null，
+ * 静态端点永不 503；integrationSchemas 纯静态轴零 contracts）；integrations/ views/ 机制层保持纯函数。
  *
  * 并发：进程内写串行（per-factory promise chain）+ 原子写 + 写后本实例缓存即刻失效（D26）。
  * onApplied（D7）：toolkit 判定「需要重启」（实际落盘且非 dryRun/no-diff）→ 调用一次 +
@@ -56,17 +65,71 @@ export interface AppToolkitOptions {
   onApplied?: () => void;
 }
 
-/** ── HTTP 直通面（9 读；L1 镜像律：方法名 = load + URL 资源段）── */
+/** 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', 'integrationFieldRegistry'],
+  module: ['serviceResolutions', 'integrationSchemas', 'integrationFieldRegistry'],
+  provider: ['integrationSchemas'],
+  service: ['integrationSchemas'],
+} as const;
+
+/** include 校验（P15 单点在 toolkit 方法内——壳层仅解析可重复参数，零校验纪律不变）：
+ *  未知/越权键 → 400 VALIDATION_FAILED fields ['include']；重复键静默去重。 */
+function validateInclude(kind: keyof typeof INCLUDE_WHITELIST, include?: string[]): Set<string> {
+  if (!include || include.length === 0) return new Set();
+  const allowed = INCLUDE_WHITELIST[kind] as readonly string[];
+  const rejected = [...new Set(include)].filter((k) => !allowed.includes(k));
+  if (rejected.length > 0) {
+    throw new AppToolkitError(
+      'VALIDATION_FAILED',
+      400,
+      `include 含未知或不适用于本端点的键：${rejected.join('、')}（白名单：${allowed.join('、')}）`,
+      ['include'],
+    );
+  }
+  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): Promise<ModuleDetailView>;
-  loadApp(): 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>;
-  loadProvider(provider: string): Promise<ProviderDetail>;
+  loadProvider(provider: string, o?: { include?: string[] }): Promise<ProviderDetail>;
   loadProviderService(provider: string, service: string): Promise<ProviderServiceDetail>;
+  /** GET /credentials（v4.4 D33——应用状态轴；零门控，永不 503） */
+  loadCredentials(): Promise<CredentialsView>;
+  /** GET /credential-types[?provider=]（v4.4 D33——供给轴静态；零门控，永不 503） */
+  loadCredentialTypes(provider?: string): Promise<CredentialTypesView>;
 }
 
 /** ── HTTP 直通面（4 写；body ≡ 文件节点全量替换；DELETE 无 dryRun/无 options）── */
@@ -163,17 +226,57 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
       const contracts = await resolveContractsForApp(appDir);
       return loadModulesView(snapshot(contracts));
     },
-    async loadModule(moduleId: string) {
+    // v4.4 D31：门控与内嵌分离——静态方法零门控分支；include=serviceResolutions 按
+    // evaluation && strictValidation 双条件装配（<0.9/形态异常 → null，永不 503——技术方案 §2.4：
+    // 仅判 strictValidation 会被「严格面在场+求值面缺席」畸形包击穿）
+    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);
-      return loadModuleDetailView(snapshot(contracts), moduleId);
+      const snap = snapshot(contracts);
+      const view = loadModuleDetailView(snap, moduleId); // ② MODULE_NOT_FOUND
+      if (include.has('serviceResolutions')) {
+        view.serviceResolutions = contracts.evaluation && contracts.strictValidation
+          ? await predicateIssues().then((issues) =>
+              loadServiceResolutionsView(snap, issues, view.services.map((s) => s.service)))
+          : null; // module = demand 服务过滤（≡ 批量 ?service= 语义；issues 恒全量）
+      }
+      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() {
+    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);
-      return loadAppView(snapshot(contracts));
+      const snap = snapshot(contracts);
+      const view = loadAppView(snap);
+      if (include.has('serviceResolutions')) {
+        view.serviceResolutions = contracts.evaluation && contracts.strictValidation
+          ? await predicateIssues().then((issues) => loadServiceResolutionsView(snap, issues)) // app = 全量键集
+          : null;
+      }
+      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);
@@ -191,14 +294,24 @@ export function createAppToolkit(appDir: string, options: AppToolkitOptions = {}
       const contracts = await resolveContractsForApp(appDir);
       return loadProvidersView(snapshot(contracts));
     },
-    async loadProvider(provider: string) {
+    async loadProvider(provider: string, o?: { include?: string[] }): Promise<ProviderDetail> {
+      const include = validateInclude('provider', o?.include);
       const contracts = await resolveContractsForApp(appDir);
-      return loadProviderDetailView(snapshot(contracts), provider);
+      return loadProviderDetailView(snapshot(contracts), provider, include);
     },
     async loadProviderService(provider: string, service: string) {
       const contracts = await resolveContractsForApp(appDir);
       return loadProviderServiceDetailView(snapshot(contracts), provider, service);
     },
+    // v4.4 D33：凭据域双端点（应用状态轴 / 供给轴静态——零门控零求值，永不 503）
+    async loadCredentials(): Promise<CredentialsView> {
+      const contracts = await resolveContractsForApp(appDir);
+      return loadCredentialsView(snapshot(contracts));
+    },
+    async loadCredentialTypes(provider?: string): Promise<CredentialTypesView> {
+      const contracts = await resolveContractsForApp(appDir);
+      return loadCredentialTypesView(snapshot(contracts), provider);
+    },
   };
 
   const core = createWriteCore(appDir, {

package/src/index.ts

@@ -79,19 +79,22 @@ export type { AppliedCredential, CredentialInput, OrphanIssue, PlannedCredential
 export { AppToolkitError, contractsNotResolvedMessage } from './core/errors.js';
 export type { AppToolkitErrorCode } from './core/errors.js';
 
-// ── views（五投影——静态四轴 + 求值轴；铁律 #3 静态/求值分离由投影结构承载）──
-export { loadModulesView, loadModuleDetailView, moduleDomainKeyOf } from './views/modules.js';
+// ── views（静态四轴 + 求值轴 + v4.4 层级 schema/凭据域；铁律 #3 静态/求值分离由投影结构承载）──
+export { loadModulesView, loadModuleDetailView } from './views/modules.js';
 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, 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';
 
-// ── 工厂（22 方法 = 9 读 + 4 写 + 9 Internals；门控 policy at edge；写串行）──
+// ── 工厂（v4.4：24 方法 = 11 读 + 4 写 + 9 Internals；门控 policy at edge；include 条件装配非门控）──
 export { createAppToolkit } from './factory.js';
 export type { AppToolkit, AppToolkitRead, AppToolkitWrite, AppToolkitInternals, AppToolkitOptions } from './factory.js';
 
-// ── DTO（api.md §3 字段级单源——28 类型；agtcodingbox/tbox-ai-coding import type 消费）──
+// ── DTO（api.md §3 字段级单源——36 类型；agtcodingbox/tbox-ai-coding import type 消费）──
 export type {
   ServiceStatus,
   BindingLayer,
@@ -101,6 +104,14 @@ export type {
   ModuleDetailView,
   AppView,
   ServiceDetail,
+  ServiceIntegrationSchemas,
+  ProviderBinding,
+  LayerIntegrationSchemas,
+  IntegrationFieldRegistryView,
+  CredentialsView,
+  CredentialBindingEcho,
+  CredentialTypesView,
+  CredentialTypeEntry,
   ServiceResolutionsView,
   ServiceResolutionEntry,
   ServiceResolution,

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/domain-binding.ts

@@ -0,0 +1,81 @@
+import type { WalkCatalog, WalkManifestsResult, WalkModuleInfo } from '../assembly/walk-manifests.js';
+
+/**
+ * 域级联绑定单源（v4.4 F1/F3——integrations 层落位依据：谓词（同层）/ 写核（同层）/
+ * views（下层可向上 import）三向消费的唯一公共下层；import 前缀 guard 覆盖）。
+ *
+ * 知识锚（module-tab note 单源锚表）：
+ *   域级联（值 + 层）  = resolveDomainBinding —— 谓词 #7（等价重构，语义 ≡
+ *                        `domains[d].provider ?? root.provider`）/ deriveBindingLayer 域级段 /
+ *                        buildInheritance module 段 / ProviderBinding
+ *   来源层四层推导     = deriveBindingLayer（views/service-resolutions，域级段改调本文件）
+ *   写通道可用性       = moduleDomainWritable —— configEditable 读标志 / applyModule 400 守卫共用
+ *                        （D34：读标志与写守卫一函数）
+ */
+
+/** 域前缀换算（service → 首点段；自 views/context.ts 迁入——文件格式词汇，静态面零 contracts 依赖） */
+export function domainOfService(service: string): string {
+  const i = service.indexOf('.');
+  return i === -1 ? service : service.slice(0, i);
+}
+
+/** 域级联绑定解析（值 + 来源层）：provider 取非空字符串（域级优先 → root 兜底；空串 = 缺席）。
+ *  layer：域级声明 → 'module'；root 兜底 → 'app'；双缺 → null（ProviderBinding 双缺诚实态）。 */
+export function resolveDomainBinding(
+  config: Record<string, unknown> | null,
+  domainKey: string,
+): { provider: string | null; layer: 'module' | 'app' | null } {
+  const domainProvider = (config?.domains as Record<string, { provider?: unknown }> | undefined)?.[domainKey]?.provider;
+  if (typeof domainProvider === 'string' && domainProvider.length > 0) {
+    return { provider: domainProvider, layer: 'module' };
+  }
+  const rootProvider = config?.provider;
+  if (typeof rootProvider === 'string' && rootProvider.length > 0) {
+    return { provider: rootProvider, layer: 'app' };
+  }
+  return { provider: null, layer: null };
+}
+
+/** 多域模块可写性（D34 判别联合——configEditable 读标志与 applyModule 写守卫共用单源） */
+export type ModuleDomainWritability =
+  | { writable: true; domainKeys: [string]; domainKey: string }
+  | { writable: false; reason: 'zero-domain'; domainKeys: [] }
+  | { writable: false; reason: 'multi-domain'; domainKeys: string[] }
+  | { writable: false; reason: 'shared-key'; domainKeys: [string]; domainKey: string; coOwners: string[] };
+
+/**
+ * 多域模块可写性判定（v4.4 F3）：domainKeys = demand 服务首段去重；
+ * shared-key 判据 = 域级 owner 并集计数（catalog.services 聚合含 dev-manifest 通道需求——
+ * P13 真源；>1 个 distinct owner ⟺ 共享。免 owner↔moduleId 身份映射——本地模块 catalog
+ * owner = entry.package ≠ mod.pkg `@app/<id>`，身份比较必踩；「他方与本模块需求同一服务」
+ * 形态亦被并集计数天然覆盖）。
+ */
+export function moduleDomainWritable(
+  walk: Pick<WalkManifestsResult, 'modules' | 'catalog'>,
+  mod: WalkModuleInfo,
+): ModuleDomainWritability {
+  const domainKeys = [...new Set((mod.descriptor.contributes.services ?? []).map((s) => domainOfService(s.service)))].sort();
+  if (domainKeys.length === 0) return { writable: false, reason: 'zero-domain', domainKeys: [] };
+  if (domainKeys.length > 1) return { writable: false, reason: 'multi-domain', domainKeys };
+  const domainKey = domainKeys[0];
+  const owners = new Set<string>();
+  for (const [service, demand] of Object.entries(walk.catalog.services)) {
+    if (domainOfService(service) === domainKey) for (const o of demand.owners) owners.add(o);
+  }
+  if (owners.size > 1) {
+    return { writable: false, reason: 'shared-key', domainKeys: [domainKey], domainKey, coOwners: [...owners].sort() };
+  }
+  return { writable: true, domainKeys: [domainKey], domainKey };
+}
+
+/** owner 串 → 显示名（尽力映射 module install id；未命中回退原始串——message 质量问题非正确性） */
+export function displayOwnerName(modules: ReadonlyArray<{ id: string; pkg: string }>, owner: string): string {
+  const mod = modules.find((m) => m.pkg === owner || `@app/${m.id}` === owner);
+  if (mod) return mod.id;
+  return owner.startsWith('@app/') ? owner.slice('@app/'.length) : owner;
+}
+
+/** 供给足迹（该厂商全部供给服务并集——应用级 integrationSchemas 作用域，D32） */
+export function providerFootprint(catalog: WalkCatalog, provider: string): string[] {
+  return [...new Set(Object.values(catalog.providers[provider] ?? {}).flatMap((e) => e.services))].sort();
+}

package/src/integrations/predicate.ts

@@ -60,6 +60,7 @@
  *     → warning（moduleResourceNeeds 缺席 → 需求面检查跳过，M3 降级先例）
  */
 import type { EvaluationExports } from '../core/contracts-expected.js';
+import { resolveDomainBinding } from './domain-binding.js';
 
 /** contracts 注入面（resolver 装配产物运行时视图 = EvaluationExports 求值子集） */
 export type PredicateContracts = Pick<
@@ -480,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;
@@ -513,13 +515,12 @@ export function evaluateIntegrationServices(
       };
       checkLayer(integrations.config, 'root.config');
       for (const [k, v] of Object.entries(integrations.configByInstance ?? {})) checkLayer(v, `root.configByInstance[${k}]`);
-      // 域级 config：键 ⊆ 该域生效厂商（domains[d].provider ?? root.provider）schema——
-      // 生效厂商缺席（全走槽级覆盖）→ 用全局并集；生效厂商 schema 缺失 → 跳过该域
+      // 域级 config：键 ⊆ 该域生效厂商 schema（resolveDomainBinding 单源——v4.4 F1 等价重构，
+      // 语义 ≡ 现状 domains[d].provider ?? root.provider）——生效厂商缺席（全走槽级覆盖）→
+      // 用全局并集；生效厂商 schema 缺失 → 跳过该域
       for (const [d, cfg] of Object.entries(integrations.domains ?? {})) {
         if (!cfg?.config) continue;
-        const domainVendor = typeof cfg.provider === 'string' && cfg.provider
-          ? cfg.provider
-          : (typeof integrations.provider === 'string' ? integrations.provider : undefined);
+        const domainVendor = resolveDomainBinding(integrations, d).provider ?? undefined;
         if (domainVendor === undefined) {
           checkLayer(cfg.config, `domains.${d}.config`);
           continue;