@tbox.cn/app-toolkit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1909 @@
+import { z } from 'zod';
+
+/**
+ * tbox.module.json schema v1（001 §3.6 字段名，003 §4.1 schema v1 定版）。
+ * app-toolkit 单一校验源（自 CLI module-schema.ts 迁入；CLI 经 re-export 消费）。
+ *
+ * 迁移改造（ai-build C2-5）：
+ * - resourceNeedContribSchema 的 type 由 `z.enum(RESOURCE_TYPE_IDS)` 放宽为 `z.string()`——
+ *   词汇校验移谓词、经 contracts 动态解析取 RESOURCE_TYPE_IDS（比静态 enum 更忠实应用版本）；
+ * - demand meta additive：serviceNeedContribSchema 增 title?/description?（服务展示元数据，
+ *   manifest demand 侧 additive 扩展，catalog 聚合顺带携带——api.md ServiceDemand 对齐）；
+ * - 安全钉子（H9b）：provider 名与 instance id 进凭据 stem 派生，字符集 pattern
+ *   `/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/` 为第一道防线（stem 派生处另有断言防线——纵深防御）。
+ */
+/** 输入字符集（安全钉子①）：provider 名 / instanceId 恒经此 pattern（进凭据 stem 派生的输入） */
+declare const SAFE_NAME_PATTERN: RegExp;
+declare const cardContribSchema: z.ZodObject<{
+    cardType: z.ZodString;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    cardType: string;
+    schemaVersion?: number | undefined;
+}, {
+    cardType: string;
+    schemaVersion?: number | undefined;
+}>;
+declare const pageContribSchema: z.ZodObject<{
+    route: z.ZodString;
+    component: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    route: string;
+    component: string;
+}, {
+    route: string;
+    component: string;
+}>;
+declare const tabContribSchema: z.ZodObject<{
+    route: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    route: string;
+    label?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+}, {
+    route: string;
+    label?: string | undefined;
+    icon?: string | undefined;
+    order?: number | undefined;
+}>;
+declare const moduleDependencySchema: z.ZodObject<{
+    id: z.ZodString;
+    range: z.ZodOptional<z.ZodString>;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    required: boolean;
+    range?: string | undefined;
+}, {
+    id: string;
+    range?: string | undefined;
+    required?: boolean | undefined;
+}>;
+/** provider 供给槽声明（integrations v2：contributes.providers.slots 元素；
+ *  provider = 厂商名（catalog 嵌套第一轴）、implementation = 'id@version'（第二轴）） */
+declare const providerSlotContribSchema: z.ZodObject<{
+    service: z.ZodString;
+    provider: z.ZodString;
+    implementation: z.ZodString;
+    credentialType: z.ZodString;
+    local: z.ZodOptional<z.ZodBoolean>;
+    configSchema: z.ZodOptional<z.ZodString>;
+    credentialSchema: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    service: string;
+    provider: string;
+    implementation: string;
+    credentialType: string;
+    local?: boolean | undefined;
+    configSchema?: string | undefined;
+    credentialSchema?: string | undefined;
+}, {
+    service: string;
+    provider: string;
+    implementation: string;
+    credentialType: string;
+    local?: boolean | undefined;
+    configSchema?: string | undefined;
+    credentialSchema?: string | undefined;
+}>;
+/** 服务需求槽声明（contributes.services 元素；业务模块声明消费——catalog 需求侧聚合源） */
+declare const serviceNeedContribSchema: z.ZodObject<{
+    service: z.ZodString;
+    optional: z.ZodDefault<z.ZodBoolean>;
+    defaults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        provider: z.ZodString;
+        implementation: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        implementation: string;
+    }, {
+        provider: string;
+        implementation: string;
+    }>, "many">>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    service: string;
+    optional: boolean;
+    defaults: {
+        provider: string;
+        implementation: string;
+    }[];
+    title?: string | undefined;
+    description?: string | undefined;
+}, {
+    service: string;
+    optional?: boolean | undefined;
+    defaults?: {
+        provider: string;
+        implementation: string;
+    }[] | undefined;
+    title?: string | undefined;
+    description?: string | undefined;
+}>;
+/** 资源需求声明（contributes.resources 元素；type 放宽为 string——词汇校验移谓词经 resolver 取词表） */
+declare const resourceNeedContribSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    id: string;
+}, {
+    type: string;
+    id: string;
+}>;
+declare const moduleDescriptorSchema: z.ZodObject<{
+    schemaVersion: z.ZodDefault<z.ZodNumber>;
+    name: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    kind: z.ZodDefault<z.ZodEnum<["platform", "business", "third-party"]>>;
+    risk: z.ZodDefault<z.ZodObject<{
+        level: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
+        writeBoundary: z.ZodDefault<z.ZodEnum<["sdk-enforced", "source"]>>;
+    }, "strip", z.ZodTypeAny, {
+        level: "high" | "medium" | "low";
+        writeBoundary: "sdk-enforced" | "source";
+    }, {
+        level?: "high" | "medium" | "low" | undefined;
+        writeBoundary?: "sdk-enforced" | "source" | undefined;
+    }>>;
+    distribution: z.ZodDefault<z.ZodObject<{
+        defaultMode: z.ZodDefault<z.ZodEnum<["hybrid", "sdk", "codegen", "local"]>>;
+    }, "strip", z.ZodTypeAny, {
+        defaultMode: "local" | "hybrid" | "sdk" | "codegen";
+    }, {
+        defaultMode?: "local" | "hybrid" | "sdk" | "codegen" | undefined;
+    }>>;
+    contributes: z.ZodDefault<z.ZodObject<{
+        handlers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        tools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        cards: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            cardType: z.ZodString;
+            schemaVersion: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            cardType: string;
+            schemaVersion?: number | undefined;
+        }, {
+            cardType: string;
+            schemaVersion?: number | undefined;
+        }>, "many">>;
+        routes: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            route: z.ZodString;
+            component: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            route: string;
+            component: string;
+        }, {
+            route: string;
+            component: string;
+        }>, "many">>;
+        tabs: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            route: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            icon: z.ZodOptional<z.ZodString>;
+            order: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            route: string;
+            label?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+        }, {
+            route: string;
+            label?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+        }>, "many">>;
+        providers: z.ZodDefault<z.ZodObject<{
+            slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                service: z.ZodString;
+                provider: z.ZodString;
+                implementation: z.ZodString;
+                credentialType: z.ZodString;
+                local: z.ZodOptional<z.ZodBoolean>;
+                configSchema: z.ZodOptional<z.ZodString>;
+                credentialSchema: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }, {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            slots: {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }[];
+        }, {
+            slots?: {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }[] | undefined;
+        }>>;
+        services: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            service: z.ZodString;
+            optional: z.ZodDefault<z.ZodBoolean>;
+            defaults: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                implementation: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                provider: string;
+                implementation: string;
+            }, {
+                provider: string;
+                implementation: string;
+            }>, "many">>;
+            title: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            service: string;
+            optional: boolean;
+            defaults: {
+                provider: string;
+                implementation: string;
+            }[];
+            title?: string | undefined;
+            description?: string | undefined;
+        }, {
+            service: string;
+            optional?: boolean | undefined;
+            defaults?: {
+                provider: string;
+                implementation: string;
+            }[] | undefined;
+            title?: string | undefined;
+            description?: string | undefined;
+        }>, "many">>;
+        resources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            id: string;
+        }, {
+            type: string;
+            id: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        handlers: string[];
+        tools: string[];
+        cards: {
+            cardType: string;
+            schemaVersion?: number | undefined;
+        }[];
+        routes: string[];
+        pages: {
+            route: string;
+            component: string;
+        }[];
+        tabs: {
+            route: string;
+            label?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+        }[];
+        providers: {
+            slots: {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }[];
+        };
+        services: {
+            service: string;
+            optional: boolean;
+            defaults: {
+                provider: string;
+                implementation: string;
+            }[];
+            title?: string | undefined;
+            description?: string | undefined;
+        }[];
+        resources: {
+            type: string;
+            id: string;
+        }[];
+    }, {
+        handlers?: string[] | undefined;
+        tools?: string[] | undefined;
+        cards?: {
+            cardType: string;
+            schemaVersion?: number | undefined;
+        }[] | undefined;
+        routes?: string[] | undefined;
+        pages?: {
+            route: string;
+            component: string;
+        }[] | undefined;
+        tabs?: {
+            route: string;
+            label?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+        }[] | undefined;
+        providers?: {
+            slots?: {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        services?: {
+            service: string;
+            optional?: boolean | undefined;
+            defaults?: {
+                provider: string;
+                implementation: string;
+            }[] | undefined;
+            title?: string | undefined;
+            description?: string | undefined;
+        }[] | undefined;
+        resources?: {
+            type: string;
+            id: string;
+        }[] | undefined;
+    }>>;
+    dependencies: z.ZodDefault<z.ZodObject<{
+        modules: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            range: z.ZodOptional<z.ZodString>;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            required: boolean;
+            range?: string | undefined;
+        }, {
+            id: string;
+            range?: string | undefined;
+            required?: boolean | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        modules: {
+            id: string;
+            required: boolean;
+            range?: string | undefined;
+        }[];
+    }, {
+        modules?: {
+            id: string;
+            range?: string | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
+    }>>;
+    env: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    schemaVersion: number;
+    name: string;
+    version: string;
+    kind: "platform" | "business" | "third-party";
+    risk: {
+        level: "high" | "medium" | "low";
+        writeBoundary: "sdk-enforced" | "source";
+    };
+    distribution: {
+        defaultMode: "local" | "hybrid" | "sdk" | "codegen";
+    };
+    contributes: {
+        handlers: string[];
+        tools: string[];
+        cards: {
+            cardType: string;
+            schemaVersion?: number | undefined;
+        }[];
+        routes: string[];
+        pages: {
+            route: string;
+            component: string;
+        }[];
+        tabs: {
+            route: string;
+            label?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+        }[];
+        providers: {
+            slots: {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }[];
+        };
+        services: {
+            service: string;
+            optional: boolean;
+            defaults: {
+                provider: string;
+                implementation: string;
+            }[];
+            title?: string | undefined;
+            description?: string | undefined;
+        }[];
+        resources: {
+            type: string;
+            id: string;
+        }[];
+    };
+    dependencies: {
+        modules: {
+            id: string;
+            required: boolean;
+            range?: string | undefined;
+        }[];
+    };
+    env: string[];
+}, {
+    name: string;
+    schemaVersion?: number | undefined;
+    version?: string | undefined;
+    kind?: "platform" | "business" | "third-party" | undefined;
+    risk?: {
+        level?: "high" | "medium" | "low" | undefined;
+        writeBoundary?: "sdk-enforced" | "source" | undefined;
+    } | undefined;
+    distribution?: {
+        defaultMode?: "local" | "hybrid" | "sdk" | "codegen" | undefined;
+    } | undefined;
+    contributes?: {
+        handlers?: string[] | undefined;
+        tools?: string[] | undefined;
+        cards?: {
+            cardType: string;
+            schemaVersion?: number | undefined;
+        }[] | undefined;
+        routes?: string[] | undefined;
+        pages?: {
+            route: string;
+            component: string;
+        }[] | undefined;
+        tabs?: {
+            route: string;
+            label?: string | undefined;
+            icon?: string | undefined;
+            order?: number | undefined;
+        }[] | undefined;
+        providers?: {
+            slots?: {
+                service: string;
+                provider: string;
+                implementation: string;
+                credentialType: string;
+                local?: boolean | undefined;
+                configSchema?: string | undefined;
+                credentialSchema?: string | undefined;
+            }[] | undefined;
+        } | undefined;
+        services?: {
+            service: string;
+            optional?: boolean | undefined;
+            defaults?: {
+                provider: string;
+                implementation: string;
+            }[] | undefined;
+            title?: string | undefined;
+            description?: string | undefined;
+        }[] | undefined;
+        resources?: {
+            type: string;
+            id: string;
+        }[] | undefined;
+    } | undefined;
+    dependencies?: {
+        modules?: {
+            id: string;
+            range?: string | undefined;
+            required?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+    env?: string[] | undefined;
+}>;
+type ModuleDescriptor = z.infer<typeof moduleDescriptorSchema>;
+type CardContrib = z.infer<typeof cardContribSchema>;
+type ProviderSlotContrib = z.infer<typeof providerSlotContribSchema>;
+type ServiceNeedContrib = z.infer<typeof serviceNeedContribSchema>;
+type ResourceNeedContrib = z.infer<typeof resourceNeedContribSchema>;
+type ParseModuleResult = {
+    ok: true;
+    value: ModuleDescriptor;
+} | {
+    ok: false;
+    errors: string[];
+};
+declare function parseModuleDescriptor(raw: unknown): ParseModuleResult;
+
+/**
+ * 配置 JSON 环境变量占位展开（纯数据形态——自 app-sdk env-expansion.ts 迁入改造）。
+ *
+ * 语法（与 SDK 版语义逐字一致，共享向量 test-fixtures/env-expansion-cases.json 防漂移）：
+ *   ${NAME}     占位引用；NAME 限定 [A-Z][A-Z0-9_]*（UPPER_SNAKE，最小化与正文 `${...}` 误碰）
+ *   $${NAME}   转义为字面量 ${NAME}（原样保留一次 $）
+ *
+ * 语义（评审 N1 钉死，壳层各自包装 throw/report）：
+ *   - 单遍非递归：env 值内若含 `${OTHER}` 不被二次展开（注入防线）；String.replace 回调形态天然单遍。
+ *   - 值经 JSON 字符串转义注入；不做数值/布尔强制转换。
+ *   - **本版为纯数据返回形态** `{ text?: string; missing: string[] }`——缺变量不 throw，
+ *     由壳层（CLI doctor 壳 / app-sdk 桥 throw 壳 / 沙箱宿主）决定 fail-fast 还是降级：
+ *     SDK 桥壳 missing 非空即 throw（错误文案逐字等价 SDK 旧版）；CLI 壳同款。
+ *   - 无 ${ 的文本快速路径：text 原文返回，零替换零开销。
+ */
+interface EnvExpansionResult {
+    /** 展开后文本；存在缺失变量时缺席（调用方按 missing 处理，正文不半展开） */
+    text?: string;
+    /** 缺失变量清单（不回显 env 值——机密不进日志） */
+    missing: string[];
+}
+/** 展开配置文本（纯数据）；缺失变量 → `{ missing }`（text 缺席），由壳层决定 throw/降级 */
+declare function expandEnvVars(text: string, env?: Readonly<Record<string, string | undefined>>): EnvExpansionResult;
+
+/**
+ * 凭据掩码算法（GET 路径永无真值——CredentialEcho.masked 单源）。
+ * 独立小模块：integrations/credentials.ts（读端掩码）与测试共用，避免 credential-format
+ * 的写端 fs 依赖被读端连带拉起（views 层零 fs 依赖约束的前置拆分）。
+ */
+/** 掩码规则：每字段前 2 字符 + '****'；≤4 字符退化全 '****'；缺字段 → null。
+ *  序列化后零真值断言由测试 O4 钉死。 */
+declare function maskCredentialValues(values: Record<string, string>): Record<string, string | null>;
+
+/**
+ * 凭据双工件·文件格式与 stem 派生（写端/读端共用格式单源）。
+ *
+ * 凭据文件 `config/credentials/<stem>.json` = `{ type, ...values }`（真值工件）；
+ * integrations.json 恒持 `secret://<stem>` 引用（ref），任何 GET 路径无真值。
+ *
+ * stem 三形（服务端单源派生；与既有自由 stem 兼容）：
+ *   服务级  `${provider}-${service}`
+ *   实例级  `${provider}-${instanceId}-${domain}`（domain = service 首点段）
+ *   应用级  `${provider}-global` / `${provider}-${instanceId}-global`
+ *
+ * 安全（纵深防御第二道）：deriveStem 对任一输入含 `/`、`\`、`..` 直接 throw——
+ * 第一道为 descriptor/节点 zod 的字符集 pattern（module-schema SAFE_NAME_PATTERN）。
+ */
+
+interface CredentialFile {
+    type: string;
+    values: Record<string, string>;
+}
+/** 凭据 stem 派生输入（service 级 / instance 级 / app 级三形由调用方按层选择字段） */
+interface StemInput {
+    provider: string;
+    service?: string;
+    instanceId?: string;
+    domain?: string;
+}
+/** stem 单源派生（三形；输入含 / \ .. → throw——断言防线） */
+declare function deriveStem(input: StemInput): string;
+/** stem → ref（'secret://<stem>'） */
+declare function stemToRef(stem: string): string;
+/** stem → 凭据文件相对路径（'config/credentials/<stem>.json'） */
+declare function stemToFilePath(stem: string): string;
+/** 读凭据文件（真值工件；缺席 → null） */
+declare function readCredentialFile(appDir: string, stem: string): CredentialFile | null;
+/** 写凭据工件（真值；写前 ensureDir 物化父目录——credentials 目录首次写物化）。
+ *  返回 overwrote（同 stem 已在场 = 重写）。调用方负责先跑凭据校验链（type 匹配 + ajv 字段级）。 */
+declare function writeCredentialFile(appDir: string, stem: string, file: CredentialFile): boolean;
+
+/**
+ * 原子写原语（自 CLI dev.ts 私有 writeAtomic 提升为导出——CLI/写核心/凭据工件三消费方单源）。
+ * temp+rename：rename 在同文件系统内原子；半写状态只会停留在 tmp（孤儿 tmp 无害）。
+ * 写前 ensureDir（递归 mkdir -p）——credentials 等目录首次写物化（H5）。
+ */
+/** 原子写文本文件：写前 ensureDir 父目录 + temp（pid+ts 后缀防碰撞）+ rename */
+declare function writeAtomic(file: string, content: string): void;
+/** 递归物化目录（mkdir -p 语义；已存在静默） */
+declare function ensureDir(dir: string): void;
+
+interface FileCache {
+    /** 读文件并 parse（指纹命中返回缓存产物；miss 重读）。文件缺席 → undefined（不缓存缺席态） */
+    read<T>(absolutePath: string, parse: (raw: string) => T): T | undefined;
+    /** 写后失效协议：paths 缺省全失效；指定路径仅失效对应条目 */
+    invalidate(paths?: readonly string[]): void;
+    /** 测试观测：parse 执行计数（W6 缓存命中不重 parse 断言用） */
+    readonly parseCount: number;
+}
+declare function createFileCache(): FileCache;
+
+/**
+ * 内联厂商声明（仅槽级 provider 字段可用；实例级 provider 恒字符串）。
+ * integrations.json 内直接声明供给，不经 provider 包 manifest。
+ * 未实施态语义：catalog/adapter 均无对应实现 → doctor warning + resolve 抛 PROVIDER_NOT_IMPLEMENTED
+ * （F5 交互化的「先声明后实施」闭环）。
+ */
+interface InlineVendorDeclaration$1 {
+    /** 厂商名（= 档位名 = provider 包轴，如 'wanda'） */
+    provider: string;
+    /** 认证类型（'-' 表示无凭据） */
+    credentialType: string;
+    /** config schema 引用（可选；相对应用 config/；受控子集校验归 doctor 谓词） */
+    configSchema?: string;
+}
+/**
+ * 槽实例（instances 键 = instanceId，mall 场景 = mallId；per-instance 唯一写位）。
+ * 激活不变式（v4）：service 在 scope k 生效 ⟺ instances[k] 在场（或 instances['*'] 通配在场，
+ * **或 instances 键整体缺席 = 通配激活**——对任意 instanceId 含 '' 命中）；任意生效点的
+ * per-instance 凭据均可写 instances[k].credentialRef（root ByInstance 是唯一例外层）。
+ * 通配边界：仅 instances 查找层生效——configByInstance/credentialRefByInstance 保持精确键语义。
+ */
+interface ServiceInstanceConfig {
+    /** 实例级厂商覆盖（绑定组头；恒字符串。impl-only 非法——implementation 需伴随 provider） */
+    provider?: string;
+    /** 实例级实现覆盖（'id@version'；缺席 = 绑定组内派生（SupplyLookup 唯一命中）） */
+    implementation?: string;
+    /** 连接参数（非机密项；configSchema 校验） */
+    config?: Record<string, unknown>;
+    /** 机密引用：'secret://{ref}'（local provider 免） */
+    credentialRef?: string;
+    /** 缺省 true；false → resolve → INSTANCE_DISABLED */
+    enabled?: boolean;
+}
+/**
+ * 槽级配置（v3：provider/implementation 可选——双双缺席回落 domain/root 继承；
+ * 显式在场 = 显式即真值（不派生——存量全显式文件零影响）。impl-only 非法：
+ * implementation 需伴随 provider（provider 是绑定组头）。内联声明仍仅槽级且必带
+ * implementation（内联无派生源）。
+ * config/credentialRef = 服务级 scope-free 默认。
+ */
+interface ConfiguredService {
+    /** 绑定组头（字符串厂商 = 派生位；内联声明 = 显式供给，必带 implementation） */
+    provider?: string | InlineVendorDeclaration$1;
+    /** 绑定组尾（'id@version'；缺席 = 派生（SupplyLookup 唯一命中）） */
+    implementation?: string;
+    config?: Record<string, unknown>;
+    credentialRef?: string;
+    /** 实例激活表（v4 可选：键缺席 = 通配激活 ≡ {"*":{}}；显式空集 = 显式零激活） */
+    instances?: Record<string, ServiceInstanceConfig>;
+}
+/**
+ * 模块域全局配置（键 = 槽位域前缀，moduleDomainOf 派生；域 ≠ 模块名——auth 域由登录链消费）。
+ * 域 ≠ 部署边界：单应用单厂商部署门禁不因 domains 表达力放开（混绑 die 原样）。
+ */
+interface DomainConfig {
+    /** 域级默认厂商（implementation 恒派生——域层无精确绑定语义） */
+    provider?: string;
+    /** 域级共享配置（该域全部槽合并进 config 级联，与绑定来源层无关） */
+    config?: Record<string, unknown>;
+}
+/**
+ * 部署实例（业务主体拓扑条目；root instances 注册表元素——v4 参考表）。
+ * 域属性经 attributes 由 TIER1 赋义（mall 场景：miniAppId/contactPhone/location）——
+ * TIER0 全程 opaque；本表纯元数据（展示/默认解析），永不充当解析闸门
+ * （闸门唯一表达位 = 槽 instances 激活表形态，见 ServiceInstanceConfig）。
+ */
+interface DeploymentInstance {
+    /** 实例 id = instanceId 注册来源（槽激活表/ByInstance 键引用它）；禁 '*'（通配保留字） */
+    id: string;
+    /** 展示名（品牌区回显等域消费） */
+    name: string;
+    /** 域属性袋（TIER0 opaque；TIER1 投影 zod 赋义） */
+    attributes?: Record<string, unknown>;
+}
+/** normalizeInstances 产物（模板装配 / CLI doctor / 根脚本共用消费形态） */
+interface NormalizedInstances {
+    instances: readonly DeploymentInstance[];
+    /** 显式 ?? 单候选唯一解；null = 无默认（多实例无显式默认 = 合法，doctor warning） */
+    defaultInstanceId: string | null;
+}
+/**
+ * integrations.json 根形状（loadIntegrations 产物 zod 目标）。
+ * 全链唯一 ByInstance 层 = root 四字段（configByInstance/credentialRefByInstance）；约束域 = provider
+ * 解析链（services/domains/instances）；modules 资源轴正交不受此限。
+ * service/instance 层级内 per-instance 语义由 instances 键承载。
+ * v3 绑定继承：绑定组从最特异层整组取（inst > slot > domains[d] > root）。
+ * v4 部署实例注册表：instances = 参考表（纯元数据）；defaultInstanceId = 默认实例
+ * （无 scope 参数访问兜底；单实例免填——唯一解；无参考表时独立在场 = env 注入动态默认形态）。
+ */
+interface IntegrationsConfig {
+    /** 应用全局默认厂商（root 继承层；implementation 恒派生） */
+    provider?: string;
+    /** 部署级 scope-free 默认配置 */
+    config?: Record<string, unknown>;
+    /** 部署级 per-instance 默认配置（键 = instanceId） */
+    configByInstance?: Record<string, Record<string, unknown>>;
+    /** 部署级 scope-free 默认凭据（文件必须 scope:{}） */
+    credentialRef?: string;
+    /** 部署级 per-instance 默认凭据表（键 = instanceId；商户级凭据主写位） */
+    credentialRefByInstance?: Record<string, string>;
+    /** 模块域全局层（键 = moduleDomainOf(service)；无 ByInstance——全链唯一 ByInstance 层恒 root） */
+    domains?: Record<string, DomainConfig>;
+    /** 部署实例注册表（参考表）；缺席 = 无参考表；空数组非法（zod 拒——无表 = 键缺席唯一写法） */
+    instances?: DeploymentInstance[];
+    /** 默认实例 id（单实例免填；∈instances ids；无表时独立在场 = 动态默认形态） */
+    defaultInstanceId?: string | null;
+    /** 模块资源绑定（v5 新轴——与 domains 正交：domains = provider 绑定默认，modules = 资源绑定；
+     *  键 = install id（.tbox/app.json entry.id / packages/ 目录名；仓内家族包恒等 manifest name 属规约）；
+     *  无 per-instance 层（扩展位词汇预选 resourcesByInstance——instances 词恒属 services 激活语义） */
+    modules?: Record<string, ModuleConfig>;
+    services: Record<string, ConfiguredService>;
+}
+/** 级联求值产物（ok 态） */
+interface EffectiveService {
+    provider: string | InlineVendorDeclaration$1;
+    implementation: string;
+    /** 五层浅合并一层：root.config → root.configByInstance[k] → domain.config → slot.config → inst.config */
+    config: Readonly<Record<string, unknown>>;
+    credentialRef?: string;
+}
+type EffectiveServiceResolution = {
+    status: 'ok';
+    effective: EffectiveService;
+} | {
+    status: 'service-not-configured';
+} | {
+    status: 'instance-not-found';
+} | {
+    status: 'instance-disabled';
+} | {
+    status: 'binding-unresolved';
+    message: string;
+};
+/** 槽位域前缀（domains 键控轴）：首个点号前段；无点号取整串。域 ≠ 模块名（auth 域由登录链消费）。 */
+declare function moduleDomainOf(service: string): string;
+/** 派生查表（buildSupplyLookup 产物）：键 `${provider}\u0000${service}` → implementation 清单（'id@version'）。 */
+type SupplyLookup$1 = Record<string, readonly string[]>;
+/**
+ * 级联细则（一句话：层序优先于 scope 特异度；层内 per-instance 胜标量）：
+ * - 绑定组（provider + implementation）：最特异层整组取（inst > slot > domain > root）——
+ *   独立 `??` 继承会产生跨层非法组合（inst.provider=wanda + 继承 slot 的 joycity impl），
+ *   故组不可拆；组内 implementation 缺席 → supplies 派生（唯一命中；
+ *   零命中/歧义/未注入查表 → binding-unresolved）；双字段显式在场 = 显式即真值（不派生，
+ *   存量全显式文件零影响）。内联声明仅槽级且必带 implementation（防御分支兜底）。
+ * - config 五层浅合并：root.config → root.configByInstance[k] → domain.config → slot.config →
+ *   inst.config（service 标量胜 root ByInstance[k]——层序优先于 scope 特异度；
+ *   domain.config 恒参与该域全部槽，与绑定来源层无关）
+ * - credentialRef：inst ?? slot ?? root.credentialRefByInstance[k] ?? root.credentialRef（v3 零改动；
+ *   domain 层无 credentialRef——链位预留 slot 后、root ByInstance 前）
+ * 不抛领域错误；status 由 SDK registry 映射 PROVIDER_* 错误码
+ * （binding-unresolved → PROVIDER_BINDING_UNRESOLVED；hasProviderBinding 点查 status !== 'ok' → false）。
+ */
+declare function resolveEffectiveService(integrations: IntegrationsConfig, service: string, instanceId: string, supplies?: SupplyLookup$1): EffectiveServiceResolution;
+/**
+ * root 部署实例注册表归一化（v4 wire → 消费形态单源）：
+ * - instances 缺席 = 空表（无参考表——wanda 动态形态；空数组已在 zod 拒，此处纯防御）；
+ * - defaultInstanceId 解析：undefined（未填）→ 单候选唯一解（instances 恰一项）；
+ *   显式 null = 显式无默认（不派生——「显式即真值」原则同 v3 绑定组）；无默认 → null。
+ * 调用方：TIER1 控制平面投影（mallControlPlaneOf）、CLI doctor（多实例无默认 warning）、
+ * 根脚本（real-env-plan 默认实例探测）——禁止各自重写解析逻辑。
+ */
+declare function normalizeInstances(config: Pick<IntegrationsConfig, 'instances' | 'defaultInstanceId'>): NormalizedInstances;
+/** catalog provider 聚合条目（providers[vendor][implementation] 两跳可达；自描述双字段） */
+interface CatalogProviderEntry {
+    /** 厂商名（嵌套第一轴；与条目键一致便于透传） */
+    provider: string;
+    /** 实现标识（嵌套第二轴；'id@version'） */
+    implementation: string;
+    /** 认证类型（authStrategies 匹配键；'-' 无凭据） */
+    credentialType: string;
+    /** 宿主 npm 包名（诊断归属；多槽同包同 owner） */
+    owner: string;
+    /** local 供给（mock 形态） */
+    local?: boolean;
+    /** config schema 引用 */
+    configSchema?: string;
+    /** credential schema 引用 */
+    credentialSchema?: string;
+    /** 供给槽清单（service id） */
+    services: string[];
+}
+/** catalog 需求侧聚合条目（模块 manifest contributes.services 元素聚合；services 键 = service id） */
+interface CatalogServiceEntry {
+    /** 可选槽（未配置不 error——doctor warning 级） */
+    optional: boolean;
+    /** manifest defaults（F5 页面预填缺省供给） */
+    defaults: Array<{
+        provider: string;
+        implementation: string;
+    }>;
+    /** 声明方模块（moduleId 清单） */
+    owners: string[];
+}
+/** loadProviderCatalog 产物：全应用 provider 供给与需求聚合（.tbox/app.json npmModules 真源） */
+interface ProviderCatalog {
+    /** 嵌套形态：厂商级语义一跳、F5 厂商→实现级联枚举天然序；migrate 反查表 = 本表自身 */
+    providers: Record<string, Record<string, CatalogProviderEntry>>;
+    services: Record<string, CatalogServiceEntry>;
+    /** credentialType 直达索引（F5/doctor 单跳；同名共享单例先例） */
+    credentialTypes: Record<string, {
+        owner: string;
+        credentialSchema?: string;
+    }>;
+}
+/**
+ * catalog → 派生查表（展开 providers[vendor][impl].services 为
+ * `${provider}\u0000${service}` → implementation 清单）。
+ * 调用方在工厂构造期构建一次（SDK registry / CLI doctor 谓词 / F5 页面 state），求值期 O(1) 查表。
+ */
+declare function buildSupplyLookup(catalog: ProviderCatalog): SupplyLookup$1;
+/** knowledge 资源声明（wire 形态；datasetId/ref 至少其一，并存时 datasetId 优先——resolver 层裁决） */
+interface KnowledgeResourceSpec {
+    type: 'knowledge';
+    /** datasetId 直填（免台账） */
+    datasetId?: string;
+    /** knowledge.json 台账条目名（展开锚 = integrations.json 所在目录——与数据同源旅行） */
+    ref?: string;
+    topK?: number;
+    scoreThreshold?: number;
+}
+/** 资源声明（discriminated by type；SDK zod / CLI doctor / 未来 app-toolkit 共用 wire 形状） */
+type ResourceSpec = KnowledgeResourceSpec;
+/** 模块资源配置（modules 节元素；strict 单字段——provider/config/instances 进 modules 即非法，防与 domains 双写位） */
+interface ModuleConfig {
+    /** resourceId → 类型化资源声明（resourceId 词汇真源 = 模块 manifest contributes.resources） */
+    resources: Record<string, ResourceSpec>;
+}
+
+/**
+ * contracts 期望面编译期锁（satisfies 语义防接口漂移——contracts 加名/改签名即编译红）。
+ * resolver 运行时产物按本接口逐命名导出存在性检查（evaluation/strictValidation 按在场降级）。
+ * contracts 恒 devDep 且限 import type——运行时全经 resolver 动态 import（版本解耦，D3）。
+ */
+interface EvaluationExports {
+    /** 求值单源（TIER0；v3 显式激活 vs v4 通配语义随应用版本） */
+    resolveEffectiveService: typeof resolveEffectiveService;
+    /** 供给查表派生（谓词 #12 与视图供给轴共用输入） */
+    buildSupplyLookup: typeof buildSupplyLookup;
+    /** service → 首点段域前缀（谓词 #14 域键匹配） */
+    moduleDomainOf: typeof moduleDomainOf;
+    /** 部署实例注册表归一（默认实例委托——null → '*' 通配口径） */
+    normalizeInstances: typeof normalizeInstances;
+    /** 模块资源类型词汇表（v5；descriptor type 校验经 resolver 取词表） */
+    RESOURCE_TYPE_IDS: readonly string[];
+    /** 严格 zod 面（0.9+ 可选）——strictValidation 门控判据；缺席 = 求值/写 503 */
+    parseIntegrationsConfig?: (raw: unknown) => IntegrationsConfig;
+}
+/** resolver 运行时产物类型（动态 import 的命名导出子集） */
+type ResolvedModule = Partial<EvaluationExports>;
+
+/**
+ * contracts 动态解析器（方案心脏，D3）：`resolveContractsForApp(appDir)`——
+ * 成员扫描 + 包根定位。沙箱内 toolkit 与目标应用版本解耦：求值与校验双面由
+ * 应用自己的 @tbox.cn/app-contracts 版本驱动。
+ *
+ * 解析算法：
+ *   候选目录序（越靠前越优）：
+ *     1. appDir/node_modules/@tbox.cn/app-contracts              （npm 平铺 / 应用根直装）
+ *     2. appDir/apps/server/node_modules/…                       （pnpm 成员级——运行时消费方优先）
+ *     3. appDir/apps/<各成员>/node_modules/…（其余成员，字母序去重）
+ *     4. appDir/packages/<各包>/node_modules/…（codegen 模块包）
+ *   每候选：existsSync → realpathSync（解 pnpm symlink 至 store 真实路径）
+ *     → 探测 <根>/dist/runtime.js（构建/发布/验证态）｜<根>/src/runtime.ts（workspace link 态，TS-host 前提）
+ *     → 读 **候选路径**（symlink 原路径）package.json version——版本轻探测：pnpm 升级换 store 目标
+ *       可觉察（realpath 缓存路径旧 version 恒旧，读候选路径修正——真 bug 候选防线）
+ *     → await import(探测命中文件) → 逐命名导出存在性检查（contracts-expected EvaluationExports）
+ *   首个命中即返回（候选序即优先级）；全候选缺席/导入拒绝 → 未解析（**绝不 throw**）。
+ *
+ * **红线**：禁 createRequire().resolve（contracts 发布面 exports 仅 types+import 双条件、
+ * 无 require/default——必抛 ERR_PACKAGE_PATH_NOT_EXPORTED）；动态 import 路径运行时计算
+ * （pathToFileURL——打包器不得字面量折叠，README 打包纪律）。
+ *
+ * memoize：per appDir 记忆 { promise, version }；每次 resolve 轻探测候选路径 version——
+ * 变更 → 重走候选链 + 动态 import（Node import 缓存按路径天然去重；升级契约自动生效，
+ * 不依赖事件广播——node_modules 被 FileWatcher IGNORED_DIRS 过滤，自愈设计不依赖广播）。
+ */
+interface ResolvedContracts {
+    /** 候选包 package.json version（未安装 → null） */
+    version: string | null;
+    /** 求值面可用（resolveEffectiveService 等命名导出在场） */
+    evaluation: boolean;
+    /** 严格 zod 面可用（parseIntegrationsConfig 在场——≥0.9 门控判据） */
+    strictValidation: boolean;
+    /** 动态 import 产物（命名导出子集——Partial<EvaluationExports>） */
+    module: ResolvedModule;
+    /** 解析诊断（N1 构建指引 message 三分支的输入：未安装 / 版本 <0.9 / 源码态未构建） */
+    notes: string[];
+}
+/** 解析应用自己的 contracts（memoize + 轻探测指纹；绝不 throw——全缺席 → 未解析产物）。
+ *  F9：命中判定 = 首个在册候选 + 命中候选双指纹（版本变更 / dist 物化 / 候选序变化 / 候选消失
+ *  全面可觉察——覆盖「build 后重试」长生命周期宿主与多候选走位两处 stale 边缘）。 */
+declare function resolveContractsForApp(appDir: string): Promise<ResolvedContracts>;
+/** 逃生舱（测试/宿主特殊场景——正常路径无需调用，Freshness Contract 自动；invalidate 逃生舱标注） */
+declare function invalidateContractsResolver(appDir?: string): void;
+
+/**
+ * integration-services 谓词单源（integrations v4；自 CLI doctor/integration-services.ts 迁入——
+ * doctor 第 19 条与 toolkit 工厂 evaluateIntegrationServices 共用此函数，单源不变）。
+ * 纯函数、零副作用、零 I/O——contracts 经 input.contracts 注入（resolver 装配，版本解耦 D3）。
+ *
+ * 结构化输出（H7 v4.3）：IntegrationIssue { severity, code, message, service?, module?, instance? }——
+ * 检查逻辑零改动（~24 处 push 机械加 code/定位字段；level→severity 字段同名随 D22 班车，
+ * severity 取值恒等旧 level——doctor 门控行为等价）。
+ * **code 枚举单源 = 本文件头映射表（additive-only；api.md §5 表与本表同步）**：
+ *   CREDENTIAL_FILE_MISSING      #1     error    effective credentialRef 引用凭据文件不在场
+ *   CREDENTIAL_TYPE_MISMATCH     #2     error    凭据文件 .type 与绑定 credentialType 不一致
+ *   SLOT_NOT_DECLARED            #3     warning  服务槽无消费方声明（拼写/需求方未安装/旧槽位词汇）
+ *   SLOT_NOT_CONFIGURED          #4     warning  需求方缺口（服务槽未配置）
+ *   INSTANCE_SUPPLY_UNMATCHED    #5     error    绑定未命中已装供给（槽级/实例级覆盖）
+ *   IMPL_WITHOUT_PROVIDER        #5/#13 error    impl-only（implementation 缺 provider 绑定组头）
+ *   INLINE_PROVIDER_INVALID      #5     error    内联厂商声明超受控形状（槽级/实例级）
+ *   SCHEMA_FILE_MISSING          #6     error    credentialType schema 引用不存在
+ *   DOMAIN_CONFIG_INVALID        #7     error    root/domains 死配置（键 ∉ 引用厂商 schema properties；
+ *                                                api.md DOMAIN_CONFIG_UNUSED 行预留 warning 级，
+ *                                                现行为 error 恒等旧谓词——doctor 门控等价）
+ *   INSTANCE_KEY_NOT_REGISTERED  #8     error    ByInstance 键/实例键 ∉ 注册表白名单
+ *   REALM_SWITCH_HINT            #9     warning  实现覆盖跨厂商（凭据域切换确认）
+ *   WILDCARD_ALIGNMENT           #10    warning  通配形态齐步提示
+ *   MULTI_INSTANCE_NO_DEFAULT    v4     warning  多实例无 defaultInstanceId（无 scope 访问落全局会话）
+ *   VENDOR_NOT_INSTALLED         #11    error    root/domains 厂商未命中已装供给
+ *   BINDING_UNRESOLVED           #12    error    绑定不可解析（resolveEffectiveService 求值失败）
+ *   DOMAIN_KEY_UNMATCHED         #14    warning  domains 键 ∉ 匹配域集（typo）
+ *   RESOURCE_TYPE_UNKNOWN        #15    error    modules 资源节 type ∉ 词汇表
+ *   RESOURCE_NOT_DECLARED        #16    warning  资源键/资源 id ∉ 模块声明集
+ *   ORPHANED_CREDENTIAL          写后对账 warning  凭据文件不再被引用（toolkit 写路径产出，非本谓词）
+ *
+ * 输入形状（调用方负责装载）：
+ * - integrations：config/integrations.json 解析产物（宽松 Record 透传——严格 zod 校验归模板 loader）
+ * - suppliedProviders：已声明供给（`${vendor}\u0000${implementation}` 拼接键 → 槽集合；同源聚合）
+ * - demandedServices：已声明需求（service → { optional, owners }）
+ * - supplies：派生查表（contracts buildSupplyLookup 产物；缺席 → #12 跳过，M3 降级兼容）
+ * - malls：可选实例 id 白名单（v4 源 = root instances 注册表 ids；缺席 → ByInstance 键检查跳过）
+ * - credentialSchemas：可选（credentialType → schema 文件引用路径；manifest 声明聚合）
+ * - configSchemas：可选（service/slot → schema 文件引用路径）
+ *
+ * 检查族（v3）：
+ * #1 effective credentialRef → 档内凭据文件在场
+ * #2 凭据文件 .type 与绑定 credentialType 对齐（错配 = transport 期「未知认证类型」前置暴露；
+ *    继承绑定（槽级 provider 缺席）经 effective 求值取厂商——supplies 在场时）
+ * #5 实例 impl-only 禁止 + 覆盖命中供给（含槽级内联形状；provider-only = 派生位，合法）
+ * #6 manifest configSchema/credentialSchema 引用文件存在性（内联与 manifest 绑定同查）
+ * #7 root/domains 死配置：root.config/configByInstance/domains[d].config 键 ⊆ 引用厂商（并集）
+ *    各槽 schema properties——引用面 = root.provider ∪ domains.*.provider ∪ 槽级（terse 化防退化）
+ * #8 ByInstance/实例键 ∈ malls 白名单（v4：源 = root instances 注册表 ids——参考表在场时
+ *    激活；'**' 通配键豁免；注册表缺席 → 跳过；domains 键 = 域前缀非 instanceId，不适用）
+ * #9 实现覆盖跨厂商提示（realm switch——凭据域切换确认）
+ * #11 root/domains 厂商未命中已装供给（vendor 集合 = suppliedProviders 键前缀展开）
+ * #12 绑定可解析性：逐 (service, instanceId) 经 contracts resolveEffectiveService 求值
+ *     （级联单源复用，谓词零级联实现），binding-unresolved → error（supplies 缺席 → 跳过）
+ * #13 槽级/实例级 impl-only（implementation 需伴随 provider——provider 是绑定组头；
+ *     zod 之外的第二道防线——doctor 读裸 JSON）
+ * #14 domains 键 ∈ 匹配域集（已配置槽 ∪ 需求声明的 moduleDomainOf 并集；typo → warning）
+ * #15-#16 modules 资源节对账（v5）：type ∉ RESOURCE_TYPE_IDS → error（裸 JSON 预启动反馈）；
+ *     键 ∉ 已装模块 id 集 / 资源 id ∉ 模块 manifest contributes.resources 声明集（声明非空时）
+ *     → warning（moduleResourceNeeds 缺席 → 需求面检查跳过，M3 降级先例）
+ */
+
+/** contracts 注入面（resolver 装配产物运行时视图 = EvaluationExports 求值子集） */
+type PredicateContracts = Pick<EvaluationExports, 'resolveEffectiveService' | 'buildSupplyLookup' | 'moduleDomainOf' | 'normalizeInstances' | 'RESOURCE_TYPE_IDS'>;
+/** 派生查表形状（contracts buildSupplyLookup 产物；结构等价 TIER0 SupplyLookup——谓词零 contracts 静态依赖） */
+type SupplyLookup = Record<string, readonly string[]>;
+interface IntegrationServicePredicateInput {
+    integrations: {
+        provider?: string;
+        domains?: Record<string, {
+            provider?: string;
+            config?: Record<string, unknown>;
+        }>;
+        config?: Record<string, unknown>;
+        configByInstance?: Record<string, Record<string, unknown>>;
+        credentialRef?: string;
+        credentialRefByInstance?: Record<string, string>;
+        services: Record<string, {
+            provider?: string | Record<string, unknown>;
+            implementation?: string;
+            config?: Record<string, unknown>;
+            credentialRef?: string;
+            instances?: Record<string, {
+                enabled?: boolean;
+                provider?: unknown;
+                implementation?: unknown;
+                credentialRef?: string;
+            }>;
+        }>;
+        /** v4 部署实例注册表（参考表——#8 白名单源 + 多实例无默认 warning） */
+        instances?: Array<{
+            id: string;
+            name?: string;
+            attributes?: Record<string, unknown>;
+        }>;
+        /** v4 默认实例（normalizeInstances 解析语义：显式 ?? 单候选唯一解） */
+        defaultInstanceId?: string | null;
+        /** v5 模块资源绑定（modules 节——宽松透传；严格 zod 归模板 loader） */
+        modules?: Record<string, {
+            resources?: Record<string, {
+                type?: unknown;
+            }>;
+        }>;
+    };
+    /** 已声明供给（`${vendor}\u0000${implementation}` → 槽集合；credentialType 供 #2/#6 绑定侧对齐） */
+    suppliedProviders: Record<string, {
+        services: string[];
+        owner: string;
+        credentialType?: string;
+    }>;
+    /** 已声明需求（service → { optional, owners }) */
+    demandedServices: Record<string, {
+        optional: boolean;
+        owners: string[];
+    }>;
+    /** 派生查表（buildSupplyLookup 产物；缺席 → #12 跳过 + #2 继承绑定不查 credentialType） */
+    supplies?: SupplyLookup;
+    /** malls 白名单（deployments 控制面 extract；缺席 → ByInstance 键检查跳过） */
+    malls?: string[];
+    /** credentialType → schema 文件引用缺失（manifest 声明指向缺失文件；#6） */
+    credentialSchemaMissing?: Record<string, boolean>;
+    /** 厂商 → 槽 schema properties 键集（#7 用；调用方从 manifest configSchema 引用解析） */
+    vendorConfigKeys?: Record<string, Set<string>>;
+    /** 厂商 → configSchema 引用文件缺失（#7 跳过该厂商——无 schema 不能判死配置） */
+    vendorConfigSchemaMissing?: Record<string, boolean>;
+    /** 凭据文件缺失（#1：credentialRef stem → 档内 credentials/<stem>.json 在场；域中立注入） */
+    credentialFileMissing?: Record<string, boolean>;
+    /** 凭据文件 .type（stem → type；#2 对齐判定——文件无 type 则缺键，跳过） */
+    credentialFileType?: Record<string, string | undefined>;
+    /** #9：实现覆盖跨厂商提示位（CLI 侧组装） */
+    realmSwitchHints?: string[];
+    /** v5：已装模块 id → manifest contributes.resources 声明 id 集（值空集 = 无声明，资源级跳过；
+     *  缺席 = 无需求面信息——键未知/资源未声明检查跳过，type 检查恒跑） */
+    moduleResourceNeeds?: Record<string, ReadonlySet<string>>;
+}
+/** 结构化 issue（H7 v4.3）：code 枚举单源 = 本文件头映射表（additive-only） */
+interface IntegrationServiceIssue {
+    severity: 'error' | 'warning';
+    code: string;
+    message: string;
+    service?: string;
+    module?: string;
+    instance?: string;
+}
+/** 内联厂商声明受控形状（v2：provider/credentialType/configSchema） */
+declare function isControlledInlineProvider(raw: unknown): boolean;
+/** #8 检查族导出（FX-2b 单源）：toolkit 写路径轻量复查（registryCheck）消费——
+ *  覆盖 configByInstance / credentialRefByInstance / services[s].instances 三键位；
+ *  malls = root instances 注册表 ids（参考表缺席 → 消费方跳过，勿传空集）。 */
+declare function checkInstanceKeys(integrations: {
+    configByInstance?: Record<string, unknown>;
+    credentialRefByInstance?: Record<string, unknown>;
+    services?: Record<string, {
+        instances?: Record<string, unknown>;
+    }>;
+}, malls: readonly string[]): IntegrationServiceIssue[];
+/** 谓词主体：integrations 配置 × catalog 声明 交叉校验（error/warning 分级；contracts 注入） */
+declare function evaluateIntegrationServices(input: IntegrationServicePredicateInput & {
+    contracts: PredicateContracts;
+}): IntegrationServiceIssue[];
+
+/**
+ * walkManifests(appDir)——单次遍历四产物（D24/D26；ai-build C3-1）。
+ *
+ * manifest 候选路径探测（packages/<id>/tbox.module.json 优先 → node_modules/<pkg>/tbox.module.json；
+ * tbox-app dev 真身经 .tbox-dev.local/dev-manifest.json redirects 独立 catalog 通道直达）一次遍历同时产出：
+ *   1. modules：已装模块清单（declared；demand meta title/description 透传）
+ *   2. catalog（富形态）：providers 嵌套（vendor→impl→entry，per-service {implementation, credentialType}
+ *      保真——同厂商异构/多实现合法，D25/H1）+ 需求侧聚合
+ *   3. serviceSchemas：per-service schema 复合键表——键 `${provider}\u0000${service}`（H2，同一服务
+ *      多厂商供给各自 schema 零碰撞）；多 impl 同 (provider, service) 异 schema → 声明序首个
+ *   4. vocabulary：所有携带 service-slots.json 的已装契约包该文件 `.slots` 键并集（fs 直读、
+ *      `$comment` 忽略；探测链 = readdir(<候选>/node_modules/@tbox.cn) 过滤携带该文件的包——
+ *      零缓存枚举，与 manifest 探测同机制；多行业 contracts-* 天然扩展 F8）；缺席 → []（退化 demanded ∪ configured）
+ *   5. domainKeyIssues：跨模块域键冲突 issue（两模块派生同一 domains 键——P13）
+ *
+ * **约束（D26；FX-3/F7 边界）**：目录枚举零缓存——readdir / node_modules 候选探测 / `.tbox/app.json` 读取 /
+ * dev-manifest 读取每次执行（枚举输入保持 fresh——agent 装卸模块下一笔即见）；manifest/service-slots
+ * **文件内容**经 file-cache（`cache` 可选参——工厂/写内核传本实例 cache（stat 指纹自愈 + 写后失效）；
+ * CLI 传 undefined 即全 fresh）。
+ * 宽松解析语义（坏文件静默 + 重复键首声明保留）零改动。
+ */
+interface WalkManifestsResult {
+    /** declared 产物（install id + descriptor；demand meta 透传） */
+    modules: WalkModuleInfo[];
+    /** 富形态 catalog（providers 嵌套保真 + 需求聚合 + credentialTypes） */
+    catalog: WalkCatalog;
+    /** per-service schema 复合键表：`${provider}\u0000${service}` → schema 引用 + 包根 */
+    serviceSchemas: Record<string, {
+        configSchema?: string;
+        credentialSchema?: string;
+        packageDir: string;
+    }>;
+    /** 服务词汇 = 所有携带 service-slots.json 的已装契约包 `.slots` 键并集（缺席 → []） */
+    vocabulary: string[];
+    /** 跨模块域键冲突（P13——两模块的 service 集派生同一 domains 键） */
+    domainKeyIssues: Array<{
+        severity: 'warning';
+        code: 'DOMAIN_KEY_CONFLICT';
+        message: string;
+        module?: string;
+    }>;
+}
+interface WalkModuleInfo {
+    /** install id（packages/ 目录名 / npmModules entry.id） */
+    id: string;
+    /** 模块目录（本地 packages/<id> 优先；sdk 包 = node_modules 解析位） */
+    dir: string;
+    /** 发布源包名 */
+    pkg: string;
+    descriptor: ModuleDescriptor;
+}
+/** 富形态供给条目：per-service {implementation, credentialType} 恒数组保真（H1） */
+interface WalkProviderEntry {
+    provider: string;
+    implementation: string;
+    credentialType: string;
+    owner: string;
+    local?: boolean;
+    configSchema?: string;
+    credentialSchema?: string;
+    services: string[];
+}
+interface WalkCatalog {
+    providers: Record<string, Record<string, WalkProviderEntry>>;
+    services: Record<string, {
+        optional: boolean;
+        defaults: Array<{
+            provider: string;
+            implementation: string;
+        }>;
+        /** demand meta（title/description 首声明保留——模块 manifest demand 侧 additive） */
+        title?: string;
+        description?: string;
+        owners: string[];
+    }>;
+    credentialTypes: Record<string, {
+        owner: string;
+        credentialSchema?: string;
+    }>;
+}
+/** walkManifests 主体（单次遍历四产物；目录枚举零缓存——每次调用执行） */
+declare function walkManifests(appDir: string, cache?: FileCache): WalkManifestsResult;
+interface DeclaredModuleInfo {
+    id: string;
+    /** 装配包名（codegen/local = @app/<id>；sdk = 发布包名） */
+    pkg: string;
+    mode: 'local' | 'sdk' | 'codegen';
+    hasServerEntry: boolean;
+    hasClientEntry: boolean;
+    hasCards: boolean;
+    /** declaration.moduleId（deployment 对账真源；老模块无 declaration → undefined） */
+    moduleId?: string;
+}
+/** 提取 declaration.moduleId（宽松正则——容忍任意嵌套/注释；未声明 → undefined） */
+declare function extractModuleIdFromSource(source: string): string | undefined;
+/**
+ * 计算声明集合（含 npm 清单 + 本地模块约定发现）。
+ * hasServerEntry/hasClientEntry 决定模块参与哪些装配文件（入口探测，非 post-hoc 修复）。
+ * 单源 = walkManifests（npmModules 登记 + packages/* 约定发现双通道；strict 形态进清单）。
+ */
+declare function collectDeclaredModules(appDir: string): DeclaredModuleInfo[];
+
+/**
+ * 谓词装配单源（FX-2b/F1）：CLI doctor 规则 与 toolkit 工厂（求值轴 / SaveResult.issues）
+ * 共用同一 I/O 装配与供给/需求聚合——「面板 issues ≡ doctor issues」的机制保证。
+ *
+ * 迁移源：cli/src/doctor/schema-reader.ts（collectVendorSchemaProfiles，105 行）
+ * + doctor 规则壳内联段（#1 effective stem 收集含 root ByInstance/标量兜底 + env 通道 +
+ * #9 realmSwitchHints + malls 注册表 + moduleResourceNeeds）。
+ *
+ * **装配源 = walkManifests 双通道产物**（声明性改进：sdk 模式模块（npmModules 登记、
+ * node_modules 消费）从 doctor 原单通道（listLocalModules = packages/* 本地扫描）的静默
+ * 忽略，转纳入检查面——与 toolkit 求值轴同源）。
+ *
+ * env 参数注入（默认 process.env——工厂边缘）：#1 的 env 通道兜底（wanda env 化形态：
+ * stem kebab → UPPER_SNAKE，env 键在场即视为已供给，不算缺文件）。
+ */
+interface PredicateIoInputs {
+    /** #1：effective 候选 stem → 缺文件（env 通道在场不算缺失） */
+    credentialFileMissing: Record<string, boolean>;
+    /** #2：凭据文件 stem → .type（无 type 则缺键） */
+    credentialFileType: Record<string, string | undefined>;
+    /** #6：credentialType → schema 引用文件缺失 */
+    credentialSchemaMissing: Record<string, boolean>;
+    /** #7：厂商 → configSchema properties 键集并集 */
+    vendorConfigKeys: Record<string, Set<string>>;
+    /** #7：厂商 → configSchema 引用缺失（跳过该厂商死配置判定） */
+    vendorConfigSchemaMissing: Record<string, boolean>;
+    /** #9：实现覆盖跨厂商提示文案（已成形——谓词直投） */
+    realmSwitchHints: string[];
+    /** #8：root instances 注册表 ids（在场才传；缺席 → 键检查跳过） */
+    malls?: string[];
+    /** #15-#16：已装模块 id → manifest contributes.resources 声明 id 集 */
+    moduleResourceNeeds: Record<string, ReadonlySet<string>>;
+}
+/** 装配全产物（= PredicateIoInputs + 供给/需求聚合——喂 evaluateIntegrationServices 的
+ *  非 contracts/integrations 入参全集，两消费方 spread 直投，零各自组装） */
+interface PredicateAssembly extends PredicateIoInputs {
+    suppliedProviders: Record<string, {
+        services: string[];
+        owner: string;
+        credentialType?: string;
+    }>;
+    demandedServices: Record<string, {
+        optional: boolean;
+        owners: string[];
+    }>;
+}
+/** stem → env 键（kebab → UPPER_SNAKE；与 SDK/provider-secret env 兜底同公式） */
+declare function refToEnvKey(stem: string): string;
+/**
+ * 装配谓词输入全集（供给/需求聚合 + I/O 档案）。
+ * @param walk 调用方已执行的 walkManifests 产物（目录枚举零缓存——每方法调用独立）
+ */
+declare function buildPredicateAssembly(appDir: string, walk: WalkManifestsResult, integrations: Record<string, unknown>, env?: Readonly<Record<string, string | undefined>>): PredicateAssembly;
+
+/**
+ * .tbox/app.json npmModules 读写（自 CLI manifest.ts 迁入——assembly 层目录知识单源）。
+ * npmModules 登记 = sdk 包双语义磁盘足迹之一（业务包 = packages/<id>/ 目录，sdk 包 = 本清单登记）。
+ * 本地模块（packages/module-*）不在 npmModules 登记——靠 tbox.module.json 约定发现。
+ */
+type ModuleMode = 'local' | 'sdk' | 'codegen';
+interface NpmModuleEntry {
+    /** 模块短 id（如 "module-member"），装配别名来源 */
+    id: string;
+    /** 发布源包名；codegen 的应用内身份由 id 派生为 @app/<id>，sdk 保持该包名 */
+    package: string;
+    /** 安装版本 */
+    version: string;
+    /** 分发模式 */
+    mode: ModuleMode;
+    /** 3-way merge 基线（codegen 模式） */
+    baseVersion?: string;
+}
+interface AppManifest {
+    templateVersion: string;
+    npmModules: NpmModuleEntry[];
+}
+declare function manifestPath(appDir: string): string;
+/** 读应用 manifest（缺席 → null；损坏/版本非法 → null——宽松解析与 CLI 语义一致） */
+declare function readAppManifest(appDir: string): AppManifest | null;
+/** 写应用 manifest（目录缺席物化；同步——写核心串行队列内使用） */
+declare function writeAppManifest(appDir: string, manifest: AppManifest): void;
+/** 小程序容器登记项（miniapp-container init 写入；与 npmModules 正交，不参与装配/doctor） */
+interface MiniappContainerEntry {
+    /** 平台 id：'alipay' / 'weapp'（= CLI platform 参数，展开目录名后缀） */
+    id: string;
+    /** 源包名（@tbox.cn/app-miniapp-container-*） */
+    package: string;
+    version: string;
+    /** 展开目录（相对应用根，如 'apps/miniapp-container-alipay'） */
+    dir: string;
+}
+interface AppManifestFull extends AppManifest {
+    /** 已初始化的小程序容器（可选——旧 manifest 无此字段，读侧归一为 []） */
+    miniappContainers?: MiniappContainerEntry[];
+}
+/** 读应用 manifest（完整面——miniappContainers 归一） */
+declare function readAppManifestFull(appDir: string): AppManifestFull | null;
+declare function upsertNpmModule(manifest: AppManifest, entry: NpmModuleEntry): AppManifest;
+declare function removeNpmModule(manifest: AppManifest, id: string): AppManifest;
+/** 登记小程序容器（按 id 去重替换；miniapp-container init 用） */
+declare function upsertMiniappContainer(manifest: AppManifestFull, entry: MiniappContainerEntry): AppManifestFull;
+/** 更新某模块的元数据（update 命令用：version / baseVersion） */
+declare function updateNpmModule(manifest: AppManifest, id: string, patch: Partial<Pick<NpmModuleEntry, 'version' | 'baseVersion'>>): AppManifest;
+/**
+ * 模块 id 合法性：小写字母/数字开头，单词段以单个中划线分隔（无连续/尾部中划线），
+ * 防路径穿越/目录注入，并保证 camelCaseId 派生别名唯一（a-b 与 a--b 不允许共存碰撞）。
+ */
+declare function isValidModuleId(id: string): boolean;
+/** 校验失败抛出（统一错误信息） */
+declare function assertValidModuleId(id: string, source: string): void;
+
+/** 桥源形态冻结：ProviderCatalog = contracts TIER0 形状（providers/services/credentialTypes） */
+interface BridgeProviderCatalog {
+    providers: Record<string, Record<string, {
+        provider: string;
+        implementation: string;
+        credentialType: string;
+        owner: string;
+        local?: boolean;
+        configSchema?: string;
+        credentialSchema?: string;
+        services: string[];
+    }>>;
+    services: Record<string, {
+        optional: boolean;
+        defaults: Array<{
+            provider: string;
+            implementation: string;
+        }>;
+        owners: string[];
+    }>;
+    credentialTypes: Record<string, {
+        owner: string;
+        credentialSchema?: string;
+    }>;
+}
+/** 富形态（工厂迁移面）：walkManifests 产物直通 */
+declare function loadProviderCatalogRaw(appDir: string): WalkCatalog;
+/** 桥源（形态冻结）：富形态 → 桥形状投影（demand meta title/description 剥离——桥面无此字段，
+ *  additive 差异声明见 app-sdk 桥 golden） */
+declare function loadProviderCatalog(appDir: string): BridgeProviderCatalog;
+interface ProviderServiceSchemas {
+    provider: string;
+    service: string;
+    /** 恒数组（H1——通常 1；多 impl = 升级窗口） */
+    implementations: Array<{
+        implementation: string;
+        credentialType: string;
+    }>;
+    integrationSchemas: {
+        configSchema: object | null;
+        credentialSchema: object | null;
+    };
+}
+type ProviderServiceSchemasResult = {
+    found: true;
+    detail: ProviderServiceSchemas;
+} | {
+    found: false;
+    reason: 'provider-not-found' | 'supply-not-found';
+};
+
+/**
+ * integrations.json 文件级读（C3-4 read）。
+ * 严格校验面（≥0.9）在场 → contracts parseIntegrationsConfig（assertNoInlineSecrets →
+ * 旧键直切防线 → zod strict）；缺席/降级 → 原文 JSON 透传（谓词宽松透传语义——
+ * doctor 读裸 JSON 先例；写路径门控在工厂边缘，读不阻断静态面）。
+ */
+interface ReadIntegrationsResult {
+    /** 解析产物（严格 zod 产物或原文 JSON；文件缺席 → null） */
+    config: Record<string, unknown> | null;
+    /** 严格校验是否已应用（false = 原文透传——<0.9 或未解析降级态） */
+    strict: boolean;
+    contracts: ResolvedContracts;
+}
+/** 文件级读（cache 注入优先；无 cache 直读——目录枚举零缓存约束不涉文件内容） */
+declare function readIntegrationsConfig(appDir: string, cache?: FileCache): Record<string, unknown> | null;
+/** 带严格校验的读（求值/写路径用——门控由工厂边缘断言，本函数按 strictValidation 分派） */
+declare function readIntegrationsStrict(appDir: string, cache?: FileCache): Promise<ReadIntegrationsResult>;
+
+/**
+ * 凭据双工件·写端（C3-4 credentials；FX-1c 拆分——F3 定序）：
+ * credentials / credentialsByInstance（body 唯一非文件字段）→ **纯派生 plan（零 I/O）**
+ * → 消费方（write.ts）ref 回填节点（先于 no-diff 判定）→ 严格校验通过后 `writeCredentialArtifacts`
+ * 落盘（dryRun → 零写盘 + existsSync 预览）。同 stem 已在场 → 重写 + overwrote:true。
+ * 孤儿凭据 = **写后对账**（扫描文件全量 credentialRef 引用 vs 凭据目录全集 →
+ * ORPHANED_CREDENTIAL warning——统一覆盖 DELETE 与 PUT 替换两类来源，只报告不自动清理，D9）。
+ */
+interface CredentialInput {
+    type: string;
+    values: Record<string, string>;
+}
+interface AppliedCredential {
+    stem: string;
+    ref: string;
+    overwrote: boolean;
+}
+/** 凭据工件计划项（纯派生产物——stem/ref 确定性；input 供落盘/校验消费） */
+interface PlannedCredential {
+    /** 实例级（credentialsByInstance）时在场；应用/服务级根凭据缺席 */
+    instanceId?: string;
+    stem: string;
+    ref: string;
+    input: CredentialInput;
+}
+interface OrphanIssue {
+    severity: 'warning';
+    code: 'ORPHANED_CREDENTIAL';
+    service?: string;
+    instance?: string;
+    message: string;
+}
+/** 凭据工件在场探测（dryRun 预览与对账共用） */
+declare function credentialArtifactExists(appDir: string, stem: string): boolean;
+/** 孤儿凭据写后对账（D9）：凭据目录全集 − integrations.json 全量引用 = 孤儿（只报告不清理） */
+declare function reconcileOrphanCredentials(appDir: string): OrphanIssue[];
+
+/**
+ * 写核心（C3-4 write；FX-1c 管线重排——F3 九步定序 + D-B2 语义 + F4 输入扩位）：
+ * PUT = 节点全量替换（三同构——body ≡ 文件节点；三 PUT 端点无例外）。
+ *
+ * 九步定序（applyApp / applyService 同构）：
+ *  1 输入约束（assertSafeNames 值位 + assertSafeInstanceKeys map 键位——F4）
+ *  2 合并 node → next；文件缺席 → 骨架物化（R13 语义翻转提示入 issues）
+ *  3 凭据校验链（type 匹配 400 + credentialSchema ajv 字段级——schema 缺席宽松；dryRun 也跑）
+ *  4 凭据 stem/ref **纯派生**（plan*——零 I/O）+ ref 回填节点（**先于 no-diff**：
+ *    node 缺 ref + 带 credentials → 节点变化 → 全量写；node 已含同 ref → 节点不变 → 纯凭据写）
+ *  5 noDiff（**深度结构等价**，非 stringify）；hasCredentialInput
+ *  6 noDiff && 无凭据输入 → 短路 written:false
+ *  7 严格整文档校验（contracts parseIntegrationsConfig——触发 = !noDiff ∥ 有凭据输入）
+ *  8 凭据工件落盘（**后置于校验通过**——防「凭据已写 + zod 拒绝」不一致态；
+ *    dryRun → writeCredentialArtifacts 零写盘 + existsSync 预览）
+ *  9 finalize：written = integrations 实写 ∥ 凭据实写（**D-B2**）；files 分列两类路径；
+ *    restartScheduled = written && onApplied（凭据影响 boot 装配——重启正当）；写后缓存失效
+ * 归一化：N1 模块节点 {} → 删 domains[键]；N3 服务节点 {} 不归一化（显式通配激活 = 合法 TIER0 态）；
+ * N2 已随 ?instance= 退役。dryRun（PUT only）：复读完整管线不落盘不排程。
+ * DELETE：节点移除 + 孤儿凭据写后对账（覆盖 DELETE 与 PUT 替换两类来源，只报告不清理——D9）。
+ * 并发：进程内串行（per-factory promise chain 由工厂持有——本模块假设单飞调用）。
+ */
+interface SaveResult {
+    written: boolean;
+    restartScheduled: boolean;
+    files: string[];
+    credentials: Array<{
+        stem: string;
+        ref: string;
+        overwrote: boolean;
+    }>;
+    issues: IntegrationServiceIssue[];
+}
+interface WriteOptions {
+    dryRun?: boolean;
+    /** body 唯一非文件字段（真值直落 config/credentials/，派生 ref 回填本节点） */
+    credentials?: CredentialInput;
+    credentialsByInstance?: Record<string, CredentialInput>;
+}
+interface WriteCoreOptions {
+    onApplied?: () => void;
+    cache?: FileCache;
+}
+/** 深度结构等价（非 stringify——键序陷阱误判 diff 防线） */
+declare function deepEqual(a: unknown, b: unknown): boolean;
+interface WriteCore {
+    /** 预热（工厂创建/写前调用——严格校验缓存就绪；memoized resolver 后续 1 stat 级） */
+    warmup(): Promise<void>;
+    /** PUT /app/integration（root 节点全集） */
+    applyApp(node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
+    /** PUT /modules/:module/integration（domains 换算；N1 {} 删域键） */
+    applyModule(moduleId: string, node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
+    /** PUT /services/:service/integration（整节点含 instances map；N3 {} 不归一化） */
+    applyService(service: string, node: Record<string, unknown>, opts?: WriteOptions): SaveResult;
+    /** DELETE /services/:service/integration（恒整节点；幂等；无预演） */
+    deleteService(service: string): SaveResult;
+    /** 模块服务域键（module → domains 键 = 服务集派生域键集 upsert 位） */
+    moduleDomainKey(moduleId: string): string | undefined;
+}
+declare function createWriteCore(appDir: string, opts?: WriteCoreOptions): WriteCore;
+
+/**
+ * mock 槽绑定生成器（自 CLI mock-bindings.ts 迁入；provider 拆包 F3 收敛 · B 方案；integrations v4 零拓扑形态）：
+ * 应用内 config/integrations.json 缺席时，从已装模块 manifest 的 local:true 槽派生全槽 mock 绑定。
+ *
+ * 语义边界（零改动迁移）：
+ * - 缺席即跳过、永不覆盖（在场文件 = 用户/素材真源，生成器零侵入）；
+ * - 只绑 local:true 槽（真厂商 provider 永不自动绑定）；
+ * - sync 不触发（add = 新事实进入体系，sync = 状态重放）。
+ * 迁移顺带修复：writeFileSync → writeAtomic（原子写；H5）。
+ * 模块发现改 walkManifests（单源——CLI listLocalModules 并入）。
+ */
+interface MockBindingsResult {
+    generated: boolean;
+    reason: 'in-place' | 'no-local-slots' | 'generated';
+    /** 本次生成（或在场文件阻断时的空集）涉及的 local 槽服务名 */
+    services: string[];
+}
+declare function ensureMockBindings(appDir: string): MockBindingsResult;
+
+/**
+ * AppToolkitError（领域 6 码 + 壳层 2 码分界——toolkit 只产领域码）：
+ * VALIDATION_FAILED(400) / SERVICE_NOT_FOUND(404) / MODULE_NOT_FOUND(404) /
+ * PROVIDER_NOT_FOUND(404) / SUPPLY_NOT_FOUND(404) / CONTRACTS_NOT_RESOLVED(503)。
+ * AUTH_REQUIRED / ROUTE_NOT_FOUND 为 HTTP 层事实（壳层产生）——6 + 2 = 8（api.md §5）。
+ *
+ * **name 约定（仓规约束①——mangle 安全真源 process note 2026-09-11-publish-dist-minify）**：
+ * 构造器必须字符串字面量赋值 `this.name = 'AppToolkitError'`（禁 `this.name = X.name` binding
+ * 形态——src 态守卫不可见、mangle 后静默漂移）；守卫 = tests/error-name-safety.test.ts（C4）。
+ * 消费面属性分发（.httpStatus/.code/.fields——比 err.name 分发更宽裕）。
+ */
+type AppToolkitErrorCode = 'VALIDATION_FAILED' | 'SERVICE_NOT_FOUND' | 'MODULE_NOT_FOUND' | 'PROVIDER_NOT_FOUND' | 'SUPPLY_NOT_FOUND' | 'CONTRACTS_NOT_RESOLVED';
+declare class AppToolkitError extends Error {
+    readonly code: AppToolkitErrorCode;
+    readonly httpStatus: number;
+    readonly fields?: string[];
+    constructor(code: AppToolkitErrorCode, httpStatus: number, message: string, fields?: string[]);
+}
+/** CONTRACTS_NOT_RESOLVED 三分支 message（N1 构建指引——api.md 错误信封示例） */
+declare function contractsNotResolvedMessage(contracts: {
+    version: string | null;
+    strictValidation: boolean;
+    notes: readonly string[];
+}): string;
+
+/**
+ * DTO 全量（api.md §3 字段级单源落源——28 类型；演进 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/…——防复活）。
+ */
+/** contracts 求值五态原样（EffectiveServiceResolution.status） */
+type ServiceStatus = 'ok' | 'service-not-configured' | 'instance-not-found' | 'instance-disabled' | 'binding-unresolved';
+/** 四配置层（instance 为 map 字段层） */
+type BindingLayer = 'app' | 'module' | 'service' | 'instance';
+/** 纯模块清单（无 services——卡片展开走 /modules/:m） */
+interface ModulesView {
+    modules: ModuleDeclaration[];
+}
+interface ModuleDeclaration {
+    /** install id（packages/ 目录名 / .tbox/app.json entry.id） */
+    id: string;
+    /** 包名 */
+    name: string;
+    title: string;
+    description: string;
+}
+/** 服务需求声明（模块 demand 单元；defaults 唯一落位 ServiceDetail） */
+interface ServiceDemand {
+    service: string;
+    /** manifest demand meta；缺席 UI 回退 service id */
+    title?: string;
+    description?: string;
+    /** demand optional !== false（多模块 OR 聚合见 resolution echo） */
+    required: boolean;
+}
+/** GET /modules/:module（模块静态一站式 · PUT 读对偶） */
+interface ModuleDetailView {
+    /** domains[换算键] 节点原值；未配置 = null */
+    integration: ModuleIntegrationNode | null;
+    /** 本模块 demand（卡片展开 + 编辑器静态上下文自足） */
+    services: ServiceDemand[];
+}
+/** GET /app（应用静态视图：平台服务 + root 原值） */
+interface AppView {
+    /** 平台服务 id（服务词汇 − 模块占用；owner/标题 UI 按首点段派生） */
+    services: string[];
+    /** root 节点原值；文件缺席 = null */
+    integration: AppIntegrationNode | null;
+}
+/** GET /services/:service（服务静态单体） */
+interface ServiceDetail extends ServiceDemand {
+    /** manifest 预填（唯一落位） */
+    defaults: Array<{
+        provider: string;
+        implementation: string;
+    }>;
+    /** 文件 services[s] 逐字原值（编辑预填源）；无声明 = null */
+    integration: ServiceIntegrationNode | null;
+    /** 供给该服务的厂商名单（catalog 静态切片——picker 数据源） */
+    suppliedBy: string[];
+}
+/** GET /service-resolutions（批量求值 · 唯一求值集合面） */
+interface ServiceResolutionsView {
+    /** P6 contracts echo（仅求值轴两端点携带） */
+    contracts: ContractsResolution;
+    /** 键集 = 服务词汇 ∪ 已配置（模块/平台/孤儿全量） */
+    resolutions: Record<string, ServiceResolutionEntry>;
+    /** 谓词全量（doctor 同源；恒全量——subset 消费方客户端过滤） */
+    issues: IntegrationIssue[];
+}
+/** 求值摘要单元（行内嵌；P14 单一形状） */
+interface ServiceResolutionEntry {
+    /** 默认实例口径（normalizeInstances 委托） */
+    status: ServiceStatus;
+    statusMessage?: string;
+    /** 最特异声明层厂商名（跨层事实） */
+    provider?: string;
+    /** provider 在场时在场：(provider, service) ∈ 供给关系 */
+    supplied?: boolean;
+    /** owner 模块 install id；平台服务/孤儿缺席 */
+    module?: string;
+    /** demand echo（OR 聚合）；平台/孤儿恒 false；集成就绪判定单源（§7） */
+    required?: boolean;
+}
+/** 求值完整结构（extends = 列表项 ⊂ 单体的编译期保证——P14） */
+interface ServiceResolution extends ServiceResolutionEntry {
+    /** P4 枚举规则（全实例逐一；默认实例求值 = 摘要基，不重复头部） */
+    instances: ResolvedInstance[];
+    inheritance: Array<{
+        layer: BindingLayer;
+        provider?: string;
+        implementation?: string;
+    }>;
+}
+/** GET /service-resolutions/:service（求值单体） */
+interface ServiceResolutionDetail {
+    contracts: ContractsResolution;
+    resolution: ServiceResolution;
+    /** service === :service 过滤子集 */
+    issues: IntegrationIssue[];
+}
+/** root 节点 */
+interface AppIntegrationNode {
+    /** 恒字符串（app/module 级无内联形态） */
+    provider?: string;
+    config?: Record<string, unknown>;
+    configByInstance?: Record<string, Record<string, unknown>>;
+    credentialRef?: string;
+    credentialRefByInstance?: Record<string, string>;
+    /** 整组替换（id 字符集受输入约束①） */
+    instances?: Array<{
+        id: string;
+        name: string;
+        attributes?: Record<string, unknown>;
+    }>;
+    defaultInstanceId?: string | null;
+}
+/** AppIntegrationNode 键集单源（runtime const——write applyApp 全量替换白名单
+ *  （缺席根键删除；services/domains/modules 域不在其中）+ views/app 投影（GET 预填 ≡ PUT body，
+ *  D21/L1——文件含 services/domains 但 root 节点投影只含本键集）） */
+declare const APP_INTEGRATION_NODE_KEYS: readonly ["provider", "config", "configByInstance", "credentialRef", "credentialRefByInstance", "instances", "defaultInstanceId"];
+/** 模块域节点（恒字符串 provider——域层无凭据位，契约事实） */
+interface ModuleIntegrationNode {
+    provider?: string;
+    config?: Record<string, unknown>;
+}
+/** services[s] 整节点 */
+interface ServiceIntegrationNode {
+    /** 对象 = 自定义 API（仅槽级，P2） */
+    provider?: string | InlineVendorDeclaration;
+    /** 内联 provider 时必填 */
+    implementation?: string;
+    config?: Record<string, unknown>;
+    credentialRef?: string;
+    /** 键 = instanceId / '*'（随节点全量替换） */
+    instances?: Record<string, ServiceInstanceNode>;
+}
+/** services[s].instances[k] 节点 */
+interface ServiceInstanceNode {
+    /** provider 恒字符串（内联仅槽级合法） */
+    provider?: string;
+    implementation?: string;
+    config?: Record<string, unknown>;
+    credentialRef?: string;
+    /** 缺省 true；false → instance-disabled */
+    enabled?: boolean;
+}
+interface InlineVendorDeclaration {
+    provider: string;
+    credentialType: string;
+    configSchema?: string;
+}
+interface CredentialValues {
+    type: string;
+    values: Record<string, string>;
+}
+interface ResolvedInstance {
+    /** 注册表 id；'*' = 通配 */
+    instanceId: string;
+    status: ServiceStatus;
+    /** 逐实例诊断（binding-unresolved 等直投） */
+    statusMessage?: string;
+    /** 该实例合并结果 */
+    effective?: EffectiveBinding;
+    /** 掩码回显 */
+    credential?: CredentialEcho;
+}
+/** GET /providers：厂商基本信息 */
+interface ProvidersView {
+    providers: ProviderEntry[];
+}
+interface ProviderEntry {
+    provider: string;
+    /** Mock 旗标（provider 级聚合） */
+    local: boolean;
+    /** 供给声明来源包名 */
+    owner: string;
+}
+/** GET /providers/:provider：供给足迹 */
+interface ProviderDetail {
+    provider: string;
+    local: boolean;
+    owner: string;
+    /** per (provider, service) 保真，同厂商异构合法；★ implementations 恒数组（H1——
+     *  多元素 = 升级窗口，UI 出 impl 选择器，PUT 显式钉版） */
+    services: Record<string, {
+        implementations: Array<{
+            implementation: string;
+            credentialType: string;
+        }>;
+    }>;
+}
+/** GET /providers/:p/services/:s：表单 schema 唯一暴露面 */
+interface ProviderServiceDetail {
+    provider: string;
+    service: string;
+    /** ★ 恒数组（通常 1） */
+    implementations: Array<{
+        implementation: string;
+        credentialType: string;
+    }>;
+    /** 厂商集成该服务的表单 schema（integration 域专属） */
+    integrationSchemas: {
+        /** raw draft 2020-12 原文零转换；供给在场未声明 = null（mock 合法）；解析自默认 impl */
+        configSchema: object | null;
+        credentialSchema: object | null;
+    };
+}
+interface EffectiveBinding {
+    /** custom 时 provider = 内联声明厂商名 */
+    provider: string;
+    implementation: string;
+    config?: Record<string, unknown>;
+    /** 'secret://{stem}' */
+    credentialRef?: string;
+    layer: BindingLayer;
+}
+/** GET 永无真值 */
+interface CredentialEcho {
+    /** credentialType（manifest 对齐） */
+    type: string;
+    /** 'secret://{stem}' */
+    ref: string;
+    /** 'config/credentials/{stem}.json' */
+    file: string;
+    /** 前 2 字符 + '****'；≤4 字符全掩码；null = 缺字段 */
+    masked: Record<string, string | null>;
+}
+interface ContractsResolution {
+    version: string | null;
+    evaluation: boolean;
+    strictValidation: boolean;
+    notes: string[];
+}
+/** 字段级真源 = 谓词结构化输出（H7） */
+interface IntegrationIssue {
+    severity: 'error' | 'warning';
+    /** 枚举单源 = 谓词文件头检查族编号映射（additive-only） */
+    code: string;
+    message: string;
+    service?: string;
+    module?: string;
+    instance?: string;
+}
+
+/**
+ * 视图装配共享上下文（五投影共用；目录枚举零缓存——walkManifests 每次调用执行）。
+ * 域前缀换算（service → 首点段）= 本地一行 helper（文件格式词汇，静态面零 contracts 依赖）。
+ */
+interface ViewContext {
+    appDir: string;
+    cache?: FileCache;
+}
+interface ViewSnapshot {
+    appDir: string;
+    walk: WalkManifestsResult;
+    catalog: WalkCatalog;
+    integrations: Record<string, unknown> | null;
+    contracts: ResolvedContracts;
+}
+
+/**
+ * 需求轴/模块静态投影（views/modules；C4）。静态端点结构性零求值（铁律 #3——
+ * 无 resolution/issues/contracts 键，永不 503）。
+ */
+/** GET /modules：纯模块清单（demand 不在——卡片展开 = GET /modules/:m） */
+declare function loadModulesView(snapshot: ViewSnapshot): {
+    modules: ModuleDeclaration[];
+};
+/** 域键换算（模块服务集派生域键集；单域 = 该域，多域/零域 = 模块 id——与 write.moduleDomainKey 同约定） */
+declare function moduleDomainKeyOf(services: ServiceDemand[], moduleId: string): string;
+/** GET /modules/:module：模块静态一站式（integration 节点原值 + demand；PUT 读对偶） */
+declare function loadModuleDetailView(snapshot: ViewSnapshot, moduleId: string): ModuleDetailView;
+
+/**
+ * 应用静态投影（views/app；C4；FX-1c B10——root 节点投影修）。
+ * /app = 平台服务 + root 节点原值（纯静态，D12）：
+ * services = 服务词汇 − 模块占用（裸 string[]——owner/标题 UI 按首点段派生，F2）；
+ * 平台服务状态不在此（→ /service-resolutions）；模块服务不在此（→ /modules/:m）。
+ * integration = **root 节点投影**（APP_INTEGRATION_NODE_KEYS——D21/L1：GET 预填 ≡ PUT body；
+ * 文件另含 services/domains/modules 域键，不进 root 节点投影——原实现整文件透传，
+ * PUT 回会级联写回域键）；文件缺席 = null，文件在场 → 投影对象（可为空）。
+ */
+declare function loadAppView(snapshot: ViewSnapshot): AppView;
+
+/**
+ * 服务静态单体投影（views/service-detail；C4）。求值数据不在此（→ /service-resolutions/:service）。
+ * SERVICE_NOT_FOUND 判据 = 服务词汇 ∪ 已配置（P9——词汇成员零 demand/供给/config 仍 200）。
+ */
+declare function loadServiceDetailView(snapshot: ViewSnapshot, service: string): ServiceDetail;
+
+/**
+ * 供给轴投影（views/providers；C4）。供给关系三切片（P5）：
+ * 名单 = /providers（基本信息）· 足迹 = /providers/:p（implementations[] 保真）·
+ * 表单 = /providers/:p/services/:s（组合单体——schema 唯一暴露面 P10）。
+ * 静态端点零求值（铁律 #3）。
+ */
+/** GET /providers：厂商基本信息（供给足迹不在本端点 → /providers/:p） */
+declare function loadProvidersView(snapshot: ViewSnapshot): ProvidersView;
+/** GET /providers/:provider：供给足迹（implementations 恒数组——H1 多实现钉版数据源） */
+declare function loadProviderDetailView(snapshot: ViewSnapshot, provider: string): ProviderDetail;
+/** 组合单体（GET /providers/:p/services/:s）：catalog 供给与槽级内联声明统一解析（P10/P11） */
+declare function loadProviderServiceDetailView(snapshot: ViewSnapshot, provider: string, service: string): ProviderServiceDetail;
+
+/** P14 单源摘要函数：/service-resolutions map 值 ≡ /service-resolutions/:s 的 resolution 摘要基 */
+declare function resolveServiceSummary(service: string, snapshot: ViewSnapshot): ServiceResolutionEntry;
+/** 批量求值（键集 = 服务词汇 ∪ 已配置；?service= 过滤语义——未知键缺席；issues 恒全量） */
+declare function loadServiceResolutionsView(snapshot: ViewSnapshot, issues: IntegrationIssue[], filter?: string[]): ServiceResolutionsView;
+/** 求值单体（完整结构 instances + inheritance + 过滤 issues；P14 extends 结构保证） */
+declare function loadServiceResolutionDetail(service: string, snapshot: ViewSnapshot, allIssues: IntegrationIssue[]): ServiceResolutionDetail;
+
+/**
+ * createAppToolkit（C4 工厂）：22 方法 = 9 读（HTTP 直通）+ 4 写（HTTP 直通）+ 9 迁移面（Internals）。
+ * 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/ 机制层保持纯函数。
+ *
+ * 并发：进程内写串行（per-factory promise chain）+ 原子写 + 写后本实例缓存即刻失效（D26）。
+ * onApplied（D7）：toolkit 判定「需要重启」（实际落盘且非 dryRun/no-diff）→ 调用一次 +
+ * restartScheduled 回填——通知闭包非控制，执行者恒为宿主 RunManager；CLI 不传恒 false。
+ */
+interface AppToolkitOptions {
+    /** 写成功（实际落盘且非 dryRun/no-diff）→ 调用一次（宿主闭包内防抖/守卫）；CLI 不传恒 false */
+    onApplied?: () => void;
+}
+/** ── HTTP 直通面（9 读；L1 镜像律：方法名 = load + URL 资源段）── */
+interface AppToolkitRead {
+    loadModules(): Promise<ModulesView>;
+    loadModule(moduleId: string): Promise<ModuleDetailView>;
+    loadApp(): Promise<AppView>;
+    loadService(service: string): Promise<ServiceDetail>;
+    loadServiceResolutions(services?: string[]): Promise<ServiceResolutionsView>;
+    loadServiceResolution(service: string): Promise<ServiceResolutionDetail>;
+    loadProviders(): Promise<ProvidersView>;
+    loadProvider(provider: string): Promise<ProviderDetail>;
+    loadProviderService(provider: string, service: string): Promise<ProviderServiceDetail>;
+}
+/** ── HTTP 直通面（4 写；body ≡ 文件节点全量替换；DELETE 无 dryRun/无 options）── */
+interface AppToolkitWrite {
+    writeAppIntegration(node: AppIntegrationNode, o?: {
+        dryRun?: boolean;
+        credentials?: {
+            type: string;
+            values: Record<string, string>;
+        };
+        credentialsByInstance?: Record<string, {
+            type: string;
+            values: Record<string, string>;
+        }>;
+    }): Promise<SaveResult>;
+    writeModuleIntegration(moduleId: string, node: ModuleIntegrationNode, o?: {
+        dryRun?: boolean;
+    }): Promise<SaveResult>;
+    writeServiceIntegration(service: string, node: ServiceIntegrationNode, o?: {
+        dryRun?: boolean;
+        credentials?: {
+            type: string;
+            values: Record<string, string>;
+        };
+        credentialsByInstance?: Record<string, {
+            type: string;
+            values: Record<string, string>;
+        }>;
+    }): Promise<SaveResult>;
+    deleteServiceIntegration(service: string): Promise<SaveResult>;
+}
+/** ── Internals（9，非 HTTP 面；L3 宾语消歧：Integration=节点级 / Config=文件级）── */
+interface AppToolkitInternals {
+    /** 逃生舱：正常路径无需调用（Freshness Contract 自动）；测试/宿主特殊场景 */
+    invalidate(): void;
+    resolveContracts(): Promise<ResolvedContracts>;
+    /** 四产物（枚举零缓存——契约机制载体） */
+    walkManifests(): WalkManifestsResult;
+    parseModuleDescriptor(raw: unknown): ReturnType<typeof parseModuleDescriptor>;
+    /** 富形态（≠ 包级桥源 loadProviderCatalog，双形态有意） */
+    loadProviderCatalogRaw(): ReturnType<typeof loadProviderCatalogRaw>;
+    /** 文件级读（doctor/migrate；宽松透传——strict 校验归门控面） */
+    readIntegrationsConfig(): Promise<Record<string, unknown> | null>;
+    /** 文件级整写（provider-migrate；门控同款） */
+    writeIntegrationsConfig(config: Record<string, unknown>): Promise<void>;
+    ensureMockBindings(): Promise<ReturnType<typeof ensureMockBindings>>;
+    /** 谓词单源（contracts 注入签名；结构化输出） */
+    evaluateIntegrationServices(input: Omit<Parameters<typeof evaluateIntegrationServices>[0], 'contracts'>): Promise<IntegrationServiceIssue[]>;
+}
+type AppToolkit = AppToolkitRead & AppToolkitWrite & AppToolkitInternals;
+declare function createAppToolkit(appDir: string, options?: AppToolkitOptions): AppToolkit;
+
+export { APP_INTEGRATION_NODE_KEYS, type AppIntegrationNode, type AppManifest, type AppManifestFull, type AppToolkit, AppToolkitError, type AppToolkitErrorCode, type AppToolkitInternals, type AppToolkitOptions, type AppToolkitRead, type AppToolkitWrite, type AppView, type AppliedCredential, type BindingLayer, type BridgeProviderCatalog, type CardContrib, type ContractsResolution, type CredentialEcho, type CredentialFile, type CredentialInput, type CredentialValues, type DeclaredModuleInfo, type EffectiveBinding, type EnvExpansionResult, type EvaluationExports, type FileCache, type InlineVendorDeclaration, type IntegrationIssue, type IntegrationServiceIssue, type IntegrationServicePredicateInput, type MiniappContainerEntry, type MockBindingsResult, type ModuleDeclaration, type ModuleDescriptor, type ModuleDetailView, type ModuleIntegrationNode, type ModuleMode, type ModulesView, type NpmModuleEntry, type OrphanIssue, type ParseModuleResult, type PlannedCredential, type PredicateAssembly, type PredicateContracts, type PredicateIoInputs, type ProviderDetail, type ProviderEntry, type ProviderServiceDetail, type ProviderServiceSchemas, type ProviderServiceSchemasResult, type ProviderSlotContrib, type ProvidersView, type ReadIntegrationsResult, type ResolvedContracts, type ResolvedInstance, type ResolvedModule, type ResourceNeedContrib, SAFE_NAME_PATTERN, type SaveResult, type ServiceDemand, type ServiceDetail, type ServiceInstanceNode, type ServiceIntegrationNode, type ServiceNeedContrib, type ServiceResolution, type ServiceResolutionDetail, type ServiceResolutionEntry, type ServiceResolutionsView, type ServiceStatus, type StemInput, type SupplyLookup, type ViewContext, type ViewSnapshot, type WalkCatalog, type WalkManifestsResult, type WalkModuleInfo, type WalkProviderEntry, type WriteCore, type WriteCoreOptions, type WriteOptions, assertValidModuleId, buildPredicateAssembly, checkInstanceKeys, collectDeclaredModules, contractsNotResolvedMessage, createAppToolkit, createFileCache, createWriteCore, credentialArtifactExists, deepEqual, deriveStem, ensureDir, ensureMockBindings, evaluateIntegrationServices, expandEnvVars, extractModuleIdFromSource, invalidateContractsResolver, isControlledInlineProvider, isValidModuleId, loadAppView, loadModuleDetailView, loadModulesView, loadProviderCatalog, loadProviderCatalogRaw, loadProviderDetailView, loadProviderServiceDetailView, loadProvidersView, loadServiceDetailView, loadServiceResolutionDetail, loadServiceResolutionsView, manifestPath, maskCredentialValues, moduleDependencySchema, moduleDescriptorSchema, moduleDomainKeyOf, pageContribSchema, parseModuleDescriptor, providerSlotContribSchema, readAppManifest, readAppManifestFull, readCredentialFile, readIntegrationsConfig, readIntegrationsStrict, reconcileOrphanCredentials, refToEnvKey, removeNpmModule, resolveContractsForApp, resolveContractsForApp as resolveContractsForAppExport, resolveServiceSummary, resourceNeedContribSchema, serviceNeedContribSchema, stemToFilePath, stemToRef, tabContribSchema, updateNpmModule, upsertMiniappContainer, upsertNpmModule, walkManifests, writeAppManifest, writeAtomic, writeCredentialFile };