@tbox.cn/app-toolkit 0.1.0

package/src/views/providers.ts

@@ -0,0 +1,165 @@
+import type { ProviderDetail, ProviderEntry, ProviderServiceDetail, ProvidersView } from '../dto.js';
+import { AppToolkitError } from '../core/errors.js';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { walkManifests } from '../assembly/walk-manifests.js';
+import type { ViewSnapshot } from './context.js';
+
+/**
+ * 供给轴投影（views/providers；C4）。供给关系三切片（P5）：
+ * 名单 = /providers（基本信息）· 足迹 = /providers/:p（implementations[] 保真）·
+ * 表单 = /providers/:p/services/:s（组合单体——schema 唯一暴露面 P10）。
+ * 静态端点零求值（铁律 #3）。
+ */
+
+/** GET /providers：厂商基本信息（供给足迹不在本端点 → /providers/:p） */
+export function loadProvidersView(snapshot: ViewSnapshot): ProvidersView {
+  const providers: ProviderEntry[] = [];
+  for (const [provider, impls] of Object.entries(snapshot.catalog.providers)) {
+    const entries = Object.values(impls);
+    if (entries.length === 0) continue;
+    providers.push({
+      provider,
+      local: entries.every((e) => e.local === true),
+      owner: entries[0].owner,
+    });
+  }
+  return { providers: providers.sort((a, b) => a.provider.localeCompare(b.provider)) };
+}
+
+/** GET /providers/:provider：供给足迹（implementations 恒数组——H1 多实现钉版数据源） */
+export function loadProviderDetailView(snapshot: ViewSnapshot, provider: string): ProviderDetail {
+  const impls = snapshot.catalog.providers[provider];
+  if (!impls) {
+    throw new AppToolkitError('PROVIDER_NOT_FOUND', 404, `厂商 ${provider} 不 ∈ catalog（内联声明厂商无包级档案——身份与表单经组合端点暴露）`);
+  }
+  const services: ProviderDetail['services'] = {};
+  for (const entry of Object.values(impls)) {
+    for (const service of entry.services) {
+      const bucket = (services[service] ??= { implementations: [] });
+      bucket.implementations.push({ implementation: entry.implementation, credentialType: entry.credentialType });
+    }
+  }
+  const entries = Object.values(impls);
+  return {
+    provider,
+    local: entries.every((e) => e.local === true),
+    owner: entries[0].owner,
+    services,
+  };
+}
+
+/** 组合单体（GET /providers/:p/services/:s）：catalog 供给与槽级内联声明统一解析（P10/P11） */
+export function loadProviderServiceDetailView(
+  snapshot: ViewSnapshot,
+  provider: string,
+  service: string,
+): ProviderServiceDetail {
+  const impls = snapshot.catalog.providers[provider];
+  const configured = (snapshot.integrations as {
+    services?: Record<string, { provider?: unknown; implementation?: string }>;
+  } | null)?.services ?? {};
+
+  // 供给解析（P11 判据 = 供给存在）：catalog 槽供给 → implementations[] 数组装配（声明序）
+  const implementations: Array<{ implementation: string; credentialType: string }> = [];
+  if (impls) {
+    for (const entry of Object.values(impls)) {
+      if (entry.services.includes(service)) {
+        implementations.push({ implementation: entry.implementation, credentialType: entry.credentialType });
+      }
+    }
+  }
+
+  // 内联声明（该 provider 名——catalog 外或补充）：单元素（声明对）
+  const inline = configured[service]?.provider;
+  const inlineDeclaration =
+    inline && typeof inline === 'object' && (inline as { provider?: string }).provider === provider
+      ? (inline as { credentialType: string; provider: string })
+      : undefined;
+
+  if (implementations.length === 0 && !inlineDeclaration) {
+    if (!impls) {
+      throw new AppToolkitError('PROVIDER_NOT_FOUND', 404, `厂商 ${provider} 完全未知（不 ∈ catalog 且无任何内联声明）`);
+    }
+    throw new AppToolkitError('SUPPLY_NOT_FOUND', 404, `厂商 ${provider} 未供给服务 ${service}（AI 帮我实现流：PUT 显式绑定后实施）`);
+  }
+  if (implementations.length === 0 && inlineDeclaration) {
+    implementations.push({ implementation: configured[service]?.implementation ?? `${provider}-inline@1`, credentialType: inlineDeclaration.credentialType });
+  }
+
+  // integrationSchemas：catalog schema（复合键）优先；内联声明 configSchema 引用应用 config/schemas/
+  // （路径约束 H9——resolve 落 config/schemas/ 内 + realpath 复核，违例 400）
+  let configSchema: object | null = null;
+  let credentialSchema: object | null = null;
+  const schemaEntry = walkManifests(snapshot.appDir).serviceSchemas[`${provider}\u0000${service}`];
+  if (schemaEntry) {
+    configSchema = readSchemaRef(snapshot.appDir, schemaEntry.packageDir, schemaEntry.configSchema);
+    credentialSchema = readSchemaRef(snapshot.appDir, schemaEntry.packageDir, schemaEntry.credentialSchema);
+  } else if (inlineDeclaration) {
+    // 内联声明 schema 解析：引用文件在 integrations 节点（provider.configSchema）——
+    // 形状同 config/schemas/ 约束（路径来源 = 节点声明，由服务端读应用侧）
+    const inlineSchemaRef = (inline as { configSchema?: string } | undefined)?.configSchema;
+    if (typeof inlineSchemaRef === 'string') {
+      configSchema = readInlineSchema(snapshot.appDir, inlineSchemaRef);
+    }
+  }
+
+  return {
+    provider,
+    service,
+    implementations,
+    integrationSchemas: { configSchema, credentialSchema },
+  };
+}
+
+/** catalog schema 引用读取（相对包根；缺席 → null——SCHEMA_FILE_MISSING 归谓词 #6） */
+function readSchemaRef(_appDir: string, packageDir: string, ref: string | undefined): object | null {
+  if (!ref) return null;
+  const file = join(packageDir, ref);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, 'utf8')) as object;
+  } catch {
+    return null;
+  }
+}
+
+/** 内联声明 configSchema 读取（H9 安全钉子，FX-2a 修：分隔符级边界 + realpath 复核）：
+ *  ①lexical：path.relative 判定必须落在 <appDir>/config/schemas/ 内（禁 `..` 逃逸/绝对路径/
+ *  同前缀兄弟目录 `config/schemas-evil`——原 startsWith 无分隔符边界被绕过）；
+ *  ②physical：realpathSync 复核（symlink 逃逸——防「凭据 JSON 被当 schema 回显」任意文件读原语）。 */
+function readInlineSchema(appDir: string, ref: string): object | null {
+  const schemasRoot = resolve(appDir, 'config', 'schemas');
+  const target = resolve(appDir, ref);
+  const rel = relative(schemasRoot, target);
+  if (rel === '' || rel.startsWith('..') || isAbsolute(rel)) {
+    throw new AppToolkitError(
+      'VALIDATION_FAILED',
+      400,
+      'configSchema 引用必须落在 config/schemas/ 内（禁路径逃逸）',
+      ['provider.configSchema'],
+    );
+  }
+  if (!existsSync(target)) return null;
+  let realRoot: string;
+  let realTarget: string;
+  try {
+    realRoot = realpathSync(schemasRoot);
+    realTarget = realpathSync(target);
+  } catch {
+    return null;
+  }
+  if (realTarget !== realRoot && !realTarget.startsWith(realRoot + sep)) {
+    throw new AppToolkitError(
+      'VALIDATION_FAILED',
+      400,
+      'configSchema 引用经 symlink 逃逸出 config/schemas/（realpath 复核拒绝）',
+      ['provider.configSchema'],
+    );
+  }
+  try {
+    return JSON.parse(readFileSync(target, 'utf8')) as object;
+  } catch {
+    return null;
+  }
+}

package/src/views/service-detail.ts

@@ -0,0 +1,32 @@
+import type { ServiceDetail } from '../dto.js';
+import { AppToolkitError } from '../core/errors.js';
+import { suppliedByVendors, type ViewSnapshot } from './context.js';
+
+/**
+ * 服务静态单体投影（views/service-detail；C4）。求值数据不在此（→ /service-resolutions/:service）。
+ * SERVICE_NOT_FOUND 判据 = 服务词汇 ∪ 已配置（P9——词汇成员零 demand/供给/config 仍 200）。
+ */
+
+export function loadServiceDetailView(snapshot: ViewSnapshot, service: string): ServiceDetail {
+  const configured = (snapshot.integrations as { services?: Record<string, unknown> } | null)?.services ?? {};
+  const demand = snapshot.catalog.services[service];
+  const inVocabulary = snapshot.walk.vocabulary.includes(service);
+  const isConfigured = service in configured;
+  // 404 判据与 /service-resolutions/:service 单源（P9）
+  if (!inVocabulary && !isConfigured) {
+    throw new AppToolkitError('SERVICE_NOT_FOUND', 404, `服务 ${service} 不在服务词汇（已装契约包 ∪ 已配置）`);
+  }
+  // integration = 文件 services[s] 逐字原值（编辑预填源 D21）；无声明 = null
+  const integration = (configured[service] as ServiceDetail['integration'] | undefined) ?? null;
+  return {
+    service,
+    ...(demand?.title ? { title: demand.title } : { title: service }),
+    ...(demand?.description ? { description: demand.description } : {}),
+    required: demand ? !demand.optional : false,
+    // defaults 唯一落位（manifest 预填）
+    defaults: demand ? demand.defaults.map((d) => ({ ...d })) : [],
+    integration,
+    // picker 数据源：供给该服务的厂商名单（catalog 静态切片）
+    suppliedBy: suppliedByVendors(snapshot.catalog, service),
+  };
+}

package/src/views/service-resolutions.ts

@@ -0,0 +1,323 @@
+import type {
+  BindingLayer,
+  ContractsResolution,
+  CredentialEcho,
+  EffectiveBinding,
+  IntegrationIssue,
+  ResolvedInstance,
+  ServiceResolution,
+  ServiceResolutionEntry,
+  ServiceResolutionsView,
+  ServiceResolutionDetail,
+  ServiceStatus,
+} from '../dto.js';
+import { maskCredentialValues, readCredentialFile, stemToFilePath } from '../core/credential-format.js';
+import type { ResolvedContracts } from '../core/contracts-resolver.js';
+import type { WalkCatalog } from '../assembly/walk-manifests.js';
+import { domainOfService, isSupplied, type ViewSnapshot } from './context.js';
+
+/**
+ * 求值轴投影（views/service-resolutions；C4；FX-2c——B6 effective/credential 填充 + F2 layer 推导）。
+ *
+ * status(service, instanceId) = contracts.resolveEffectiveService(integrations, service, instanceId,
+ * supplies).status——动态（应用自身 contracts 求值单源）。
+ * 默认实例 = 应用自身 normalizeInstances 委托（显式 defaultInstanceId ?? 单候选唯一解；
+ * null → '*' 通配口径求值——显式键集无通配 → instance-not-found 如实暴露；不自造 instances[0]）。
+ * required(service) = 任一需求方 required（OR 聚合——demandedServices.optional AND 合并的补语义；
+ * 平台/孤儿恒 false）——集成就绪判定单源：pending = Σ (required && status !== 'ok')。
+ * **P14 单一形状（结构保证）**：resolveServiceSummary() 单源函数——/service-resolutions map 值 ≡
+ * /service-resolutions/:s 的 resolution 摘要基（ServiceResolution extends ServiceResolutionEntry）。
+ * **实例条目**：effective（合并绑定投影 + layer 推导——contracts EffectiveService 无 layer，F2）
+ * + credential（掩码回显——GET 永无真值；文件缺席省略，缺失归谓词 #1）。
+ */
+
+function toContractsResolution(contracts: ResolvedContracts): ContractsResolution {
+  return {
+    version: contracts.version,
+    evaluation: contracts.evaluation,
+    strictValidation: contracts.strictValidation,
+    notes: [...contracts.notes],
+  };
+}
+
+/** 实例求值产物（摘要消费 status/provider；单体消费 effective） */
+interface InstanceEvaluation {
+  status: ServiceStatus;
+  statusMessage?: string;
+  provider?: string;
+  implementation?: string;
+  effective?: EffectiveBinding;
+}
+
+/** 最特异声明层推导（F2）：inst 位 provider 在场 → 'instance'；槽级 → 'service'；域级 → 'module'；
+ *  root → 'app'。实例位查找复刻 TIER0 语义（精确键优先、'*' 通配兜底——与 resolveEffectiveService
+ *  的 instances 查找层同轴）。 */
+function deriveBindingLayer(snapshot: ViewSnapshot, service: string, instanceId: string): BindingLayer {
+  const integrations = snapshot.integrations as {
+    provider?: unknown;
+    domains?: Record<string, { provider?: unknown }>;
+    services?: Record<string, { provider?: unknown; instances?: Record<string, { provider?: unknown }> }>;
+  } | null;
+  const domain = domainOfService(service);
+  const slot = integrations?.services?.[service];
+  const inst = slot?.instances?.[instanceId] ?? slot?.instances?.['*'];
+  if (inst && inst.provider !== undefined) return 'instance';
+  if (slot?.provider !== undefined) return 'service';
+  if (integrations?.domains?.[domain]?.provider !== undefined) return 'module';
+  return 'app';
+}
+
+/** 凭据掩码回显（O4：GET 永无真值——maskCredentialValues 单源；文件缺席省略） */
+function echoForRef(appDir: string, ref: string | undefined): CredentialEcho | undefined {
+  if (ref === undefined || !ref.startsWith('secret://')) return undefined;
+  const stem = ref.slice('secret://'.length);
+  const file = readCredentialFile(appDir, stem);
+  if (!file) return undefined;
+  return { type: file.type, ref, file: stemToFilePath(stem), masked: maskCredentialValues(file.values) };
+}
+
+/** 求值单实例（resolveEffectiveService 动态求值；ok 态携带完整 effective——layer 推导附） */
+function evaluateInstance(
+  snapshot: ViewSnapshot,
+  contracts: NonNullable<ReturnType<typeof evaluationContracts>>,
+  service: string,
+  instanceId: string,
+  supplies: unknown,
+): InstanceEvaluation {
+  const r = contracts.resolveEffectiveService(
+    snapshot.integrations as never,
+    service,
+    instanceId,
+    supplies as never,
+  );
+  if (r.status === 'ok' && r.effective) {
+    const raw: unknown = r.effective.provider;
+    const provider = typeof raw === 'string' ? raw : String((raw as { provider?: string } | null)?.provider ?? '');
+    return {
+      status: 'ok',
+      provider,
+      implementation: r.effective.implementation,
+      effective: {
+        provider,
+        implementation: r.effective.implementation,
+        ...(r.effective.config !== undefined ? { config: { ...(r.effective.config as Record<string, unknown>) } } : {}),
+        ...(r.effective.credentialRef !== undefined ? { credentialRef: r.effective.credentialRef } : {}),
+        layer: deriveBindingLayer(snapshot, service, instanceId),
+      },
+    };
+  }
+  if (r.status === 'binding-unresolved') return { status: 'binding-unresolved', statusMessage: r.message };
+  return { status: r.status };
+}
+
+/** 应用自身 contracts（快照.contracts.module 的求值子集——门控保证在场才调用） */
+function evaluationContracts(snapshot: ViewSnapshot) {
+  const mod = snapshot.contracts.module as {
+    resolveEffectiveService?: (...args: never[]) => EffectiveResolutionShape;
+    normalizeInstances?: (input: unknown) => { instances: Array<{ id: string }>; defaultInstanceId: string | null };
+    buildSupplyLookup?: (catalog: unknown) => unknown;
+  };
+  // 门控（工厂边缘）保证 evaluation/strictValidation 后此断言恒真
+  if (!mod.resolveEffectiveService || !mod.normalizeInstances) {
+    throw new Error('contracts 求值面缺席（工厂门控应先行拦截）');
+  }
+  return mod as unknown as {
+    resolveEffectiveService: (
+      integrations: never,
+      service: string,
+      instanceId: string,
+      supplies?: never,
+    ) => EffectiveResolutionShape;
+    normalizeInstances: (input: unknown) => { instances: Array<{ id: string }>; defaultInstanceId: string | null };
+    buildSupplyLookup: (catalog: unknown) => unknown;
+  };
+}
+
+/** contracts EffectiveServiceResolution 消费面形状（effective 五字段——FX-2c 全集透传） */
+interface EffectiveResolutionShape {
+  status: ServiceStatus;
+  effective?: {
+    provider: unknown;
+    implementation: string;
+    config?: Readonly<Record<string, unknown>>;
+    credentialRef?: string;
+  };
+  message?: string;
+}
+
+/** P14 单源摘要函数：/service-resolutions map 值 ≡ /service-resolutions/:s 的 resolution 摘要基 */
+export function resolveServiceSummary(
+  service: string,
+  snapshot: ViewSnapshot,
+): ServiceResolutionEntry {
+  const contracts = evaluationContracts(snapshot);
+  const { integrations, catalog } = snapshot;
+
+  // 供给查表（buildSupplyLookup 动态派生——应用自身 contracts）
+  const supplies = contracts.buildSupplyLookup(catalog as never);
+
+  // 默认实例 = 应用自身 normalizeInstances 委托（null → '*' 通配口径）
+  const cfg = integrations as { instances?: unknown; defaultInstanceId?: unknown } | null;
+  const normalized = contracts.normalizeInstances({
+    instances: cfg?.instances,
+    defaultInstanceId: cfg?.defaultInstanceId,
+  });
+  const defaultInstanceId = normalized.defaultInstanceId ?? '*';
+
+  // 跨实例求值异常聚合（statusMessage 直投）
+  const evaluation = evaluateInstance(snapshot, contracts, service, defaultInstanceId, supplies);
+
+  // provider：effective 求值厂商（最特异声明层——跨层事实）；缺席 = 未配置/未解析
+  const declaredProvider = (snapshot.integrations as { services?: Record<string, { provider?: unknown }> } | null)
+    ?.services?.[service]?.provider;
+  const provider =
+    evaluation.provider ??
+    (typeof declaredProvider === 'string' ? declaredProvider : typeof declaredProvider === 'object' && declaredProvider ? String((declaredProvider as { provider?: string }).provider) : undefined);
+
+  // supplied 点查：provider ∈ 厂商集合时在场（true 供给 / false 显式绑定未供给——「AI 实施中」）；
+  // provider ∉（自定义 API）或缺席时缺席
+  const knownVendors = new Set(Object.keys(snapshot.catalog.providers));
+  const supplied =
+    provider !== undefined && knownVendors.has(provider)
+      ? isSuppliedCheck(snapshot.catalog, provider, service)
+      : undefined;
+
+  // required echo（OR 聚合——demand 单源随求值轴；平台/孤儿恒 false）
+  const demand = catalog.services[service];
+  const required = demand !== undefined ? !demand.optional : undefined;
+
+  // module = owner 模块（demand owners 首）；平台/孤儿缺席
+  const module = demand?.owners[0];
+
+  return {
+    status: evaluation.status,
+    ...(evaluation.statusMessage ? { statusMessage: evaluation.statusMessage } : {}),
+    ...(provider !== undefined ? { provider } : {}),
+    ...(supplied !== undefined ? { supplied } : {}),
+    ...(module !== undefined ? { module } : {}),
+    ...(required !== undefined ? { required } : {}),
+  };
+}
+
+function isSuppliedCheck(catalog: WalkCatalog, provider: string, service: string): boolean {
+  return isSupplied(catalog, provider, service);
+}
+
+/** 批量求值（键集 = 服务词汇 ∪ 已配置；?service= 过滤语义——未知键缺席；issues 恒全量） */
+export function loadServiceResolutionsView(
+  snapshot: ViewSnapshot,
+  issues: IntegrationIssue[],
+  filter?: string[],
+): ServiceResolutionsView {
+  const keys = new Set<string>([...snapshot.walk.vocabulary, ...Object.keys(snapshot.catalog.services)]);
+  const configured = (snapshot.integrations as { services?: Record<string, unknown> } | null)?.services ?? {};
+  for (const k of Object.keys(configured)) keys.add(k);
+
+  const resolutions: Record<string, ServiceResolutionEntry> = {};
+  for (const service of [...keys].sort()) {
+    if (filter && !filter.includes(service)) continue;
+    resolutions[service] = resolveServiceSummary(service, snapshot);
+  }
+  return { contracts: toContractsResolution(snapshot.contracts), resolutions, issues };
+}
+
+/** 求值单体（完整结构 instances + inheritance + 过滤 issues；P14 extends 结构保证） */
+export function loadServiceResolutionDetail(
+  service: string,
+  snapshot: ViewSnapshot,
+  allIssues: IntegrationIssue[],
+): ServiceResolutionDetail {
+  const contracts = evaluationContracts(snapshot);
+  const supplies = contracts.buildSupplyLookup(snapshot.catalog as never);
+  const cfg = snapshot.integrations as { instances?: unknown; defaultInstanceId?: unknown } | null;
+  const normalized = contracts.normalizeInstances({
+    instances: cfg?.instances,
+    defaultInstanceId: cfg?.defaultInstanceId,
+  });
+
+  // P4 枚举规则：root 注册表 id 逐一 + 显式 '*' 条目（若在）；无注册表且节点通配激活 → 单 '*' 合成；
+  // 无注册表无节点 → []
+  const declaredIds = normalized.instances.map((i) => i.id);
+  const slot = (snapshot.integrations as { services?: Record<string, { instances?: Record<string, unknown> }> } | null)
+    ?.services?.[service];
+  const slotKeys = slot?.instances ? Object.keys(slot.instances) : undefined;
+  let instanceIds: string[];
+  if (declaredIds.length > 0) {
+    instanceIds = [...declaredIds];
+    if (slotKeys?.includes('*')) instanceIds.push('*');
+  } else if (slotKeys !== undefined && slotKeys.length > 0) {
+    instanceIds = slotKeys.includes('*') ? ['*'] : slotKeys;
+  } else {
+    instanceIds = [];
+  }
+
+  // 默认实例口径（摘要 status = 默认实例求值——不重复头部；原 defaultEval 死代码已删 FX-2c）
+
+  const instances: ResolvedInstance[] = instanceIds.map((id) => {
+    const evalResult = evaluateInstance(snapshot, contracts, service, id, supplies);
+    const echo = echoForRef(snapshot.appDir, evalResult.effective?.credentialRef);
+    return {
+      instanceId: id,
+      status: evalResult.status,
+      ...(evalResult.statusMessage ? { statusMessage: evalResult.statusMessage } : {}),
+      ...(evalResult.effective ? { effective: evalResult.effective } : {}),
+      ...(echo ? { credential: echo } : {}),
+    };
+  });
+
+  // inheritance 四层（app → module → service → instance——effective 链声明位投影）
+  const inheritance = buildInheritance(snapshot, service);
+
+  const summary = resolveServiceSummary(service, snapshot);
+  const resolution: ServiceResolution = {
+    ...summary,
+    instances,
+    inheritance,
+  };
+
+  return {
+    contracts: toContractsResolution(snapshot.contracts),
+    resolution,
+    issues: allIssues.filter((i) => i.service === service),
+  };
+}
+
+/** inheritance 投影：四层各取该层声明 provider/implementation（缺席层 = 继承位，provider 缺席）。
+ *  实例层 = **默认实例口径**（FX-2c 修——与摘要 status 同轴：normalizeInstances 委托解析
+ *  defaultInstanceId ?? '*'；原实现取 Object.keys[0] 任意实例）。 */
+function buildInheritance(
+  snapshot: ViewSnapshot,
+  service: string,
+): ServiceResolution['inheritance'] {
+  const integrations = snapshot.integrations as {
+    provider?: string;
+    domains?: Record<string, { provider?: string }>;
+    services?: Record<string, { provider?: unknown; implementation?: string; instances?: Record<string, { provider?: string; implementation?: string }> }>;
+  } | null;
+  const domain = domainOfService(service);
+  const slot = integrations?.services?.[service];
+  const cfg = snapshot.integrations as { instances?: unknown; defaultInstanceId?: unknown } | null;
+  const normalized = evaluationContracts(snapshot).normalizeInstances({
+    instances: cfg?.instances,
+    defaultInstanceId: cfg?.defaultInstanceId,
+  });
+  const defaultInstanceId = normalized.defaultInstanceId ?? '*';
+  const defaultInstance = slot?.instances?.[defaultInstanceId] ?? slot?.instances?.['*'];
+  return [
+    { layer: 'app' as const, ...(integrations?.provider ? { provider: integrations.provider } : {}) },
+    { layer: 'module' as const, ...(integrations?.domains?.[domain]?.provider ? { provider: integrations.domains[domain].provider } : {}) },
+    {
+      layer: 'service' as const,
+      ...(typeof slot?.provider === 'string' ? { provider: slot.provider } : {}),
+      ...(slot?.implementation ? { implementation: slot.implementation } : {}),
+    },
+    {
+      layer: 'instance' as const,
+      ...(defaultInstance?.provider ? { provider: defaultInstance.provider } : {}),
+      ...(defaultInstance?.implementation ? { implementation: defaultInstance.implementation } : {}),
+    },
+  ];
+}
+
+/** 谓词全量 issues 装配（写路径/求值轴共用——工厂经 evaluateIntegrationServices 装配后传入） */
+export type { IntegrationIssue };