@sns-parse/core 0.4.0-alpha.9 → 0.6.0-alpha.1

package/lib/engine/runtime.js

@@ -4,14 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRuntime = createRuntime;
-exports.createCoreExtensions = createCoreExtensions;
 /**
- * 运行时构建（自宿主 runtime 下沉，平台无关）。
+ * 运行时装配（本文件在 core 内，平台无关）。
  *
- * 平台定义列表（defs）由调用方传入：
- * - koishi 兼容层传内置 BUILTIN_PLATFORMS（本地 definitions）
- * - CLI 传 collectPlatformDefinitions()（已安装的 @sns-parse/platform-*）
- * 默认扩展实现同样注入：koishi 传含 NSFW 的完整默认实现，CLI 传 createCoreExtensions()。
+ * 平台定义列表（defs）由宿主按已加载平台插件声明注入：
+ * - koishi 兼容层：collectPlatformDefinitions(anchor)（聚合包 + 粒度包并集）
+ * - CLI：collectPlatformDefinitions()
+ * 工作流阶段基线在 createDefaultPipeline()，扩展经 WorkflowExtension.setup(hooks) 注入/替换。
+ * core 不依赖任何扩展包、不含扩展实现。
  */
 const axios_1 = __importDefault(require("axios"));
 const https_proxy_agent_1 = require("https-proxy-agent");
@@ -20,13 +20,11 @@ const cache_1 = require("../utils/cache");
 const field_mapping_1 = require("../utils/field-mapping");
 const platform_config_1 = require("./platform-config");
 const gateway_1 = require("./gateway");
-const merge_1 = require("../utils/merge");
-const gif_1 = require("../utils/gif");
-const translate_1 = require("./translate");
+const default_1 = require("../workflow/default");
 function createRuntime(source, config, opts = {}) {
     const host = (0, host_1.createHost)(source);
     const ctx = host.context;
-    const extensions = { ...(opts.defaultExtensions || {}), ...(host.extensions || {}) };
+    const extensions = [...(opts.extensions || []), ...(host.extensions || [])];
     const dedupCache = new cache_1.SimpleLRUCache(1000, config.deduplicationInterval * 1000);
     const cacheTTL = (config.cacheTTL || 600) * 1000;
     const urlCacheLocal = new cache_1.SimpleLRUCache(500, cacheTTL);
@@ -64,7 +62,12 @@ function createRuntime(source, config, opts = {}) {
         axiosConfig.proxy = false;
     }
     const http = axios_1.default.create(axiosConfig);
-    return {
+    const pipeline = (0, default_1.createDefaultPipeline)(null);
+    for (const ext of extensions) {
+        if (ext && typeof ext.setup === 'function')
+            ext.setup(pipeline);
+    }
+    const runtime = {
         host,
         ctx,
         config,
@@ -76,15 +79,11 @@ function createRuntime(source, config, opts = {}) {
         contentDedupCache,
         customPlatforms,
         allRules,
+        defs,
         dedicatedApis,
         extensions,
+        pipeline,
     };
-}
-/** core 自带扩展实现（无 NSFW：CLI / 嵌入式宿主用；koishi 层在其上叠加 NSFW） */
-function createCoreExtensions() {
-    return {
-        mergeImages: merge_1.mergeImages,
-        mp4ToGif: gif_1.mp4ToGif,
-        translate: translate_1.translateText,
-    };
+    pipeline.rt = runtime;
+    return runtime;
 }

package/lib/engine/translate.d.ts

@@ -1,15 +1,10 @@
 /**
- * 推文翻译：Google gtx 免费端点（无 Key、GET-only）。
- *
- * X 网页端的 Grok 翻译走私有通道（translations/show.json 已 404，GraphQL
- * 仅返回 is_translatable 标志），无公开端点可调，故用通用翻译源兜底。
- * 译文存入 ParsedData.translation，经 ${翻译} 模板变量展示，空值行自动隐藏。
+ * 语种决策与展示工具（纯函数，属调度/编排层的共享工具）。
+ * 翻译实现（Google gtx + MyMemory）在 @sns-parse/ext-translate；
+ * 平台原生翻译（如 X 网页同源 Grok）在对应平台包的 translate 钩子。
  */
-import type { ParserRuntime } from './runtime';
 import type { TranslateResult } from '../extensions';
 export type { TranslateResult };
-/** 判断是否需要跳过翻译（目标语系与推文语种相同 / 无语言内容） */
+/** 判断是否需要跳过翻译（目标语种与源语种相同 / 无文本内容） */
 export declare function shouldSkipTranslate(tweetLang: string | undefined, target: string): boolean;
 export declare function langName(code?: string): string;
-/** 翻译文本；失败返回 null（调用方保持无译文继续发送）。gtx 优先，MyMemory 兜底 */
-export declare function translateText(rt: ParserRuntime, text: string, target: string, sourceLang?: string): Promise<TranslateResult | null>;

package/lib/engine/translate.js

@@ -2,15 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.shouldSkipTranslate = shouldSkipTranslate;
 exports.langName = langName;
-exports.translateText = translateText;
-const logger_1 = require("../logger");
-/** 判断是否需要跳过翻译（目标语系与推文语种相同 / 无语言内容） */
+/** 判断是否需要跳过翻译（目标语种与源语种相同 / 无文本内容） */
 function shouldSkipTranslate(tweetLang, target) {
     if (!tweetLang)
         return false;
     const l = tweetLang.toLowerCase();
     if (l === 'zxx' || l === 'und')
-        return l === 'zxx'; // zxx=无语言内容；und=未定则仍尝试
+        return l === 'zxx'; // zxx=无文本内容；und=未识别可尝试
     const t = target.toLowerCase();
     if (t === 'zh')
         return l === 'zh' || l.startsWith('zh-');
@@ -20,7 +18,7 @@ function shouldSkipTranslate(tweetLang, target) {
         return l === 'en';
     return l === t;
 }
-/** 常见语种代码 → 中文名（未知代码原样展示） */
+/** 语种代码 → 展示名（未知返回原代码） */
 const LANG_NAMES = {
     fr: '法语', ja: '日语', ko: '韩语', en: '英语', zh: '中文', es: '西班牙语', pt: '葡萄牙语',
     de: '德语', ru: '俄语', ar: '阿拉伯语', it: '意大利语', th: '泰语', vi: '越南语',
@@ -37,71 +35,3 @@ function langName(code) {
         return '';
     return LANG_NAMES[base] || code;
 }
-/** 翻译文本；失败返回 null（调用方保持无译文继续发送）。gtx 优先，MyMemory 兜底 */
-async function translateText(rt, text, target, sourceLang) {
-    if (!text)
-        return null;
-    const out = await viaGtx(rt, text, target);
-    if (out)
-        return { text: out, provider: 'Google' };
-    const backup = await viaMyMemory(rt, text, target, sourceLang);
-    if (backup)
-        return { text: backup, provider: 'MyMemory' };
-    return null;
-}
-/** Google gtx 免费端点（无 Key；sl=auto 自动检测源语种） */
-async function viaGtx(rt, text, target) {
-    const url = 'https://translate.googleapis.com/translate_a/single' +
-        `?client=gtx&sl=auto&dt=t&tl=${encodeURIComponent(target)}` +
-        `&q=${encodeURIComponent(text.slice(0, 2000))}`;
-    try {
-        const res = await rt.http.get(url, {
-            timeout: 15000,
-            headers: { 'User-Agent': rt.config.userAgent },
-        });
-        const data = res.data;
-        // gtx 响应形如 [[["译文","原文",null,null,10]],null,"fr",...]
-        if (Array.isArray(data?.[0])) {
-            const out = data[0].map((seg) => (typeof seg?.[0] === 'string' ? seg[0] : '')).join('').trim();
-            if (out)
-                return out;
-        }
-        (0, logger_1.debugLog)('gtx 翻译响应结构异常，尝试备用通道');
-        return null;
-    }
-    catch (e) {
-        (0, logger_1.debugLog)(`gtx 翻译失败：${e?.message || e}`);
-        return null;
-    }
-}
-/** MyMemory 备用（免费无 Key；需已知源语种，不支持 auto） */
-async function viaMyMemory(rt, text, target, sourceLang) {
-    const sl = normalizeLang(sourceLang);
-    if (!sl)
-        return null;
-    const tl = target.toLowerCase();
-    const url = 'https://api.mymemory.translated.net/get' +
-        `?q=${encodeURIComponent(text.slice(0, 500))}&langpair=${encodeURIComponent(sl + '|' + tl)}`;
-    try {
-        const res = await rt.http.get(url, { timeout: 15000, headers: { 'User-Agent': rt.config.userAgent } });
-        const out = res.data?.responseData?.translatedText;
-        if (typeof out === 'string' && out.trim() && !/^MYMEMORY WARNING/i.test(out))
-            return out.trim();
-        (0, logger_1.debugLog)('MyMemory 翻译响应异常，放弃译文');
-        return null;
-    }
-    catch (e) {
-        logger_1.logger.info(`推文翻译失败（跳过译文继续发送）：${e?.message || e}`);
-        return null;
-    }
-}
-function normalizeLang(lang) {
-    if (!lang)
-        return null;
-    const l = lang.toLowerCase();
-    if (l === 'und' || l === 'zxx')
-        return null;
-    if (l.startsWith('zh'))
-        return 'zh-CN';
-    return l.split('-')[0];
-}

package/lib/extensions.d.ts

@@ -1,21 +1,25 @@
 /**
- * 扩展契约：core 不直接依赖 NSFW/合并/翻译/GIF 实现，而是通过可注入的
- * VideoParserExtensions 调用。宿主可整体替换或按需覆盖单项能力。
+ * 扩展契约：core 完整工作流 + 基线行为；扩展经阶段钩子注入/修改。
  *
- * 默认实现由 extensions 包（@sns-parse/extensions）提供；runtime 会合并默认实现，
- * 因此 core 编排层可直接调用，无需判空。
+ * core 不内建任何扩展实现（NSFW/合并/翻译/GIF），也不依赖扩展包；
+ * 基线行为保证无扩展时全链路可跑（媒体直通、不合并逐张发、GIF 退化发视频、不翻译）。
+ * 扩展导出 WorkflowExtension（含 setup(hooks)），由宿主收集后注入管道。
  */
+import type { ConfigContribution } from './config';
 import type { ParserRuntimeLike } from './host';
+import type { WorkflowHooks } from './workflow/hooks';
 export type MediaKind = 'cover' | 'image' | 'avatar' | 'music-cover';
 export interface ImageOutcome {
-    /** raw=原图 url；scrambled=混淆 buffer+token；link=仅链接文字；drop=不发送 */
+    /** raw=原图 url 或 buffer 直发；scrambled=混淆 buffer+token；link=只发链接文本；drop=丢弃 */
     kind: 'raw' | 'scrambled' | 'link' | 'drop';
     url?: string;
     buffer?: Buffer;
     token?: string;
+    /** buffer 直发时的 mime（缺省 image/jpeg） */
+    mime?: string;
 }
 export interface VideoOutcome {
-    /** raw=照发；card=群内纯文字卡片+token（无封面无视频）；link=文字卡片+原链接；drop=仅文字卡片 */
+    /** raw=直发视频；card=群内容易吞 → 暂存+token，无法直发视频；link=只发卡片+原链接；drop=只发卡片 */
     kind: 'raw' | 'card' | 'link' | 'drop';
     url?: string;
     token?: string;
@@ -29,29 +33,23 @@ export interface GifOptions {
     fps: number;
     maxDurationSec: number;
 }
-/** 扩展能力集合（全部可选；runtime 会与默认实现合并） */
-export interface VideoParserExtensions {
-    /** 同源切图合并；返回 null 表示不合并 */
-    mergeImages?(rt: ParserRuntimeLike, urls: string[]): Promise<{
-        buffer: Buffer;
-    } | null>;
-    /** 单张出站图片处理（NSFW 策略） */
-    processImage?(rt: ParserRuntimeLike, platform: string, url: string, kind: MediaKind): Promise<ImageOutcome>;
-    /** 出站视频处理（NSFW 策略） */
-    processVideo?(rt: ParserRuntimeLike, platform: string, videoUrl: string, coverUrl: string, meta: {
-        title?: string;
-        author?: string;
-        requesterId: string;
-    }): Promise<VideoOutcome>;
-    /** 合并图审核；返回 null 表示回退逐张处理 */
-    processMergedImage?(rt: ParserRuntimeLike, platform: string, buffer: Buffer, refUrl: string): Promise<ImageOutcome | null>;
-    /** 视频转 GIF；失败返回 null 回退原视频 */
-    mp4ToGif?(rt: ParserRuntimeLike, url: string, durationSec: number, opts: GifOptions): Promise<Buffer | null>;
-    /** 文本翻译；失败返回 null */
-    translate?(rt: ParserRuntimeLike, text: string, target: string, sourceLang?: string): Promise<TranslateResult | null>;
-    /** 内容安全能力状态（启动日志） */
+export interface VideoMeta {
+    title?: string;
+    author?: string;
+    requesterId: string;
+}
+/** 单个扩展片段：能力注册（setup 钩子注入）+ 可选配置贡献/能力位 */
+export interface WorkflowExtension {
+    name: string;
+    setup(hooks: WorkflowHooks): void;
+    configContribution?: ConfigContribution;
     capability?(rt: ParserRuntimeLike): {
         ferret: boolean;
         moderation: string | null;
     };
 }
+/** 汇总各扩展能力位（日志用） */
+export declare function collectCapabilities(extensions: WorkflowExtension[] | undefined, rt: ParserRuntimeLike): {
+    ferret: boolean;
+    moderation: string | null;
+};

package/lib/extensions.js

@@ -1,2 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectCapabilities = collectCapabilities;
+/** 汇总各扩展能力位（日志用） */
+function collectCapabilities(extensions, rt) {
+    let ferret = false;
+    let moderation = null;
+    for (const e of extensions || []) {
+        if (typeof e.capability !== 'function')
+            continue;
+        try {
+            const c = e.capability(rt);
+            if (c?.ferret)
+                ferret = true;
+            if (c?.moderation)
+                moderation = c.moderation;
+        }
+        catch {
+            // 能力位探测失败不影响主链路
+        }
+    }
+    return { ferret, moderation };
+}

package/lib/host.d.ts

@@ -9,7 +9,7 @@
  */
 import { type LoggerLike } from './logger';
 import type { OutboundSender } from './sender';
-import type { VideoParserExtensions } from './extensions';
+import type { WorkflowExtension } from './extensions';
 export interface VideoParserHost {
     logger: LoggerLike;
     /** 数据根目录（如 koishi ctx.baseDir）；缺省时持久化走临时目录 */
@@ -19,7 +19,7 @@ export interface VideoParserHost {
     /** 发送层实现（缺省时由宿主适配层注入） */
     sender?: OutboundSender;
     /** 扩展实现（部分覆盖；缺省能力由内置实现补齐） */
-    extensions?: VideoParserExtensions;
+    extensions?: WorkflowExtension[];
     /** 过渡期：底层上下文（koishi Context 等），core 新代码不应依赖 */
     context?: any;
 }
@@ -31,7 +31,7 @@ export interface ParserRuntimeLike {
     config: any;
     http: any;
     host: VideoParserHost;
-    extensions: VideoParserExtensions;
+    extensions: WorkflowExtension[];
     [key: string]: any;
 }
 /**

package/lib/index.d.ts

@@ -16,16 +16,17 @@ export * from './utils/concurrency';
 export * from './utils/field-mapping';
 export * from './utils/image-size';
 export * from './utils/tls-client';
-export * from './utils/gif';
-export * from './utils/merge';
 export * from './engine/gateway';
 export * from './engine/config';
 export * from './engine/platform-config';
 export * from './engine/translate';
-export * from './engine/twitter';
-export * from './engine/twitter-user';
 export * from './engine/parser';
 export * from './engine/fetcher';
+export * from './engine/compose';
+export * from './engine/forward';
+export * from './engine/flush';
 export * from './engine/runtime';
 export * from './engine/config-io';
+export * from './workflow/hooks';
+export * from './workflow/default';
 export * from './registry';

package/lib/index.js

@@ -32,16 +32,17 @@ __exportStar(require("./utils/concurrency"), exports);
 __exportStar(require("./utils/field-mapping"), exports);
 __exportStar(require("./utils/image-size"), exports);
 __exportStar(require("./utils/tls-client"), exports);
-__exportStar(require("./utils/gif"), exports);
-__exportStar(require("./utils/merge"), exports);
 __exportStar(require("./engine/gateway"), exports);
 __exportStar(require("./engine/config"), exports);
 __exportStar(require("./engine/platform-config"), exports);
 __exportStar(require("./engine/translate"), exports);
-__exportStar(require("./engine/twitter"), exports);
-__exportStar(require("./engine/twitter-user"), exports);
 __exportStar(require("./engine/parser"), exports);
 __exportStar(require("./engine/fetcher"), exports);
+__exportStar(require("./engine/compose"), exports);
+__exportStar(require("./engine/forward"), exports);
+__exportStar(require("./engine/flush"), exports);
 __exportStar(require("./engine/runtime"), exports);
 __exportStar(require("./engine/config-io"), exports);
+__exportStar(require("./workflow/hooks"), exports);
+__exportStar(require("./workflow/default"), exports);
 __exportStar(require("./registry"), exports);

package/lib/platform.d.ts

@@ -1,9 +1,22 @@
+import type { AxiosInstance } from 'axios';
+import type { ParsedData } from './types';
 import { type ConfigContribution } from './config';
+/** 平台原生解析上下文（fetcher 透传：HTTP 实例、配置、GraphQL GET 器） */
+export interface PlatformParseContext {
+    http: AxiosInstance;
+    config: any;
+    /** TLS 指纹 GET 器（tlsget-rs；平台实现用于鉴权 GraphQL） */
+    getGraphql?: (url: string, opts: any) => Promise<{
+        status: number;
+        data: any;
+    }>;
+}
 /**
  * 平台定义契约：每个平台的自描述单元，是「每平台一个包」的基础。
  *
- * 一个 PlatformDefinition 应自包含该平台的全部静态信息（链接规则、专属 API、
- * 提示等）；动态解析逻辑（normalize/parseNative）在后续阶段以可选钩子加入。
+ * 一个 PlatformDefinition 自包含该平台的全部静态信息（链接规则、专属 API、
+ * 提示等）；有原生解析能力的平台（如 X/Twitter 的 syndication/GraphQL 路径）
+ * 通过 parse/translate 钩子提供实现——core 只调度，不持有平台实现。
  */
 export interface PlatformDefinition {
     /** 平台类型标识（与 config.platformEnabled 的键一致） */
@@ -23,6 +36,13 @@ export interface PlatformDefinition {
     label?: string;
     /** 解析失败时的平台特定引导提示 */
     hints?: string[];
+    /** 原生解析钩子：不经网关，由平台包自实现（如 X syndication/GraphQL） */
+    parse?(url: string, ctx: PlatformParseContext): Promise<ParsedData>;
+    /** 原生翻译钩子（如 X 网页同源 Grok 翻译）；失败/不支持返回 null 回落通用翻译 */
+    translate?(ctx: PlatformParseContext, url: string, text: string, target: string): Promise<{
+        text: string;
+        sourceLang?: string;
+    } | null>;
 }
 /**
  * 由平台定义聚合出「平台相关配置」（平台开关 / 专属 API 优先）。

package/lib/registry.d.ts

@@ -1,20 +1,28 @@
+/**
+ * 已安装碎片包（平台 @sns-parse/platform-* / 扩展 @sns-parse/ext-*）的动态发现。
+ *
+ * - 平台：先聚合包（@sns-parse/platforms 的 definitions[]），再逐个候选粒度包，
+ *   按 type 去重合并（粒度包覆盖聚合条目）；宿主可传自己的 require 锚点
+ *   （koishi/CLI 包路径），pnpm strict 下也能发现宿主直依赖。
+ * - 扩展：loadWorkflowExtensions() 返回 WorkflowExtension[]（含 setup 钩子），
+ *   未安装的自动缺席（能力/配置贡献同时缺席，不报错）。
+ */
+import { createRequire } from 'node:module';
 import type { PlatformDefinition } from './platform';
 import type { ConfigContribution } from './config';
-import type { VideoParserExtensions } from './extensions';
-/** 收集已安装平台的定义（含 label/rules/dedicated） */
-export declare function collectPlatformDefinitions(): PlatformDefinition[];
-/** 已安装平台的链接规则（扁平） */
-export declare function collectPlatformLinkRules(): {
+import type { WorkflowExtension } from './extensions';
+type NodeRequire = ReturnType<typeof createRequire>;
+/** 收集已加载平台的定义（聚合包 + 粒度包并集；粒度包覆盖聚合条目） */
+export declare function collectPlatformDefinitions(anchor?: NodeRequire): PlatformDefinition[];
+/** 已加载平台的链接规则（按平台声明） */
+export declare function collectPlatformLinkRules(anchor?: NodeRequire): {
     pattern: RegExp;
     type: string;
 }[];
-export interface LoadedExtension {
-    name: string;
-    contribution?: ConfigContribution;
-    extension?: Partial<VideoParserExtensions>;
-}
-/** 探测并加载全部已安装扩展 */
-export declare function loadExtensions(): LoadedExtension[];
-export declare function loadExtensionContributions(): ConfigContribution[];
-/** 合并所有已安装扩展的能力片段 */
-export declare function loadExtensionImplementations(): Partial<VideoParserExtensions>;
+/** 探测并实例化全部已安装扩展（WorkflowExtension[]；含 setup 钩子） */
+export declare function loadWorkflowExtensions(anchor?: NodeRequire): WorkflowExtension[];
+/** 已安装扩展的配置贡献（settings 动态渲染用） */
+export declare function loadExtensionContributions(anchor?: NodeRequire): ConfigContribution[];
+/** 兼容旧名（已废弃：请用 loadWorkflowExtensions） */
+export declare function loadExtensionImplementations(anchor?: NodeRequire): WorkflowExtension[];
+export {};

package/lib/registry.js

@@ -2,76 +2,100 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.collectPlatformDefinitions = collectPlatformDefinitions;
 exports.collectPlatformLinkRules = collectPlatformLinkRules;
-exports.loadExtensions = loadExtensions;
+exports.loadWorkflowExtensions = loadWorkflowExtensions;
 exports.loadExtensionContributions = loadExtensionContributions;
 exports.loadExtensionImplementations = loadExtensionImplementations;
 /**
- * 已安装碎片包的动态收集（平台 @sns-parse/platform-* 与扩展 @sns-parse/ext-*）。
+ * 已安装碎片包（平台 @sns-parse/platform-* / 扩展 @sns-parse/ext-*）的动态发现。
  *
- * - 可自选安装单个碎片包；安装聚合包（@sns-parse/platforms / extensions）则全部到位
- * - 未安装的碎片自动缺席（链接识别、配置项与能力同时缺席）
- * - koishi 兼容层与 CLI 均经此处收集定义与配置声明
+ * - 平台：先聚合包（@sns-parse/platforms 的 definitions[]），再逐个候选粒度包，
+ *   按 type 去重合并（粒度包覆盖聚合条目）；宿主可传自己的 require 锚点
+ *   （koishi/CLI 包路径），pnpm strict 下也能发现宿主直依赖。
+ * - 扩展：loadWorkflowExtensions() 返回 WorkflowExtension[]（含 setup 钩子），
+ *   未安装的自动缺席（能力/配置贡献同时缺席，不报错）。
  */
 const node_module_1 = require("node:module");
-const nodeRequire = (0, node_module_1.createRequire)(typeof __filename !== 'undefined' ? __filename : process.cwd() + '/');
+const fallbackRequire = (0, node_module_1.createRequire)(typeof __filename !== 'undefined' ? __filename : process.cwd() + '/');
+function req(anchor) {
+    return anchor || fallbackRequire;
+}
 const PLATFORM_TYPES = [
     'bilibili', 'douyin', 'kuaishou', 'xiaohongshu', 'weibo', 'xigua', 'youtube',
     'tiktok', 'acfun', 'zhihu', 'weishi', 'huya', 'haokan', 'meipai', 'twitter',
     'instagram', 'doubao', 'doubao_image', 'jimeng', 'oasis', 'wechat_channel',
     'lishi', 'quanmin', 'pipigx', 'pipixia', 'zuiyou', 'toutiao',
 ];
-/** 收集已安装平台的定义（含 label/rules/dedicated） */
-function collectPlatformDefinitions() {
-    const out = [];
+/** 收集已加载平台的定义（聚合包 + 粒度包并集；粒度包覆盖聚合条目） */
+function collectPlatformDefinitions(anchor) {
+    const nodeRequire = req(anchor);
+    const byType = new Map();
+    // 1) 聚合包（若安装）：一次拿全声明
+    try {
+        const agg = nodeRequire('@sns-parse/platforms');
+        const defs = agg?.definitions || agg?.default?.definitions || [];
+        for (const d of defs) {
+            if (d && d.type && !byType.has(d.type))
+                byType.set(d.type, d);
+        }
+    }
+    catch {
+        // 未装聚合包 → 只看粒度包
+    }
+    // 2) 粒度包（可覆盖聚合条目）
     for (const type of PLATFORM_TYPES) {
         try {
             const mod = nodeRequire(`@sns-parse/platform-${type}`);
             const def = mod.default || mod[type];
             if (def && def.type)
-                out.push(def);
+                byType.set(def.type, def);
         }
         catch {
-            // 未安装该平台包 → 跳过
+            // 未装该平台 → 缺席
         }
     }
-    return out;
+    return [...byType.values()];
 }
-/** 已安装平台的链接规则（扁平） */
-function collectPlatformLinkRules() {
-    return collectPlatformDefinitions().flatMap(d => d.rules.map(pattern => ({ pattern, type: d.type })));
+/** 已加载平台的链接规则（按平台声明） */
+function collectPlatformLinkRules(anchor) {
+    return collectPlatformDefinitions(anchor).flatMap(d => d.rules.map(pattern => ({ pattern, type: d.type })));
 }
 const EXTENSION_SPECS = [
-    { name: 'ext-nsfw', contributionKey: 'nsfwConfigContribution', extensionKey: 'nsfwExtension' },
+    { name: 'ext-nsfw', extensionKey: 'nsfwExtension', contributionKey: 'nsfwConfigContribution' },
     { name: 'ext-merge', extensionKey: 'mergeExtension' },
     { name: 'ext-translate', extensionKey: 'translateExtension' },
     { name: 'ext-gif', extensionKey: 'gifExtension' },
 ];
-/** 探测并加载全部已安装扩展 */
-function loadExtensions() {
+/** 探测并实例化全部已安装扩展（WorkflowExtension[]；含 setup 钩子） */
+function loadWorkflowExtensions(anchor) {
+    const nodeRequire = req(anchor);
     const out = [];
     for (const spec of EXTENSION_SPECS) {
         try {
             const mod = nodeRequire(`@sns-parse/${spec.name}`);
-            out.push({
-                name: spec.name,
-                contribution: spec.contributionKey ? mod[spec.contributionKey] : undefined,
-                extension: spec.extensionKey && typeof mod[spec.extensionKey] === 'function'
-                    ? mod[spec.extensionKey]()
-                    : undefined,
-            });
+            const factory = mod?.[spec.extensionKey];
+            if (typeof factory !== 'function')
+                continue;
+            const ext = factory();
+            if (!ext || typeof ext.setup !== 'function')
+                continue;
+            if (!ext.configContribution && spec.contributionKey && mod[spec.contributionKey]) {
+                ext.configContribution = mod[spec.contributionKey];
+            }
+            out.push(ext);
         }
         catch {
-            // 未安装该扩展 → 跳过（配置项与能力同时缺席）
+            // 未安装的扩展 → 缺席（能力与配置贡献同时缺席）
         }
     }
     return out;
 }
-function loadExtensionContributions() {
-    return loadExtensions()
-        .map(e => e.contribution)
+/** 已安装扩展的配置贡献（settings 动态渲染用） */
+function loadExtensionContributions(anchor) {
+    return loadWorkflowExtensions(anchor)
+        .map(e => e.configContribution)
         .filter((c) => !!c);
 }
-/** 合并所有已安装扩展的能力片段 */
-function loadExtensionImplementations() {
-    return Object.assign({}, ...loadExtensions().map(e => e.extension || {}));
+/** 兼容旧名（已废弃：请用 loadWorkflowExtensions） */
+function loadExtensionImplementations(anchor) {
+    return loadWorkflowExtensions(anchor);
 }

package/lib/utils/merge.d.ts

@@ -28,8 +28,9 @@ export interface SeamVerdict {
     /** 结论文案 */
     reason: string;
 }
-/** 内容验证：所有接缝（趋势+纹理）均通过才成立；允许至多一条「边界容差缝」
- *  （比值 ∈ [3,5)，其余全部通过——平台独立重压缩的典型错位幅度；平坦不可验证缝不参与容差）。
+/** 内容验证：所有接缝（趋势+纹理）均通过才成立；接缝总数 ≥3 时允许至多一条
+ *  「边界容差缝」（比值 ∈ [3,5)——平台独立重压缩的典型错位幅度；多条缝相互
+ *  印证才可信，2 缝场景证据不足不放行；平坦不可验证缝不参与容差）。
  *  返回最大接缝比值与逐缝证据。 */
 export declare function verifyLayout(layout: MergeLayout, grays: Buffer[]): {
     pass: boolean;

package/lib/utils/merge.js

@@ -37,10 +37,12 @@ const COL_LEN = 64;
 /** 接缝差异 / 内部自然差异 的判定阈值（母图切片 ≈1，无关图片 ≫1；下限 3 防平坦图除零） */
 const BOUNDARY_THRESH = 3.0;
 const MAD_FLOOR = 3.0;
-/** 单缝边界容差：平台（如 X）对各分片独立重压缩会让个别接缝低频轻微错位；
- *  其余接缝全部通过且仅一条落在 [BOUNDARY_THRESH, BORDERLINE_THRESH) 时放行 */
+/** 单缝边界容差：平台（如 X）对各分片独立重压缩会让个别接缝低频轻微错位。
+ *  仅当接缝总数 ≥3（≥4 图，多条缝相互印证）且恰好一条落在
+ *  [BOUNDARY_THRESH, BORDERLINE_THRESH)、其余全部通过时放行；平坦不可验证缝不参与容差 */
 const BORDERLINE_THRESH = 5.0;
 const BORDERLINE_MAX = 1;
+const BORDERLINE_MIN_SEAMS = 3;
 /** 边界带纹理能量下限：低于此值视为「不可验证接缝」（相似背景/平边照片会骗过亮度对比） */
 const TEXTURE_MIN = 4.0;
 /* ---------- 尺寸候选 ---------- */
@@ -188,8 +190,9 @@ function seamVerdictH(a, b, from, to) {
         [colOf(b, 2), colOf(b, 1)],
     ]);
 }
-/** 内容验证：所有接缝（趋势+纹理）均通过才成立；允许至多一条「边界容差缝」
- *  （比值 ∈ [3,5)，其余全部通过——平台独立重压缩的典型错位幅度；平坦不可验证缝不参与容差）。
+/** 内容验证：所有接缝（趋势+纹理）均通过才成立；接缝总数 ≥3 时允许至多一条
+ *  「边界容差缝」（比值 ∈ [3,5)——平台独立重压缩的典型错位幅度；多条缝相互
+ *  印证才可信，2 缝场景证据不足不放行；平坦不可验证缝不参与容差）。
  *  返回最大接缝比值与逐缝证据。 */
 function verifyLayout(layout, grays) {
     const seams = [];
@@ -217,7 +220,7 @@ function verifyLayout(layout, grays) {
     const failed = seams.filter((v) => !v.ok);
     const borderline = failed.filter((v) => v.score < BORDERLINE_THRESH);
     const pass = seams.every((v) => v.ok)
-        || (borderline.length <= BORDERLINE_MAX && failed.length === borderline.length);
+        || (seams.length >= BORDERLINE_MIN_SEAMS && borderline.length <= BORDERLINE_MAX && failed.length === borderline.length);
     return { pass, score: worst, seams };
 }
 /** 内容识别：候选布局逐一经接缝连续性验证，取通过者中比值最小的一个 */

package/lib/workflow/default.d.ts

@@ -0,0 +1,3 @@
+import { Pipeline } from './hooks';
+/** 构建带全部基线实现的管道；随后调用各扩展 setup(hooks) 注入/覆盖 */
+export declare function createDefaultPipeline(rt: any): Pipeline;