@sns-parse/core 0.5.0-alpha.1 → 0.6.0-alpha.1

package/lib/engine/compose.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 发送编排：把一条解析结果拆成「语义单元」（MessageUnit），按发送策略消费。
+ *
+ * 本模块发送层无关：只构建 OutboundElement，具体发送交给 OutboundSender。
+ *
+ * 每个单元带 mergeable 标记：
+ * - mergeable=true：概述文字/头像/封面/图片/音乐/提示文案（含受限视频与混淆图提示），
+ *   全部并入首条消息——提示说清楚「怎么取」
+ * - mergeable=false：后面跟着的干脆的可领取形式，不含其他内容：
+ *   视频文件 / 「取视频 <token>」/ 「解混淆 <token>[混淆图]」
+ *
+ * 消费方式见 core/flush.ts：
+ * - sendSingle：合并所有 mergeable 单元为一条，mergeable=false 单元逐条
+ * - sendSplit：每个单元一条
+ * - sendForward：每个单元一个转发气泡（仅一条时不打包直接发送）
+ */
+import type { ParserRuntime } from './runtime';
+import type { ParsedData } from '../types';
+import { type OutboundElement, type OutboundSender, type SessionLike } from '../sender';
+import type { ImageOutcome, VideoOutcome } from '../extensions';
+export interface ProcessedItem {
+    text: string;
+    parsed: ParsedData;
+    images: ImageOutcome[];
+    avatar: ImageOutcome;
+    cover: ImageOutcome | null;
+    video: VideoOutcome;
+    /** 推文动图转 GIF 的成品（转换失败为 null，回退发视频） */
+    gif?: Buffer | null;
+    /** 多视频推文的其余视频及其 GIF 成品/封面（与 extraVideos 一一对应） */
+    extraVideos?: VideoOutcome[];
+    extraGifs?: (Buffer | null)[];
+    extraCovers?: (ImageOutcome | null)[];
+}
+/** 一个待发送的语义单元 */
+export interface MessageUnit {
+    content: OutboundElement[];
+    /** true=可合并进单条消息；false=必须独立发送（视频文件/混淆图/取件码） */
+    mergeable: boolean;
+}
+/** 首条消息的混淆图数量提示（不含取件码，取件码只出现在独立领取消息里） */
+export declare function buildImageHint(rt: ParserRuntime, count: number): string;
+/** 首条消息的受限视频提示（不含取件码；token 只在独立的「取视频 <token>」消息里） */
+export declare function buildVideoHint(rt: ParserRuntime, item: ProcessedItem): string;
+/** 把 ProcessedItem 拆成有序语义单元 */
+export declare function buildUnits(rt: ParserRuntime, item: ProcessedItem): MessageUnit[];
+/**
+ * 单条整合：合并所有 mergeable 单元为一条消息（图片超限则退化为逐条），
+ * mergeable=false 单元独立逐条。
+ */
+export declare function sendSingle(rt: ParserRuntime, sender: OutboundSender, session: SessionLike, item: ProcessedItem, opts?: {
+    quoteId?: string;
+}): Promise<void>;
+/** 逐条发送：每个语义单元一条消息 */
+export declare function sendSplit(rt: ParserRuntime, sender: OutboundSender, session: SessionLike, item: ProcessedItem, opts?: {
+    quoteId?: string;
+}): Promise<void>;

package/lib/engine/compose.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildImageHint = buildImageHint;
+exports.buildVideoHint = buildVideoHint;
+exports.buildUnits = buildUnits;
+exports.sendSingle = sendSingle;
+exports.sendSplit = sendSplit;
+const common_1 = require("../utils/common");
+const sender_1 = require("../sender");
+const hooks_1 = require("../workflow/hooks");
+/** 首条消息的混淆图数量提示（不含取件码，取件码只出现在独立领取消息里） */
+function buildImageHint(rt, count) {
+    const nsfw = rt.config.nsfwPolicy || {};
+    return String(nsfw.tokenHintText || '').replace(/\$\{count\}/g, String(count));
+}
+/** 首条消息的受限视频提示（不含取件码；token 只在独立的「取视频 <token>」消息里） */
+function buildVideoHint(rt, item) {
+    const nsfw = rt.config.nsfwPolicy || {};
+    if (item.video.kind === 'card' && item.video.token) {
+        const ttl = rt.config.nsfwVault?.ttlMinutes || 30;
+        const until = new Date(Date.now() + ttl * 60000);
+        const untilStr = `${String(until.getHours()).padStart(2, '0')}:${String(until.getMinutes()).padStart(2, '0')}`;
+        return String(nsfw.videoCardHint || '')
+            .replace(/\$\{until\}/g, untilStr)
+            .replace(/\$\{ttl\}/g, String(ttl));
+    }
+    if (item.video.kind === 'link' && item.video.url)
+        return `受限视频未在群内发送。视频链接：${item.video.url}`;
+    if (item.video.kind === 'drop' && item.parsed.video)
+        return '受限视频未在群内发送。';
+    return '';
+}
+/** 把 ProcessedItem 拆成有序语义单元 */
+function buildUnits(rt, item) {
+    const { config } = rt;
+    const p = item.parsed;
+    const units = [];
+    const push = (content, mergeable) => { if (content.length)
+        units.push({ content, mergeable }); };
+    // ① 概述文字
+    if (item.text && config.showImageText)
+        push([sender_1.el.text(item.text)], true);
+    // ② 头像（非混淆）
+    if (config.showAuthorAvatar && p.avatar && item.avatar.kind !== 'drop' && item.avatar.kind !== 'scrambled' && item.avatar.url) {
+        push([sender_1.el.image(item.avatar.url)], true);
+    }
+    // ③ 封面（非混淆）；多视频推文的每个视频封面都进概述区
+    if (item.cover && item.cover.kind === 'raw' && item.cover.url
+        && p.cover && config.showCoverImage && p.type !== 'live_photo' && p.type !== 'image' && p.type !== 'live') {
+        const c = [];
+        if (config.showCoverText)
+            c.push(sender_1.el.text(config.coverText || '封面：'));
+        c.push(sender_1.el.image(item.cover.url));
+        push(c, true);
+    }
+    if (config.showCoverImage && p.type !== 'live_photo' && p.type !== 'image' && p.type !== 'live') {
+        for (const ec of item.extraCovers || []) {
+            if (ec?.kind === 'raw' && ec.url && ec.url !== item.cover?.url)
+                push([sender_1.el.image(ec.url)], true);
+            else if (ec?.kind === 'link' && ec.url && ec.url !== item.cover?.url)
+                push([sender_1.el.text(`封面链接：${ec.url}`)], true);
+        }
+    }
+    // ④ 音乐封面
+    if (config.showMusicCover && p.music.cover)
+        push([sender_1.el.image(p.music.cover)], true);
+    // ⑤ 非混淆图片（raw 可带 buffer：同源切图合并成品优先按 buffer 发送）
+    for (const img of item.images) {
+        if (img.kind === 'raw' && img.buffer)
+            push([sender_1.el.imageBuffer(img.buffer, 'image/jpeg')], true);
+        else if (img.kind === 'raw' && img.url)
+            push([sender_1.el.image(img.url)], true);
+        else if (img.kind === 'link' && img.url)
+            push([sender_1.el.text(`图片链接：${img.url}`)], true);
+    }
+    // ⑥ 合规视频（必须独立，含视频自动分条）；动图已转 GIF 时以图片形式独立发送
+    if (item.gif) {
+        push([sender_1.el.imageBuffer(item.gif, 'image/gif')], false);
+    }
+    else if (p.video && p.type !== 'live' && p.type !== 'live_photo' && item.video.kind === 'raw' && item.video.url) {
+        push([config.showVideoFile !== false ? sender_1.el.video(item.video.url) : sender_1.el.text(`视频链接：${item.video.url}`)], false);
+    }
+    // ⑥b 多视频推文：其余视频逐条独立发送（动图转 GIF 优先，受限降级链接）
+    for (let i = 0; i < (item.extraVideos?.length || 0); i++) {
+        const ev = item.extraVideos[i];
+        const eg = item.extraGifs?.[i];
+        if (eg) {
+            push([sender_1.el.imageBuffer(eg, 'image/gif')], false);
+        }
+        else if (ev.kind === 'raw' && ev.url) {
+            push([config.showVideoFile !== false ? sender_1.el.video(ev.url) : sender_1.el.text(`视频链接：${ev.url}`)], false);
+        }
+        else if (ev.kind === 'link' && ev.url) {
+            push([sender_1.el.text(`视频链接：${ev.url}`)], true);
+        }
+    }
+    // ⑦ 音乐语音
+    if (config.showMusicVoice && p.music.url)
+        push([sender_1.el.audio(p.music.url)], true);
+    // ⑧ 直播提示
+    if (p.type === 'live' && config.sendLiveMessage)
+        push([sender_1.el.text('直播进行中，无法发送视频流。')], true);
+    // ⑨ 受限视频：提示并入首条消息（存在任一受限视频即提示一次）；每个取件码独立成条
+    const cardOutcomes = [item.video, ...(item.extraVideos || [])]
+        .filter(v => v?.kind === 'card' && v.token);
+    let videoHint = buildVideoHint(rt, item);
+    if (!videoHint && cardOutcomes.length) {
+        // 主视频未受限但存在受限的额外视频（按各自封面单独判定）：仍给出领取提示
+        videoHint = buildVideoHint(rt, { ...item, video: cardOutcomes[0] });
+    }
+    if (videoHint)
+        push([sender_1.el.text(videoHint)], true);
+    for (const c of cardOutcomes)
+        push([sender_1.el.text(`取视频 ${c.token}`)], false);
+    // ⑩ 混淆图：首条只报数量；每张独立为干脆的「解混淆 <token>[混淆图]」（多视频封面同策略）
+    const scrambledImgs = [item.avatar, item.cover, ...(item.extraCovers || []), ...item.images]
+        .filter(img => img?.kind === 'scrambled' && img.buffer);
+    if (scrambledImgs.length) {
+        const summary = buildImageHint(rt, scrambledImgs.length);
+        if (summary)
+            push([sender_1.el.text(summary)], true);
+    }
+    for (const img of scrambledImgs) {
+        const c = [];
+        if (img.token)
+            c.push(sender_1.el.text(`解混淆 ${img.token}`));
+        c.push(sender_1.el.imageBuffer(img.buffer, 'image/png'));
+        push(c, false);
+    }
+    return units;
+}
+/** 发送一组元素；失败时视频元素降级为链接文字 */
+async function sendElements(sender, session, elements, quoteId) {
+    const withQuote = quoteId ? [sender_1.el.quote(quoteId), ...elements] : elements;
+    try {
+        await sender.send(session, withQuote);
+    }
+    catch {
+        const links = elements.map(sender_1.videoFallback);
+        await sender.send(session, quoteId ? [sender_1.el.quote(quoteId), ...links] : links).catch(() => { });
+    }
+}
+/**
+ * 单条整合：合并所有 mergeable 单元为一条消息（图片超限则退化为逐条），
+ * mergeable=false 单元独立逐条。
+ */
+async function sendSingle(rt, sender, session, item, opts = {}) {
+    const units = await (0, hooks_1.runStage)(rt, 'compose', { item });
+    const mergeable = units.filter(u => u.mergeable);
+    const standalone = units.filter(u => !u.mergeable);
+    const maxImages = rt.config.singleSendMaxImages || 10;
+    let quote = opts.quoteId;
+    if (mergeable.length) {
+        const imgCount = mergeable.reduce((n, u) => n + u.content.filter(e => e.type === 'image').length, 0);
+        if (imgCount <= maxImages) {
+            const merged = mergeable.flatMap(u => u.content);
+            await sendElements(sender, session, merged, quote);
+            await (0, common_1.delay)(300);
+            quote = undefined; // 仅首条引用原消息
+        }
+        else {
+            for (const u of mergeable) {
+                await sendElements(sender, session, u.content, quote);
+                await (0, common_1.delay)(300);
+                quote = undefined;
+            }
+        }
+    }
+    for (const u of standalone) {
+        await sendElements(sender, session, u.content, quote);
+        await (0, common_1.delay)(300);
+        quote = undefined;
+    }
+}
+/** 逐条发送：每个语义单元一条消息 */
+async function sendSplit(rt, sender, session, item, opts = {}) {
+    const units = await (0, hooks_1.runStage)(rt, 'compose', { item });
+    let quote = opts.quoteId;
+    for (const u of units) {
+        await sendElements(sender, session, u.content, quote);
+        await (0, common_1.delay)(300);
+        quote = undefined;
+    }
+}

package/lib/engine/fetcher.js

@@ -16,6 +16,7 @@ const platform_config_1 = require("./platform-config");
 const translate_1 = require("./translate");
 const tls_client_1 = require("../utils/tls-client");
 const gateway_1 = require("./gateway");
+const hooks_1 = require("../workflow/hooks");
 async function fetchApi(rt, url, type, fieldMapping, platformConf) {
     const { config, http, urlCacheLocal, proxyConfig, cacheTTL } = rt;
     const cacheKey = url;
@@ -53,7 +54,7 @@ async function fetchApi(rt, url, type, fieldMapping, platformConf) {
                         parsed.lang = nativeTr.sourceLang;
                 }
                 if (!translated) {
-                    const generic = await rt.extensions.translate?.(rt, parsed.desc, target, parsed.lang);
+                    const generic = await (0, hooks_1.runStage)(rt, 'translate', { text: parsed.desc, target, sourceLang: parsed.lang });
                     if (generic) {
                         translated = generic.text;
                         provider = generic.provider;

package/lib/engine/flush.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 解析编排（发送层无关）：三层去重 → 并发解析 → gate（NSFW 策略）预处理 → 发送分派。
+ *
+ * 发送由 OutboundSender 完成（Koishi 适配器见 src/sender/koishi-sender.ts）。
+ *
+ * 去重三层（默认全开）：
+ * ① 同消息 URL 去重（含并发竞态）
+ * ② 内容指纹去重（不同链接相同内容只发首个）
+ * ③ title===desc 抑制（engine/parser 与 twitter mapper 内实现）
+ *
+ * 发送分派（优先级）：
+ * enableForward(onebot/satori) → 合并转发
+ * sendStrategy='single'（默认）→ 单条整合；不可行/失败 → 转发 → split
+ * sendStrategy='split' → 逐条
+ */
+import type { ParserRuntime } from './runtime';
+import type { LinkMatch } from '../types';
+import type { OutboundSender, SessionLike } from '../sender';
+export interface FlushOptions {
+    /** 手动命令（parse <url>）显式触发：跳过去重检查（用户明确要求重新解析） */
+    skipDedup?: boolean;
+    /** 注入发送层；缺省取 host.sender */
+    sender?: OutboundSender;
+}
+export declare function flush(rt: ParserRuntime, session: SessionLike, matches: LinkMatch[], opts?: FlushOptions): Promise<void>;

package/lib/engine/flush.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flush = flush;
+const concurrency_1 = require("../utils/concurrency");
+const logger_1 = require("../logger");
+const common_1 = require("../utils/common");
+const platform_config_1 = require("./platform-config");
+const fetcher_1 = require("./fetcher");
+const sender_1 = require("../sender");
+const hooks_1 = require("../workflow/hooks");
+/** 去重键按会话隔离：防的是同一会话内刷屏，不阻断内容跨会话传播 */
+function dedupScopeKey(session, url) {
+    const scope = session?.channelId || session?.guildId || session?.userId || 'global';
+    return `${scope}::${url}`;
+}
+/** gate 预处理：把 ParsedData 转成发送层消费的 ProcessedItem */
+async function processItem(rt, session, platform, text, parsed) {
+    // 各能力一律经阶段管道（基线=直通/不合并/不转换），扩展可注入或替换
+    const requesterId = String(session?.userId || 'unknown');
+    const images = [];
+    // 同源切图合并：四宫格/九宫格/n×n 宫格与水平/垂直切分条带识别为一张母图的分片，合成后发送；
+    // 识别失败 / ffmpeg 不可用 / 审核 fail-closed → 回退逐张处理
+    let mergedSent = false;
+    if (rt.config.mergeSameOriginImages !== false && (parsed.images || []).length >= 2) {
+        try {
+            const merged = await (0, hooks_1.runStage)(rt, 'merge', { urls: parsed.images });
+            if (merged) {
+                const outcome = await (0, hooks_1.runStage)(rt, 'media.merged', { platform, buffer: merged.buffer, refUrl: parsed.images[0] });
+                if (outcome) {
+                    images.push(outcome);
+                    mergedSent = true;
+                }
+                else
+                    (0, logger_1.debugLog)('合并图未过内容安全策略，回退逐张处理');
+            }
+        }
+        catch (e) {
+            (0, logger_1.debugLog)(`切图合并跳过（${e?.message || e}）`);
+        }
+    }
+    if (!mergedSent) {
+        for (const url of (parsed.images || [])) {
+            images.push(await (0, hooks_1.runStage)(rt, 'media.image', { platform, url, kind: 'image' }));
+        }
+    }
+    const avatar = parsed.avatar ? await (0, hooks_1.runStage)(rt, 'media.image', { platform, url: parsed.avatar, kind: 'avatar' }) : { kind: 'drop' };
+    const cover = (parsed.cover && parsed.type !== 'image' && parsed.type !== 'live_photo' && parsed.type !== 'live')
+        ? await (0, hooks_1.runStage)(rt, 'media.image', { platform, url: parsed.cover, kind: 'cover' })
+        : null;
+    const video = parsed.video
+        ? await (0, hooks_1.runStage)(rt, 'media.video', { platform, videoUrl: parsed.video, coverUrl: parsed.cover || '', meta: { title: parsed.title, author: parsed.author, requesterId } })
+        : { kind: 'raw', url: '' };
+    // 推文动图：按配置转 GIF（仅合规视频；转换失败回退原视频）
+    let gif = null;
+    if (parsed.isGif && video.kind === 'raw' && video.url && rt.config.gifConvertEnabled !== false) {
+        gif = await (0, hooks_1.runStage)(rt, 'transcode', {
+            url: video.url, durationSec: parsed.duration,
+            opts: {
+                maxWidth: rt.config.gifMaxWidth || 480,
+                fps: rt.config.gifFps || 15,
+                maxDurationSec: rt.config.gifMaxDurationSec || 15,
+            },
+        });
+    }
+    // 多视频推文：其余视频逐条过 gate 与 GIF 转换；封面单独审核、随行展示，视频判定用各自封面
+    const extraVideos = [];
+    const extraGifs = [];
+    const extraCovers = [];
+    for (const ev of parsed.extraVideos || []) {
+        const evCover = ev.cover || parsed.cover || '';
+        extraCovers.push(evCover
+            ? await (0, hooks_1.runStage)(rt, 'media.image', { platform, url: evCover, kind: 'cover' })
+            : null);
+        const outcome = await (0, hooks_1.runStage)(rt, 'media.video', { platform, videoUrl: ev.url, coverUrl: evCover, meta: { title: parsed.title, author: parsed.author, requesterId } });
+        extraVideos.push(outcome);
+        if (ev.isGif && outcome.kind === 'raw' && outcome.url && rt.config.gifConvertEnabled !== false) {
+            extraGifs.push(await (0, hooks_1.runStage)(rt, 'transcode', {
+                url: outcome.url, durationSec: ev.duration || 0,
+                opts: {
+                    maxWidth: rt.config.gifMaxWidth || 480,
+                    fps: rt.config.gifFps || 15,
+                    maxDurationSec: rt.config.gifMaxDurationSec || 15,
+                },
+            }));
+        }
+        else {
+            extraGifs.push(null);
+        }
+    }
+    return { text, parsed, images, avatar, cover, video, gif, extraVideos, extraGifs, extraCovers };
+}
+async function flush(rt, session, matches, opts = {}) {
+    const sender = opts.sender ?? rt.host.sender;
+    if (!sender)
+        throw new Error('flush: 未提供 OutboundSender（请通过 opts.sender 或 host.sender 注入）');
+    const { config, dedupCache, contentDedupCache } = rt;
+    (0, logger_1.debugLog)(`开始解析 ${matches.length} 个链接`);
+    const items = [];
+    const errors = [];
+    const limiter = new concurrency_1.ConcurrencyLimiter(config.maxConcurrent || 3);
+    // 去重层①：同消息 URL 去重（保序）
+    const seenUrl = new Set();
+    const uniqueMatches = matches.filter((m) => {
+        const key = m.url.replace(/\/+$/, '');
+        if (seenUrl.has(key))
+            return false;
+        seenUrl.add(key);
+        return true;
+    });
+    const promises = uniqueMatches.map(async (match) => {
+        await limiter.acquire();
+        try {
+            const platformEnabled = config.platformEnabled?.[match.type] ?? true;
+            if (!platformEnabled && !match.type.startsWith('custom_')) {
+                (0, logger_1.debugLog)(`平台 ${match.type} 已禁用，跳过链接: ${match.url}`);
+                return;
+            }
+            const dedupEnabled = !opts.skipDedup && config.enableDeduplication !== false && config.deduplicationInterval > 0;
+            const scopeKey = dedupScopeKey(session, match.url);
+            if (dedupEnabled) {
+                const lastTime = dedupCache.get(scopeKey);
+                if (lastTime && (Date.now() - lastTime < config.deduplicationInterval * 1000)) {
+                    (0, logger_1.debugLog)(`跳过重复链接: ${match.url}`);
+                    const shortUrl = match.url.length > 80 ? match.url.slice(0, 80) + '...' : match.url;
+                    const tip = (0, common_1.getText)(config, 'deduplicationTipText').replace(/\$\{url\}/g, shortUrl).replace(/\$\{interval\}/g, String(config.deduplicationInterval));
+                    await sender.send(session, [sender_1.el.text(tip)]).catch(() => { });
+                    return;
+                }
+            }
+            logger_1.logger.info(`解析链接: ${match.url} (${match.type})`);
+            const platformConf = (0, platform_config_1.getPlatformConfig)(rt, match.type);
+            const result = await (0, fetcher_1.processSingleUrl)(rt, match.url, match.type, platformConf.fieldMapping, platformConf);
+            if (result.success) {
+                if (dedupEnabled) {
+                    // 去重层②：内容指纹按会话隔离；不同链接相同内容只发首个
+                    const fp = dedupScopeKey(session, (0, common_1.contentFingerprint)(result.data.parsed));
+                    const lastDedup = contentDedupCache.get(fp);
+                    if (lastDedup && (Date.now() - lastDedup < config.deduplicationInterval * 1000)) {
+                        (0, logger_1.debugLog)(`跳过重复内容: ${match.url}`);
+                        return;
+                    }
+                    contentDedupCache.set(fp, Date.now());
+                    dedupCache.set(scopeKey, Date.now());
+                }
+                items.push(await processItem(rt, session, match.type, result.data.text, result.data.parsed));
+            }
+            else {
+                const displayUrl = match.url.length > 80 ? match.url.slice(0, 80) + '...' : match.url;
+                const item = (0, common_1.getText)(config, 'parseErrorItemFormat').replace(/\$\{url\}/g, displayUrl).replace(/\$\{msg\}/g, result.msg);
+                errors.push(item);
+            }
+        }
+        finally {
+            limiter.release();
+        }
+    });
+    await Promise.all(promises);
+    if (errors.length)
+        await sender.send(session, [sender_1.el.text(`${(0, common_1.getText)(config, 'parseErrorPrefix')}\n${errors.join('\n')}`)]);
+    if (!items.length)
+        return;
+    await (0, hooks_1.runStage)(rt, 'send', { items, session, sender, quoteId: session?.messageId });
+}

package/lib/engine/forward.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 合并转发模式：把每个语义单元（MessageUnit）构建为一个转发气泡。
+ *
+ * 发送层无关：构建 ForwardBubble[]，由 OutboundSender.sendForward 翻译为
+ * 宿主实现（Koishi 为 <message forward> 嵌套 <message><author>）。
+ * 仅一个气泡时不打包卡片，直接发送。
+ */
+import type { ParserRuntime } from './runtime';
+import type { OutboundSender, SessionLike } from '../sender';
+import type { ProcessedItem } from './compose';
+export declare function buildForwardNode(_session: any, content: any, botName: string): {
+    content: any;
+    name: string;
+};
+export declare function sendForward(rt: ParserRuntime, sender: OutboundSender, session: SessionLike, items: ProcessedItem[]): Promise<void>;

package/lib/engine/forward.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildForwardNode = buildForwardNode;
+exports.sendForward = sendForward;
+const common_1 = require("../utils/common");
+const logger_1 = require("../logger");
+const hooks_1 = require("../workflow/hooks");
+// 保持兼容：旧签名 buildForwardNode(session, content, botName) 曾用于构建气泡；
+// 发送层无关后由 OutboundSender.sendForward 负责，占位导出避免外部引用断裂。
+function buildForwardNode(_session, content, botName) {
+    return { content, name: botName };
+}
+async function sendForward(rt, sender, session, items) {
+    const { config } = rt;
+    const botName = config.botName || '视频解析机器人';
+    const bubbles = [];
+    const total = items.length;
+    for (let i = 0; i < total; i++) {
+        const item = items[i];
+        const units = await (0, hooks_1.runStage)(rt, 'compose', { item });
+        // 多 item 时给概述文字加序号前缀
+        if (total > 1) {
+            for (const u of units) {
+                const txt = u.content.find((e) => e.type === 'text');
+                if (txt && txt.type === 'text') {
+                    txt.text = `【${i + 1}/${total}】\n${txt.text}`;
+                    break;
+                }
+            }
+        }
+        // mergeable 单元（概述+图片+提示）合并为第一个气泡；非 mergeable（视频文件/取件码/混淆图）各占一个气泡
+        const mergeable = units.filter(u => u.mergeable);
+        const standalone = units.filter(u => !u.mergeable);
+        if (mergeable.length)
+            bubbles.push({ content: mergeable.flatMap(u => u.content), name: botName });
+        for (const u of standalone)
+            bubbles.push({ content: u.content, name: botName });
+    }
+    // 仅一条消息：不打包转发卡片，直接发送
+    if (bubbles.length === 1) {
+        await sender.send(session, bubbles[0].content, config.retryTimes);
+        return;
+    }
+    const MAX_BUBBLES = 50;
+    for (let i = 0; i < bubbles.length; i += MAX_BUBBLES) {
+        const batch = bubbles.slice(i, i + MAX_BUBBLES);
+        try {
+            await sender.sendForward(session, batch, config.retryTimes);
+        }
+        catch (err) {
+            logger_1.logger.error('合并转发失败，降级逐条发送:', err);
+            for (const item of items) {
+                for (const u of await (0, hooks_1.runStage)(rt, 'compose', { item })) {
+                    await sender.send(session, u.content).catch(() => { });
+                    await (0, common_1.delay)(300);
+                }
+            }
+            return;
+        }
+    }
+}

package/lib/engine/runtime.d.ts

@@ -1,23 +1,24 @@
 /**
- * 运行时构建（自宿主 runtime 下沉，平台无关）。
+ * 运行时装配（本文件在 core 内，平台无关）。
  *
- * 平台定义列表（defs）由调用方传入：
- * - koishi 兼容层传内置 BUILTIN_PLATFORMS（本地 definitions）
- * - CLI 传 collectPlatformDefinitions()（已安装的 @sns-parse/platform-*）
- * 默认扩展实现同样由宿主注入（loadExtensionImplementations() 发现已安装 ext-*）；
- * core 只负责调度，不持有任何功能实现。
+ * 平台定义列表（defs）由宿主按已加载平台插件声明注入：
+ * - koishi 兼容层：collectPlatformDefinitions(anchor)（聚合包 + 粒度包并集）
+ * - CLI：collectPlatformDefinitions()
+ * 工作流阶段基线在 createDefaultPipeline()，扩展经 WorkflowExtension.setup(hooks) 注入/替换。
+ * core 不依赖任何扩展包、不含扩展实现。
  */
 import { AxiosInstance } from 'axios';
 import type { ParsedData, CustomPlatformConfig } from '../types';
 import type { VideoParserHost } from '../host';
-import type { VideoParserExtensions } from '../extensions';
+import type { WorkflowExtension } from '../extensions';
 import type { PlatformDefinition } from '../platform';
 import { SimpleLRUCache } from '../utils/cache';
 import { type DedicatedApiMaps } from './gateway';
+import type { Pipeline } from '../workflow/hooks';
 export interface ParserRuntime {
-    /** 宿主抽象（core 统一入口） */
+    /** 宿主适配（core 统一入口） */
     host: VideoParserHost;
-    /** 过渡期兼容字段：底层上下文（等同于 host.context） */
+    /** 仅在特化字段：底层运行模块（等同于 host.context） */
     ctx: any;
     config: any;
     http: AxiosInstance;
@@ -34,17 +35,19 @@ export interface ParserRuntime {
         pattern: RegExp;
         type: string;
     }[];
-    /** 平台定义列表（原生解析/翻译钩子由 fetcher 查找使用） */
+    /** 平台定义列表（原生解析/原生翻译 fetcher 阶段使用） */
     defs: PlatformDefinition[];
-    /** 平台专属端点映射（由 defs 计算；getPlatformConfig 使用） */
+    /** 平台专属 API 映射（由 defs 推导；getPlatformConfig 使用） */
     dedicatedApis: DedicatedApiMaps;
-    /** 扩展能力（默认实现 + 宿主覆盖） */
-    extensions: VideoParserExtensions;
+    /** 已加载扩展片段（能力位/配置贡献查询用；实现经管道注入） */
+    extensions: WorkflowExtension[];
+    /** 工作流阶段管道（基线 + 扩展注入） */
+    pipeline: Pipeline;
 }
 export interface CreateRuntimeOptions {
-    /** 平台定义列表（内置或已安装包收集）；缺省为空（仅自定义平台规则可用） */
+    /** 平台定义列表（按用户已加载插件声明；缺省为空，只认自定义平台配置） */
     defs?: PlatformDefinition[];
-    /** 默认扩展实现（koishi 层含 NSFW；CLI 可用 createCoreExtensions） */
-    defaultExtensions?: VideoParserExtensions;
+    /** 扩展片段（setup 钩子注入；后注册者胜） */
+    extensions?: WorkflowExtension[];
 }
 export declare function createRuntime(source: any, config: any, opts?: CreateRuntimeOptions): ParserRuntime;

package/lib/engine/runtime.js

@@ -5,13 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRuntime = createRuntime;
 /**
- * 运行时构建（自宿主 runtime 下沉，平台无关）。
+ * 运行时装配（本文件在 core 内，平台无关）。
  *
- * 平台定义列表（defs）由调用方传入：
- * - koishi 兼容层传内置 BUILTIN_PLATFORMS（本地 definitions）
- * - CLI 传 collectPlatformDefinitions()（已安装的 @sns-parse/platform-*）
- * 默认扩展实现同样由宿主注入（loadExtensionImplementations() 发现已安装 ext-*）；
- * core 只负责调度，不持有任何功能实现。
+ * 平台定义列表（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,10 +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 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);
@@ -61,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,5 +82,8 @@ function createRuntime(source, config, opts = {}) {
         defs,
         dedicatedApis,
         extensions,
+        pipeline,
     };
+    pipeline.rt = runtime;
+    return runtime;
 }

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

@@ -22,6 +22,11 @@ export * from './engine/platform-config';
 export * from './engine/translate';
 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

@@ -38,6 +38,11 @@ __exportStar(require("./engine/platform-config"), exports);
 __exportStar(require("./engine/translate"), 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/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/workflow/default.d.ts

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

package/lib/workflow/default.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultPipeline = createDefaultPipeline;
+const hooks_1 = require("./hooks");
+const fetcher = __importStar(require("../engine/fetcher"));
+const compose = __importStar(require("../engine/compose"));
+const forward = __importStar(require("../engine/forward"));
+async function sendDispatch(rt, input) {
+    const { items, session, sender, quoteId } = input;
+    const config = rt.config || {};
+    const forwardAllowed = config.enableForward && (session.platform === 'onebot' || session.platform === 'satori');
+    if (forwardAllowed) {
+        await forward.sendForward(rt, sender, session, items);
+        return;
+    }
+    if (config.sendStrategy === 'split') {
+        for (const item of items)
+            await compose.sendSplit(rt, sender, session, item, { quoteId });
+        return;
+    }
+    for (const item of items) {
+        await compose.sendSingle(rt, sender, session, item, { quoteId });
+    }
+}
+/** 构建带全部基线实现的管道；随后调用各扩展 setup(hooks) 注入/覆盖 */
+function createDefaultPipeline(rt) {
+    const p = new hooks_1.Pipeline(rt);
+    p.replace('parse', (input, r) => fetcher.fetchApi(r, input.url, input.type, input.fieldMapping, input.platformConf));
+    p.replace('translate', async () => null);
+    p.replace('media.image', async (input) => ({ kind: 'raw', url: input.url }));
+    p.replace('media.video', async (input) => ({ kind: 'raw', url: input.videoUrl }));
+    p.replace('media.merged', async (input) => ({ kind: 'raw', buffer: input.buffer, url: input.refUrl }));
+    p.replace('merge', async () => null);
+    p.replace('transcode', async () => null);
+    p.replace('compose', (input, r) => compose.buildUnits(r, input.item));
+    p.replace('send', (input, r) => sendDispatch(r, input));
+    return p;
+}

package/lib/workflow/hooks.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 工作流阶段钩子管道（core 内建完整工作流，扩展经钩子注入/修改）。
+ *
+ * 每阶段结构：{ before[], impl, after[] }
+ * - before：前置，可改输入（返回新输入；返回 undefined 表示不变）
+ * - after：后置，可改输出（返回新输出；返回 undefined 表示不变）
+ * - replace：整体替换该阶段实现（后注册者胜）
+ *
+ * 基线实现见 workflow/default.ts（无扩展时全链路可跑：
+ * 不合并逐张发 / GIF 退化发视频 / 不翻译 / 媒体直通）。
+ */
+import type { ParsedData } from '../types';
+import type { ImageOutcome, VideoOutcome, TranslateResult, GifOptions, MediaKind, VideoMeta } from '../extensions';
+import type { ProcessedItem, MessageUnit } from '../engine/compose';
+import type { OutboundSender, SessionLike } from '../sender';
+export type StageName = 'parse' | 'translate' | 'media.image' | 'media.video' | 'media.merged' | 'merge' | 'transcode' | 'compose' | 'send';
+export interface ParseInput {
+    url: string;
+    type: string;
+    fieldMapping?: Record<string, string>;
+    platformConf?: any;
+}
+export interface TranslateInput {
+    text: string;
+    target: string;
+    sourceLang?: string;
+}
+export interface MediaImageInput {
+    platform: string;
+    url: string;
+    kind: MediaKind;
+}
+export interface MediaVideoInput {
+    platform: string;
+    videoUrl: string;
+    coverUrl: string;
+    meta: VideoMeta;
+}
+export interface MediaMergedInput {
+    platform: string;
+    buffer: Buffer;
+    refUrl: string;
+}
+export interface MergeInput {
+    urls: string[];
+}
+export type MergeResult = {
+    buffer: Buffer;
+    layout?: any;
+} | null;
+export interface TranscodeInput {
+    url: string;
+    durationSec: number;
+    opts: GifOptions;
+}
+export interface ComposeInput {
+    item: ProcessedItem;
+}
+export interface SendInput {
+    items: ProcessedItem[];
+    session: SessionLike;
+    sender: OutboundSender;
+    quoteId?: string;
+}
+export interface StageIO {
+    parse: {
+        input: ParseInput;
+        output: ParsedData;
+    };
+    translate: {
+        input: TranslateInput;
+        output: TranslateResult | null;
+    };
+    'media.image': {
+        input: MediaImageInput;
+        output: ImageOutcome;
+    };
+    'media.video': {
+        input: MediaVideoInput;
+        output: VideoOutcome;
+    };
+    'media.merged': {
+        input: MediaMergedInput;
+        output: ImageOutcome | null;
+    };
+    merge: {
+        input: MergeInput;
+        output: MergeResult;
+    };
+    transcode: {
+        input: TranscodeInput;
+        output: Buffer | null;
+    };
+    compose: {
+        input: ComposeInput;
+        output: MessageUnit[];
+    };
+    send: {
+        input: SendInput;
+        output: void;
+    };
+}
+export type StageImpl<S extends StageName = StageName> = (input: StageIO[S]['input'], rt: any) => StageIO[S]['output'] | Promise<StageIO[S]['output']>;
+export type BeforeHandler<S extends StageName = StageName> = (input: StageIO[S]['input'], rt: any) => StageIO[S]['input'] | void | Promise<StageIO[S]['input'] | void>;
+export type AfterHandler<S extends StageName = StageName> = (output: StageIO[S]['output'], input: StageIO[S]['input'], rt: any) => StageIO[S]['output'] | void | Promise<StageIO[S]['output'] | void>;
+/** 扩展注入面：before/after 可插入，replace 可整体替换（后注册者胜） */
+export interface WorkflowHooks {
+    before<S extends StageName>(stage: S, h: BeforeHandler<S>): void;
+    after<S extends StageName>(stage: S, h: AfterHandler<S>): void;
+    replace<S extends StageName>(stage: S, h: StageImpl<S>): void;
+}
+export declare class Pipeline implements WorkflowHooks {
+    rt: any;
+    private impls;
+    private befores;
+    private afters;
+    constructor(rt: any);
+    before<S extends StageName>(stage: S, h: BeforeHandler<S>): void;
+    after<S extends StageName>(stage: S, h: AfterHandler<S>): void;
+    replace<S extends StageName>(stage: S, h: StageImpl<S>): void;
+    run<S extends StageName>(stage: S, input: StageIO[S]['input']): Promise<StageIO[S]['output']>;
+}
+/** 取（或懒挂）runtime 的管道；裸 rt 对象也能工作（自动挂默认管道）。 */
+export declare function ensurePipeline(rt: any): Pipeline;
+export declare function runStage<S extends StageName>(rt: any, stage: S, input: StageIO[S]['input']): Promise<StageIO[S]['output']>;

package/lib/workflow/hooks.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipeline = void 0;
+exports.ensurePipeline = ensurePipeline;
+exports.runStage = runStage;
+class Pipeline {
+    constructor(rt) {
+        this.rt = rt;
+        this.impls = new Map();
+        this.befores = new Map();
+        this.afters = new Map();
+    }
+    before(stage, h) {
+        const list = this.befores.get(stage) || [];
+        list.push(h);
+        this.befores.set(stage, list);
+    }
+    after(stage, h) {
+        const list = this.afters.get(stage) || [];
+        list.push(h);
+        this.afters.set(stage, list);
+    }
+    replace(stage, h) {
+        this.impls.set(stage, h);
+    }
+    async run(stage, input) {
+        let cur = input;
+        for (const h of this.befores.get(stage) || []) {
+            const r = await h(cur, this.rt);
+            if (r !== undefined)
+                cur = r;
+        }
+        const impl = this.impls.get(stage);
+        if (!impl)
+            throw new Error(`workflow: 阶段缺少实现: ${stage}`);
+        let out = await impl(cur, this.rt);
+        for (const h of this.afters.get(stage) || []) {
+            const r = await h(out, cur, this.rt);
+            if (r !== undefined)
+                out = r;
+        }
+        return out;
+    }
+}
+exports.Pipeline = Pipeline;
+/** 取（或懒挂）runtime 的管道；裸 rt 对象也能工作（自动挂默认管道）。 */
+function ensurePipeline(rt) {
+    if (rt && rt.pipeline instanceof Pipeline)
+        return rt.pipeline;
+    const { createDefaultPipeline } = require('./default');
+    const p = createDefaultPipeline(rt);
+    if (rt)
+        rt.pipeline = p;
+    return p;
+}
+function runStage(rt, stage, input) {
+    return ensurePipeline(rt).run(stage, input);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sns-parse/core",
-  "version": "0.5.0-alpha.1+upstream.1.6.7",
+  "version": "0.6.0-alpha.1+upstream.1.6.7",
   "description": "sns-parse 核心：契约、宿主抽象、配置 DSL 与解析引擎（fetcher/parser/翻译/X 原生解析/合并/GIF/TLS 指纹客户端）",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",