@sns-parse/ext-merge 0.1.0-alpha.1

package/lib/image-size.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 图片尺寸探测（无依赖）：PNG / GIF / JPEG / WebP 头部解析。
+ * 仅供同源切图识别用：只读宽高，不解码像素。
+ */
+export interface ImageSize {
+    width: number;
+    height: number;
+}
+/** 探测图片缓冲区尺寸；无法识别返回 null */
+export declare function probeImageSize(buf: Buffer): ImageSize | null;

package/lib/image-size.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * 图片尺寸探测（无依赖）：PNG / GIF / JPEG / WebP 头部解析。
+ * 仅供同源切图识别用：只读宽高，不解码像素。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeImageSize = probeImageSize;
+/** 探测图片缓冲区尺寸；无法识别返回 null */
+function probeImageSize(buf) {
+    if (!buf || buf.length < 12)
+        return null;
+    // PNG: 89 50 4E 47 0D 0A 1A 0A，IHDR 宽高在 16..24
+    if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) {
+        if (buf.length < 24)
+            return null;
+        return { width: buf.readUInt32BE(16), height: buf.readUInt32BE(20) };
+    }
+    // GIF: GIF8
+    if (buf.toString('ascii', 0, 4) === 'GIF8') {
+        if (buf.length < 10)
+            return null;
+        return { width: buf.readUInt16LE(6), height: buf.readUInt16LE(8) };
+    }
+    // JPEG: FF D8，扫描 SOF0/1/2/...（C0-CF，除 C4/C8/CC）段
+    if (buf[0] === 0xff && buf[1] === 0xd8) {
+        let off = 2;
+        while (off + 9 < buf.length) {
+            if (buf[off] !== 0xff) {
+                off++;
+                continue;
+            }
+            const marker = buf[off + 1];
+            if (marker >= 0xc0 && marker <= 0xcf && marker !== 0xc4 && marker !== 0xc8 && marker !== 0xcc) {
+                const height = buf.readUInt16BE(off + 5);
+                const width = buf.readUInt16BE(off + 7);
+                if (width && height)
+                    return { width, height };
+                return null;
+            }
+            if (marker === 0xd8 || (marker >= 0xd0 && marker <= 0xd9)) {
+                off += 2;
+                continue;
+            }
+            const segLen = buf.readUInt16BE(off + 2);
+            if (segLen < 2)
+                return null;
+            off += 2 + segLen;
+        }
+        return null;
+    }
+    // WebP: RIFF....WEBP
+    if (buf.toString('ascii', 0, 4) === 'RIFF' && buf.toString('ascii', 8, 12) === 'WEBP') {
+        const fourcc = buf.toString('ascii', 12, 16);
+        if (fourcc === 'VP8 ' && buf.length >= 30) {
+            return { width: buf.readUInt16LE(26) & 0x3fff, height: buf.readUInt16LE(28) & 0x3fff };
+        }
+        if (fourcc === 'VP8L' && buf.length >= 25) {
+            const b = buf.readUInt32LE(21);
+            return { width: (b & 0x3fff) + 1, height: ((b >> 14) & 0x3fff) + 1 };
+        }
+        if (fourcc === 'VP8X' && buf.length >= 30) {
+            const w = 1 + (buf[24] | (buf[25] << 8) | (buf[26] << 16));
+            const h = 1 + (buf[27] | (buf[28] << 8) | (buf[29] << 16));
+            return { width: w, height: h };
+        }
+        return null;
+    }
+    return null;
+}

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @sns-parse/ext-merge：同源切图纯内容识别与合并（依赖 ffmpeg，经 ext-gif 解析）。
+ */
+import { mergeImages } from './merge';
+export { mergeImages, candidateLayouts, verifyLayout, detectMergeLayout, xstackLayout, buildMergeFilter, } from './merge';
+export type { MergeLayout } from './merge';
+export { probeImageSize } from './image-size';
+export type { ImageSize } from './image-size';
+/** 组装为 core 扩展片段 */
+export declare function mergeExtension(): {
+    mergeImages: typeof mergeImages;
+};

package/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeImageSize = exports.buildMergeFilter = exports.xstackLayout = exports.detectMergeLayout = exports.verifyLayout = exports.candidateLayouts = exports.mergeImages = void 0;
+exports.mergeExtension = mergeExtension;
+/**
+ * @sns-parse/ext-merge：同源切图纯内容识别与合并（依赖 ffmpeg，经 ext-gif 解析）。
+ */
+const merge_1 = require("./merge");
+var merge_2 = require("./merge");
+Object.defineProperty(exports, "mergeImages", { enumerable: true, get: function () { return merge_2.mergeImages; } });
+Object.defineProperty(exports, "candidateLayouts", { enumerable: true, get: function () { return merge_2.candidateLayouts; } });
+Object.defineProperty(exports, "verifyLayout", { enumerable: true, get: function () { return merge_2.verifyLayout; } });
+Object.defineProperty(exports, "detectMergeLayout", { enumerable: true, get: function () { return merge_2.detectMergeLayout; } });
+Object.defineProperty(exports, "xstackLayout", { enumerable: true, get: function () { return merge_2.xstackLayout; } });
+Object.defineProperty(exports, "buildMergeFilter", { enumerable: true, get: function () { return merge_2.buildMergeFilter; } });
+var image_size_1 = require("./image-size");
+Object.defineProperty(exports, "probeImageSize", { enumerable: true, get: function () { return image_size_1.probeImageSize; } });
+/** 组装为 core 扩展片段 */
+function mergeExtension() {
+    return { mergeImages: merge_1.mergeImages };
+}

package/lib/merge.d.ts

@@ -0,0 +1,61 @@
+import type { ParserRuntimeLike } from '@sns-parse/core';
+import { type ImageSize } from './image-size';
+export type MergeLayout = {
+    kind: 'grid';
+    cols: number;
+    rows: number;
+} | {
+    kind: 'v';
+} | {
+    kind: 'h';
+};
+/** 仅凭数量与尺寸给出全部可行布局（内容验证前） */
+export declare function candidateLayouts(n: number, sizes: ImageSize[]): MergeLayout[];
+export interface SeamVerdict {
+    /** false = 接缝不可验证（边界带平坦，无纹理可判）或不连续 */
+    ok: boolean;
+    score: number;
+    /** 证据明细（供 debug 日志） */
+    dir: 'V' | 'H';
+    from: number;
+    to: number;
+    /** 边界带高频纹理能量（两侧最大值；低于 TEXTURE_MIN 即不可验证） */
+    texture: number;
+    /** 平滑后接缝差 */
+    trendMAD: number;
+    /** 片内自然步进基线 */
+    baseline: number;
+    /** 结论文案 */
+    reason: string;
+}
+/** 内容验证：所有接缝（趋势+纹理）均通过才成立；返回最大接缝比值与逐缝证据 */
+export declare function verifyLayout(layout: MergeLayout, grays: Buffer[]): {
+    pass: boolean;
+    score: number;
+    seams: SeamVerdict[];
+};
+/** 内容识别：候选布局逐一经接缝连续性验证，取通过者中比值最小的一个 */
+export declare function detectMergeLayout(sizes: ImageSize[], grays: Buffer[]): MergeLayout | null;
+/** 布局名（日志用） */
+export declare function layoutName(layout: MergeLayout): string;
+/**
+ * 候选布局逐一验证并产出证据链；返回通过者中证据最强（worst 接缝比值最小）的一个。
+ * 每次调用都会把逐候选、逐接缝的判定依据写入 debug 日志（含尺寸与灰度行数）。
+ */
+export declare function pickMergeLayout(sizes: ImageSize[], grays: Buffer[]): {
+    layout: MergeLayout;
+    score: number;
+    seams: SeamVerdict[];
+} | null;
+/** xstack 均匀网格布局串（各片已统一缩放为 w×h，行优先） */
+export declare function xstackLayout(cols: number, rows: number, w: number, h: number): string;
+/** 生成 ffmpeg filter_complex（输出标签恒为 [out]，导出供测试） */
+export declare function buildMergeFilter(n: number, layout: MergeLayout, sizes: ImageSize[]): string;
+/**
+ * 下载 → 灰度解码 → 内容识别接缝 → 合并。
+ * 不构成母图切片（接缝不连续）或任一环节失败 → null。
+ */
+export declare function mergeImages(rt: ParserRuntimeLike, urls: string[]): Promise<{
+    buffer: Buffer;
+    layout: MergeLayout;
+} | null>;

package/lib/merge.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.candidateLayouts = candidateLayouts;
+exports.verifyLayout = verifyLayout;
+exports.detectMergeLayout = detectMergeLayout;
+exports.layoutName = layoutName;
+exports.pickMergeLayout = pickMergeLayout;
+exports.xstackLayout = xstackLayout;
+exports.buildMergeFilter = buildMergeFilter;
+exports.mergeImages = mergeImages;
+/**
+ * 同源切图识别与合并（纯内容识别，不依赖 URL/文件名等外部信息）：
+ * - 候选布局：n∈{4,9,16} 且各片等尺寸 → n×n 宫格；各片同宽 → 垂直堆叠；各片同高 → 水平拼接
+ * - 内容验证：ffmpeg 解码为 256 宽灰度图，比较接缝两侧边界行/列的平均绝对差（MAD），
+ *   与图片内部相邻行/列的自然差异比较——母图切片在接缝处连续（比值≈1），无关图片差异显著（比值≫1）
+ * - 合并：宫格 xstack / 垂直 vstack / 水平 hstack
+ *
+ * 识别/解码/ffmpeg 任一环节失败均返回 null，调用方回退逐张发送。
+ */
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+const image_size_1 = require("./image-size");
+const ext_gif_1 = require("@sns-parse/ext-gif");
+const core_1 = require("@sns-parse/core");
+const MAX_PIECES = 12;
+/** 同一母图切出的分片尺寸精确相等，仅留极小容差防探测/编解码舍入 */
+const DIM_TOLERANCE = 2;
+const MAX_OUTPUT_SIDE = 4096;
+const MAX_TOTAL_BYTES = 150 * 1048576;
+/** 灰度归一化宽度（边界行/列向量长度基准） */
+const GRAY_W = 256;
+/** 列向量统一重采样长度 */
+const COL_LEN = 64;
+/** 接缝差异 / 内部自然差异 的判定阈值（母图切片 ≈1，无关图片 ≫1；下限 3 防平坦图除零） */
+const BOUNDARY_THRESH = 3.0;
+const MAD_FLOOR = 3.0;
+/** 边界带纹理能量下限：低于此值视为「不可验证接缝」（相似背景/平边照片会骗过亮度对比） */
+const TEXTURE_MIN = 4.0;
+/* ---------- 尺寸候选 ---------- */
+function dimsEqual(a, b, tol) {
+    return Math.abs(a.width - b.width) <= tol && Math.abs(a.height - b.height) <= tol;
+}
+/** 仅凭数量与尺寸给出全部可行布局（内容验证前） */
+function candidateLayouts(n, sizes) {
+    if (n < 2 || n > MAX_PIECES)
+        return [];
+    if (sizes.some((s) => !s || s.width < 8 || s.height < 8))
+        return [];
+    const out = [];
+    const sqrt = Math.sqrt(n);
+    if (Number.isInteger(sqrt) && sizes.every((s) => dimsEqual(s, sizes[0], DIM_TOLERANCE))) {
+        out.push({ kind: 'grid', cols: sqrt, rows: sqrt });
+    }
+    if (sizes.every((s) => Math.abs(s.width - sizes[0].width) <= DIM_TOLERANCE))
+        out.push({ kind: 'v' });
+    if (sizes.every((s) => Math.abs(s.height - sizes[0].height) <= DIM_TOLERANCE))
+        out.push({ kind: 'h' });
+    return out;
+}
+/* ---------- 灰度边界向量 ---------- */
+/** 解码为固定宽度灰度原始流（buf = rows × GRAY_W 字节） */
+function toGray(file) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)((0, ext_gif_1.resolveFfmpeg)(), [
+            '-hide_banner', '-loglevel', 'error', '-i', file,
+            '-vf', `scale=${GRAY_W}:-2:flags=area,format=gray`, '-f', 'rawvideo', 'pipe:1',
+        ]);
+        const chunks = [];
+        child.stdout.on('data', (d) => chunks.push(d));
+        child.stderr.on('data', (d) => reject(new Error(d.toString().slice(0, 120))));
+        child.on('error', (e) => reject(e));
+        child.on('close', (code) => {
+            const buf = Buffer.concat(chunks);
+            if (code === 0 && buf.length >= GRAY_W * 2)
+                resolve(buf);
+            else
+                reject(new Error(`gray decode exit ${code}`));
+        });
+    });
+}
+function grayRows(g) {
+    return Math.floor(g.length / GRAY_W);
+}
+/** 取一行（256 长） */
+function rowOf(g, r) {
+    const rows = grayRows(g);
+    const rr = Math.min(Math.max(r, 0), rows - 1);
+    const out = new Float32Array(GRAY_W);
+    for (let x = 0; x < GRAY_W; x++)
+        out[x] = g[rr * GRAY_W + x];
+    return out;
+}
+/** 取一列（重采样到 COL_LEN，适配各片灰度高度不一） */
+function colOf(g, c) {
+    const rows = grayRows(g);
+    const cc = Math.min(Math.max(c, 0), GRAY_W - 1);
+    const out = new Float32Array(COL_LEN);
+    for (let i = 0; i < COL_LEN; i++) {
+        const y = Math.min(rows - 1, Math.round((i / (COL_LEN - 1)) * (rows - 1)));
+        out[i] = g[y * GRAY_W + cc];
+    }
+    return out;
+}
+function mad(a, b) {
+    let sum = 0;
+    for (let i = 0; i < a.length; i++)
+        sum += Math.abs(a[i] - b[i]);
+    return sum / a.length;
+}
+/** 滑动平均（提取平滑趋势） */
+function smooth(v) {
+    const win = Math.max(3, Math.floor(v.length / 16) | 1);
+    const out = new Float32Array(v.length);
+    let sum = 0;
+    for (let i = 0; i < v.length; i++) {
+        sum += v[i];
+        if (i >= win)
+            sum -= v[i - win];
+        out[i] = sum / Math.min(i + 1, win);
+    }
+    return out;
+}
+/** 去趋势残差（高频纹理成分） */
+function residual(v) {
+    const s = smooth(v);
+    const out = new Float32Array(v.length);
+    for (let i = 0; i < v.length; i++)
+        out[i] = v[i] - s[i];
+    return out;
+}
+function std(v) {
+    let mean = 0;
+    for (let i = 0; i < v.length; i++)
+        mean += v[i];
+    mean /= v.length;
+    let acc = 0;
+    for (let i = 0; i < v.length; i++)
+        acc += (v[i] - mean) ** 2;
+    return Math.sqrt(acc / v.length);
+}
+/**
+ * 单条接缝裁决：
+ * - 可验证性：任一侧边界带高频纹理能量不足（TEXTURE_MIN）→ 拒绝（平坦边缘无法证明连续）
+ * - 连续性：低频成分（平滑后）的边界差 vs 片内相邻行/列的自然步进，比值 < 阈值才通过。
+ *   高频纹理逐行天然去相关、不能作匹配信号，先平滑剔除；基线取各自片内相邻对
+ *   （不可跨片比较，否则无关片间差异会稀释接缝信号）。
+ */
+function judgeSeam(edgeA, edgeB, dir, from, to, innerPairs) {
+    const texture = Math.max(std(residual(edgeA)), std(residual(edgeB)));
+    const mk = (ok, score, reason, trendMAD = 0, baseline = 0) => ({ ok, score, dir, from, to, texture, trendMAD, baseline, reason });
+    if (texture < TEXTURE_MIN)
+        return mk(false, Infinity, `纹理能量 ${texture.toFixed(1)} < ${TEXTURE_MIN}，平坦边缘不可验证`);
+    const sA = smooth(edgeA);
+    const sB = smooth(edgeB);
+    const pairs = innerPairs();
+    const innerTrend = pairs.map(([p, q]) => mad(smooth(p), smooth(q)));
+    const baseline = innerTrend.reduce((t, s) => t + s, 0) / innerTrend.length;
+    const trendRef = Math.max(baseline, MAD_FLOOR);
+    const trendMAD = mad(sA, sB);
+    const score = trendMAD / trendRef;
+    return mk(score < BOUNDARY_THRESH, score, score < BOUNDARY_THRESH
+        ? `连续（趋势差 ${trendMAD.toFixed(1)} / 基线 ${trendRef.toFixed(1)} = ${score.toFixed(2)} < ${BOUNDARY_THRESH}，纹理 ${texture.toFixed(1)}）`
+        : `不连续（趋势差 ${trendMAD.toFixed(1)} / 基线 ${trendRef.toFixed(1)} = ${score.toFixed(2)} ≥ ${BOUNDARY_THRESH}，纹理 ${texture.toFixed(1)}）`, trendMAD, baseline);
+}
+/** 垂直接缝：A 末行 vs B 首行（基线取各自片内相邻行对） */
+function seamVerdictV(a, b, from, to) {
+    const r = grayRows(a);
+    return judgeSeam(rowOf(a, r - 1), rowOf(b, 0), 'V', from, to, () => [
+        [rowOf(a, r - 2), rowOf(a, r - 1)],
+        [rowOf(a, r - 3), rowOf(a, r - 2)],
+        [rowOf(b, 1), rowOf(b, 0)],
+        [rowOf(b, 2), rowOf(b, 1)],
+    ]);
+}
+/** 水平接缝：A 末列 vs B 首列（基线取各自片内相邻列对） */
+function seamVerdictH(a, b, from, to) {
+    return judgeSeam(colOf(a, GRAY_W - 1), colOf(b, 0), 'H', from, to, () => [
+        [colOf(a, GRAY_W - 2), colOf(a, GRAY_W - 1)],
+        [colOf(a, GRAY_W - 3), colOf(a, GRAY_W - 2)],
+        [colOf(b, 1), colOf(b, 0)],
+        [colOf(b, 2), colOf(b, 1)],
+    ]);
+}
+/** 内容验证：所有接缝（趋势+纹理）均通过才成立；返回最大接缝比值与逐缝证据 */
+function verifyLayout(layout, grays) {
+    const seams = [];
+    const n = grays.length;
+    if (layout.kind === 'v') {
+        for (let i = 0; i + 1 < n; i++)
+            seams.push(seamVerdictV(grays[i], grays[i + 1], i, i + 1));
+    }
+    else if (layout.kind === 'h') {
+        for (let i = 0; i + 1 < n; i++)
+            seams.push(seamVerdictH(grays[i], grays[i + 1], i, i + 1));
+    }
+    else {
+        const { cols } = layout;
+        for (let i = 0; i < n; i++) {
+            if (i % cols < cols - 1 && i + 1 < n)
+                seams.push(seamVerdictH(grays[i], grays[i + 1], i, i + 1));
+            if (i + cols < n)
+                seams.push(seamVerdictV(grays[i], grays[i + cols], i, i + cols));
+        }
+    }
+    if (!seams.length)
+        return { pass: false, score: Infinity, seams };
+    const worst = Math.max(...seams.map((v) => v.score));
+    return { pass: seams.every((v) => v.ok), score: worst, seams };
+}
+/** 内容识别：候选布局逐一经接缝连续性验证，取通过者中比值最小的一个 */
+function detectMergeLayout(sizes, grays) {
+    return pickMergeLayout(sizes, grays)?.layout ?? null;
+}
+/** 布局名（日志用） */
+function layoutName(layout) {
+    return layout.kind === 'grid' ? `网格 ${layout.cols}x${layout.rows}` : layout.kind === 'v' ? '竖堆（水平切分）' : '横拼（垂直切分）';
+}
+/**
+ * 候选布局逐一验证并产出证据链；返回通过者中证据最强（worst 接缝比值最小）的一个。
+ * 每次调用都会把逐候选、逐接缝的判定依据写入 debug 日志（含尺寸与灰度行数）。
+ */
+function pickMergeLayout(sizes, grays) {
+    const candidates = candidateLayouts(sizes.length, sizes);
+    (0, core_1.debugLog)(`同源合并候选：${sizes.length} 张，尺寸 ${sizes.map((s) => `${s.width}x${s.height}`).join(' / ')}，灰度行数 ${grays.map((g) => grayRows(g)).join('/')}`);
+    if (!candidates.length) {
+        (0, core_1.debugLog)('同源合并候选：无（数量/尺寸组合不构成网格/竖堆/横拼任何可能）');
+        return null;
+    }
+    let best = null;
+    for (const c of candidates) {
+        const { pass, score, seams } = verifyLayout(c, grays);
+        const detail = seams.map((v) => `[${v.dir === 'V' ? '竖' : '横'}缝 ${v.from}→${v.to}] ${v.reason}`).join('；');
+        (0, core_1.debugLog)(`同源合并证据·${layoutName(c)}：${pass ? '通过' : '拒绝'}，worst=${score === Infinity ? '∞' : score.toFixed(2)} ⟶ ${detail}`);
+        if (pass && (!best || score < best.score))
+            best = { layout: c, score, seams };
+    }
+    if (best)
+        (0, core_1.debugLog)(`同源合并裁决：${layoutName(best.layout)}（证据最强，worst 接缝比值 ${best.score.toFixed(2)}）`);
+    else
+        (0, core_1.debugLog)('同源合并裁决：全部候选未通过内容验证 → 逐张发送');
+    return best;
+}
+/* ---------- ffmpeg 合并 ---------- */
+/** xstack 均匀网格布局串（各片已统一缩放为 w×h，行优先） */
+function xstackLayout(cols, rows, w, h) {
+    const parts = [];
+    for (let i = 0; i < cols * rows; i++) {
+        const x = (i % cols) * w;
+        const y = Math.floor(i / cols) * h;
+        parts.push(`${x}_${y}`);
+    }
+    return parts.join('|');
+}
+/** 生成 ffmpeg filter_complex（输出标签恒为 [out]，导出供测试） */
+function buildMergeFilter(n, layout, sizes) {
+    const chains = [];
+    const stacks = [];
+    const chainOf = (stack, outW, outH) => {
+        if (outW > MAX_OUTPUT_SIDE || outH > MAX_OUTPUT_SIDE) {
+            const scale = Math.min(1, MAX_OUTPUT_SIDE / Math.max(outW, outH));
+            return `${stack}[tmp];[tmp]scale=${Math.round(outW * scale) / 2 * 2}:${Math.round(outH * scale) / 2 * 2}:flags=lanczos[out]`;
+        }
+        return `${stack}[out]`;
+    };
+    if (layout.kind === 'grid') {
+        // 宫格拼图：各片等比缩放进统一格子（不足处黑边补齐——切片场景无补边，杂图集保持各自比例），
+        // 逐片 concat 成帧序列后 tile 出宫格（支持非满宫格，如 7 图 3x3）
+        const cellW = Math.min(Math.max(...sizes.map((s) => s.width)), 1920);
+        const cellH = Math.min(Math.max(...sizes.map((s) => s.height)), 1920);
+        const cw = Math.ceil(cellW / 2) * 2;
+        const ch = Math.ceil(cellH / 2) * 2;
+        for (let i = 0; i < n; i++) {
+            chains.push(`[${i}:v]scale=${cw}:${ch}:force_original_aspect_ratio=decrease:flags=lanczos,pad=${cw}:${ch}:(ow-iw)/2:(oh-ih)/2:color=black,setsar=1[c${i}]`);
+            stacks.push(`[c${i}]`);
+        }
+        chains.push(`${stacks.join('')}concat=n=${n}:v=1:a=0[frames]`);
+        chains.push(chainOf(`[frames]tile=${layout.cols}x${layout.rows}`, layout.cols * cw, layout.rows * ch));
+    }
+    else if (layout.kind === 'v') {
+        const w = Math.max(...sizes.map((s) => s.width));
+        for (let i = 0; i < n; i++)
+            chains.push(`[${i}:v]scale=${w}:-2:flags=lanczos[s${i}]`);
+        for (let i = 0; i < n; i++)
+            stacks.push(`[s${i}]`);
+        chains.push(chainOf(`${stacks.join('')}vstack=inputs=${n}`, w, sizes.reduce((t, s) => t + s.height, 0)));
+    }
+    else {
+        const h = Math.max(...sizes.map((s) => s.height));
+        for (let i = 0; i < n; i++)
+            chains.push(`[${i}:v]scale=-2:${h}:flags=lanczos[s${i}]`);
+        for (let i = 0; i < n; i++)
+            stacks.push(`[s${i}]`);
+        chains.push(chainOf(`${stacks.join('')}hstack=inputs=${n}`, sizes.reduce((t, s) => t + s.width, 0), h));
+    }
+    return chains.join(';');
+}
+/** 按魔数给临时文件配扩展名（ffmpeg 也可自行探测，显式更稳） */
+function extOf(buf) {
+    if (buf[0] === 0x89 && buf[1] === 0x50)
+        return 'png';
+    if (buf[0] === 0xff && buf[1] === 0xd8)
+        return 'jpg';
+    if (buf.toString('ascii', 0, 4) === 'RIFF')
+        return 'webp';
+    if (buf.toString('ascii', 0, 4) === 'GIF8')
+        return 'gif';
+    return 'bin';
+}
+const MERGE_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36';
+function downloadImage(rt, url) {
+    const headers = { 'User-Agent': MERGE_UA };
+    headers['Referer'] = /twimg\.com/.test(url) ? 'https://twitter.com/' : 'https://www.baidu.com/';
+    return rt.http.get(url, { responseType: 'arraybuffer', timeout: 30000, headers })
+        .then((res) => Buffer.from(res.data));
+}
+/**
+ * 下载 → 灰度解码 → 内容识别接缝 → 合并。
+ * 不构成母图切片（接缝不连续）或任一环节失败 → null。
+ */
+async function mergeImages(rt, urls) {
+    if (urls.length < 2 || urls.length > MAX_PIECES)
+        return null;
+    let buffers;
+    try {
+        buffers = await Promise.all(urls.map((u) => downloadImage(rt, u)));
+    }
+    catch (e) {
+        (0, core_1.debugLog)(`切图合并跳过（分片下载失败）：${e?.message || e}`);
+        return null;
+    }
+    const total = buffers.reduce((t, b) => t + b.length, 0);
+    if (total > MAX_TOTAL_BYTES || buffers.some((b) => !b.length))
+        return null;
+    const sizes = buffers.map((b) => (0, image_size_1.probeImageSize)(b));
+    if (sizes.some((s) => !s))
+        return null;
+    const dir = await (0, promises_1.mkdtemp)((0, path_1.join)((0, os_1.tmpdir)(), `vpa-merge-${(0, crypto_1.randomBytes)(4).toString('hex')}-`));
+    try {
+        const files = [];
+        for (let i = 0; i < buffers.length; i++) {
+            const f = (0, path_1.join)(dir, `${i}.${extOf(buffers[i])}`);
+            await (0, promises_1.writeFile)(f, buffers[i]);
+            files.push(f);
+        }
+        // 布局决策（完全由像素内容裁决，不依赖数量规则、链接/文件名与色调风格）：
+        // 网格/竖堆/横拼三种布局候选（按尺寸可能性给出），逐一经接缝内容验证
+        // （亮度趋势 + 去趋势纹理双通道、平坦边缘不可验证即拒绝），
+        // 取通过者中证据最强（接缝比值最小）的一种——真 2x2/3x3 切片网格缝连续、
+        // 长图条带单向连续、无关图全部不过；合并方式由内容区分，均不过则逐张发送
+        let grays;
+        try {
+            grays = await Promise.all(files.map(toGray));
+        }
+        catch (e) {
+            (0, core_1.debugLog)(`切图合并跳过（灰度解码失败）：${e?.message || e}`);
+            return null;
+        }
+        const picked = pickMergeLayout(sizes, grays);
+        if (!picked)
+            return null;
+        const layout = picked.layout;
+        const filter = buildMergeFilter(files.length, layout, sizes);
+        const args = ['-hide_banner', '-loglevel', 'error', ...files.flatMap((f) => ['-i', f]),
+            '-filter_complex', filter, '-map', '[out]', '-frames:v', '1', '-q:v', '2',
+            '-f', 'image2pipe', '-c:v', 'mjpeg', 'pipe:1'];
+        const out = await new Promise((resolve) => {
+            const child = (0, child_process_1.spawn)((0, ext_gif_1.resolveFfmpeg)(), args);
+            const chunks = [];
+            child.stdout.on('data', (d) => chunks.push(d));
+            child.stderr.on('data', () => { });
+            child.on('error', () => resolve(null));
+            child.on('close', (code) => resolve(code === 0 && chunks.length ? Buffer.concat(chunks) : null));
+        });
+        if (!out) {
+            (0, core_1.debugLog)(`切图合并失败（ffmpeg 退出非 0），回退逐张发送`);
+            return null;
+        }
+        const desc = layout.kind === 'grid' ? `${layout.cols}x${layout.rows} 宫格` : layout.kind === 'v' ? '垂直堆叠' : '水平拼接';
+        core_1.logger.info(`同源切图已合并为一张（内容识别：${urls.length} 张 → ${desc}，${Math.round(out.length / 1024)}KB）`);
+        return { buffer: out, layout };
+    }
+    finally {
+        (0, promises_1.rm)(dir, { recursive: true, force: true }).catch(() => { });
+    }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@sns-parse/ext-merge",
+  "version": "0.1.0-alpha.1+upstream.1.6.7",
+  "description": "sns-parse 扩展：merge",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf lib",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@sns-parse/core": "^0.1.0",
+    "@sns-parse/ext-gif": "^0.1.0-alpha.1"
+  },
+  "optionalDependencies": {
+    "ffmpeg-static": "^5.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "rimraf": "^5.0.5",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sns-parse/extensions.git",
+    "directory": "packages/ext-merge"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}