rn-update-cli 1.0.0

package/lib/diff.js

@@ -0,0 +1,690 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffCommands = exports.readEntry = exports.enumZipEntries = void 0;
+exports.zipEntryContentKey = zipEntryContentKey;
+exports.zipEntriesHaveSameContent = zipEntriesHaveSameContent;
+/**
+ * [INPUT]: 依赖 ZIP 读写工具、native-package 条目映射、HDiff 实现与 Hermes 字节码变换能力
+ * [OUTPUT]: 对外提供 diffCommands、ZIP 读取工具重导出及条目内容比较函数
+ * [POS]: CLI 本地补丁生成层，将旧 PPK 或原生基线与目标 PPK 转为补丁文件；上传登记由 standalone-publish 承担，普通发布不会自动调用本层
+ */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("fs-extra"));
+const global_dirs_1 = require("global-dirs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const yazl_1 = require("yazl");
+const native_package_1 = require("./native-package");
+const utils_1 = require("./utils");
+const constants_1 = require("./utils/constants");
+const hbcTransform_1 = require("./utils/hbcTransform");
+const i18n_1 = require("./utils/i18n");
+const zip_entries_1 = require("./utils/zip-entries");
+Object.defineProperty(exports, "enumZipEntries", { enumerable: true, get: function () { return zip_entries_1.enumZipEntries; } });
+Object.defineProperty(exports, "readEntry", { enumerable: true, get: function () { return zip_entries_1.readEntry; } });
+const zip_options_1 = require("./utils/zip-options");
+/**
+ * 判定两个 zip entry 内容相同的键:crc32 单独并不足以证明内容一致(32 位
+ * 校验和碰撞并不罕见,尤其是长度不同的文件),必须同时要求解压后长度相等。
+ * 仅用于生成端匹配,manifest 里的 copies / copiesCrc 格式不变。
+ */
+function zipEntryContentKey(entry) {
+    return `${entry.crc32}:${entry.uncompressedSize}`;
+}
+function zipEntriesHaveSameContent(left, right) {
+    return (left.crc32 === right.crc32 &&
+        left.uncompressedSize === right.uncompressedSize);
+}
+const loadModule = (pkgName) => {
+    const nodePathDirs = (process.env.NODE_PATH || '')
+        .split(path_1.default.delimiter)
+        .filter(Boolean);
+    const resolvePaths = ['.', ...nodePathDirs, global_dirs_1.npm.packages, global_dirs_1.yarn.packages];
+    try {
+        const resolved = require.resolve(pkgName, { paths: resolvePaths });
+        return require(resolved);
+    }
+    catch { }
+    return undefined;
+};
+const hdiff = loadModule('node-hdiffpatch');
+function basename(fn) {
+    const m = /^(.+\/)[^/]+\/?$/.exec(fn);
+    return m?.[1];
+}
+function createOutputZip(output) {
+    fs.ensureDirSync(path_1.default.dirname(output));
+    const zipfile = new yazl_1.ZipFile();
+    const writeStream = fs.createWriteStream(output);
+    const writePromise = new Promise((resolve, reject) => {
+        zipfile.outputStream.on('error', reject);
+        // without this, a full disk / read-only target left the promise pending
+        writeStream.on('error', reject);
+        zipfile.outputStream.pipe(writeStream).on('close', () => {
+            resolve(void 0);
+        });
+    });
+    // 失败时释放输出 fd 并删掉半成品,避免残留一个截断的 patch 包
+    const abort = async () => {
+        writePromise.catch(() => { });
+        zipfile.outputStream.unpipe(writeStream);
+        // yazl 的 outputStream 类型声明缺 destroy,运行时是 PassThrough
+        zipfile.outputStream.destroy();
+        if (!writeStream.closed) {
+            // 等 fd 真正关闭再删文件,避免 Windows 上删除被占用文件失败
+            await new Promise((resolve) => {
+                writeStream.once('close', () => resolve());
+                if (!writeStream.destroyed) {
+                    writeStream.destroy();
+                }
+            });
+        }
+        await fs.rm(output, { force: true });
+    };
+    return { zipfile, writePromise, abort };
+}
+/**
+ * 打开输出包,执行 build 填充条目并返回 manifest,最后写入 __diff.json
+ * 收尾。build 或收尾任何一步失败都会关闭输出流、删除半成品并重新抛出。
+ */
+async function writeDiffZip(output, build) {
+    const { zipfile, writePromise, abort } = createOutputZip(output);
+    try {
+        const manifest = await build(zipfile);
+        await finishDiffZip(zipfile, writePromise, manifest);
+    }
+    catch (error) {
+        await abort();
+        throw error;
+    }
+}
+// baseline patch 小于该值时跳过变换尝试:节省一次 diff 的 CPU,
+// 且此时变换收益上限(~25%)也抵不过元数据开销
+const HBC_TRANSFORM_MIN_BASELINE_BYTES = 64 * 1024;
+function reportDiffPhase(options, metric) {
+    try {
+        options.onDiffPhase?.(metric);
+    }
+    catch {
+        // Observability must never break patch generation.
+    }
+}
+const bundleSourceSize = (source) => source.kind === 'buffer' ? source.data.length : source.size;
+const bundleSourceBuffer = async (source) => source.kind === 'buffer' ? source.data : fs.readFile(source.path);
+async function bundleSourceFile(source, outputPath) {
+    if (source.kind === 'file') {
+        return source.path;
+    }
+    await fs.writeFile(outputPath, source.data);
+    return outputPath;
+}
+async function hashFile(filePath) {
+    const hash = (0, node_crypto_1.createHash)('sha256');
+    for await (const chunk of fs.createReadStream(filePath)) {
+        hash.update(chunk);
+    }
+    return hash.digest('hex');
+}
+async function filesEqual(leftPath, rightPath) {
+    const [leftStat, rightStat] = await Promise.all([
+        fs.stat(leftPath),
+        fs.stat(rightPath),
+    ]);
+    if (leftStat.size !== rightStat.size) {
+        return false;
+    }
+    const [leftHash, rightHash] = await Promise.all([
+        hashFile(leftPath),
+        hashFile(rightPath),
+    ]);
+    return leftHash === rightHash;
+}
+/**
+ * 大 bundle 流式路径:bundle 直接从 ZIP entry 落盘后传入 native,
+ * 避免 old/new/restored 的整块 Buffer 副本。HBC 变换 T/T⁻¹ 也在文件上
+ * 按段定位改写(transformHbcFile),全程不持有整个 bundle。native 已
+ * 自校验的普通产物不再重复 patch;自定义/变换路径仍保留 round-trip 校验。
+ */
+async function buildStreamBundlePatch(originSource, newSource, options, workRoot) {
+    const diffStreamFn = options.diffStreamFn;
+    const patchStreamFn = options.patchStreamFn;
+    if (!diffStreamFn || !patchStreamFn) {
+        throw new Error('stream diff requires diffStream/patchStream from node-hdiffpatch');
+    }
+    const tempRoot = fs.mkdtempSync(path_1.default.join(workRoot, 'stream-'));
+    const inputBytes = bundleSourceSize(originSource) + bundleSourceSize(newSource);
+    const extractionDurationMs = (originSource.kind === 'file' ? originSource.materializeDurationMs : 0) +
+        (newSource.kind === 'file' ? newSource.materializeDurationMs : 0);
+    let phaseStartedAt = performance.now();
+    const rawOldFile = await bundleSourceFile(originSource, path_1.default.join(tempRoot, 'old.bin'));
+    const rawNewFile = await bundleSourceFile(newSource, path_1.default.join(tempRoot, 'new.bin'));
+    // 变换走文件版 T:只读头部选布局、按段定位改写,不把 bundle 读进内存
+    const transformedOldFile = path_1.default.join(tempRoot, 'old-transformed.bin');
+    const transformedNewFile = path_1.default.join(tempRoot, 'new-transformed.bin');
+    const pair = options.hbcTransform
+        ? await (0, hbcTransform_1.tryTransformPairFiles)(rawOldFile, rawNewFile, transformedOldFile, transformedNewFile)
+        : null;
+    reportDiffPhase(options, {
+        phase: 'materialize',
+        durationMs: extractionDurationMs + performance.now() - phaseStartedAt,
+        inputBytes,
+    });
+    // 与内存路径同一约束:变换候选连同元数据开销必须比 baseline 更小才采用,
+    // 因此变换命中时两个候选都要生成再比较。
+    phaseStartedAt = performance.now();
+    const rawPatchFile = path_1.default.join(tempRoot, 'patch-raw.bin');
+    await diffStreamFn(rawOldFile, rawNewFile, rawPatchFile);
+    let patchFile = rawPatchFile;
+    let patchBytes = (await fs.stat(rawPatchFile)).size;
+    let chosenPair = null;
+    if (pair) {
+        const transformedPatchFile = path_1.default.join(tempRoot, 'patch-transformed.bin');
+        await diffStreamFn(transformedOldFile, transformedNewFile, transformedPatchFile);
+        const transformedPatchBytes = (await fs.stat(transformedPatchFile)).size;
+        const metaOverhead = Buffer.byteLength(JSON.stringify(pair.meta));
+        if (transformedPatchBytes + metaOverhead < patchBytes) {
+            patchFile = transformedPatchFile;
+            patchBytes = transformedPatchBytes;
+            chosenPair = pair;
+        }
+    }
+    reportDiffPhase(options, {
+        phase: 'diff',
+        durationMs: performance.now() - phaseStartedAt,
+        inputBytes,
+        outputBytes: patchBytes,
+    });
+    // 变换路径必须验证 T⁻¹ 和元数据;未声明自校验的自定义 diff 也保留
+    // round-trip。node-hdiffpatch native 普通路径已经在返回前完整验证。
+    if (chosenPair || !options.streamOutputVerified) {
+        phaseStartedAt = performance.now();
+        const restoredFile = path_1.default.join(tempRoot, 'restored.bin');
+        await patchStreamFn(chosenPair ? transformedOldFile : rawOldFile, patchFile, restoredFile);
+        if (chosenPair) {
+            // T⁻¹ 同样在文件上按段改写,再以流式哈希比对,内存与 bundle 大小无关
+            const restoredRawFile = path_1.default.join(tempRoot, 'restored-raw.bin');
+            const inverted = await (0, hbcTransform_1.transformHbcFile)(restoredFile, restoredRawFile, chosenPair.layout, true);
+            if (!inverted || !(await filesEqual(restoredRawFile, rawNewFile))) {
+                throw new Error('stream diff round-trip verification failed');
+            }
+        }
+        else if (!(await filesEqual(restoredFile, rawNewFile))) {
+            throw new Error('stream diff round-trip verification failed');
+        }
+        reportDiffPhase(options, {
+            phase: 'verify',
+            durationMs: performance.now() - phaseStartedAt,
+            inputBytes,
+            outputBytes: patchBytes,
+        });
+    }
+    else {
+        reportDiffPhase(options, {
+            phase: 'verify',
+            durationMs: 0,
+            inputBytes,
+            outputBytes: patchBytes,
+            skipped: true,
+        });
+    }
+    return {
+        patch: { kind: 'file', path: patchFile },
+        ...(chosenPair ? { hbcTransform: chosenPair.meta } : {}),
+    };
+}
+/**
+ * 生成 bundle patch:默认现状路径;开启 hbcTransform 时对 Hermes bundle
+ * 做双候选择优(baseline vs 变换域 + 元数据开销),且变换候选必须通过
+ * 本地 round-trip 还原自检才会被采用——收益永不为负,未知格式天然安全。
+ */
+async function buildBundlePatch(diffFn, originSource, newSource, options, workRoot) {
+    if (options.streamThresholdBytes &&
+        originSource &&
+        Math.max(bundleSourceSize(originSource), bundleSourceSize(newSource)) >=
+            options.streamThresholdBytes) {
+        return buildStreamBundlePatch(originSource, newSource, options, workRoot);
+    }
+    const [originBuffer, newBuffer] = await Promise.all([
+        originSource
+            ? bundleSourceBuffer(originSource)
+            : Promise.resolve(undefined),
+        bundleSourceBuffer(newSource),
+    ]);
+    const baseline = await diffFn(originBuffer, newBuffer);
+    if (!options.hbcTransform ||
+        !options.patchFn ||
+        !originBuffer ||
+        baseline.length <
+            (options.minBaselineBytes ?? HBC_TRANSFORM_MIN_BASELINE_BYTES)) {
+        return { patch: { kind: 'buffer', data: baseline } };
+    }
+    const pair = (0, hbcTransform_1.tryTransformPair)(originBuffer, newBuffer);
+    if (!pair) {
+        return { patch: { kind: 'buffer', data: baseline } };
+    }
+    try {
+        const candidate = await diffFn(pair.tOld, pair.tNew);
+        const metaOverhead = Buffer.byteLength(JSON.stringify(pair.meta));
+        if (candidate.length + metaOverhead >= baseline.length) {
+            return { patch: { kind: 'buffer', data: baseline } };
+        }
+        // patched 是 patchFn 新返回的 Buffer,原地做 T⁻¹ 省去一次整块拷贝
+        const patched = options.patchFn(pair.tOld, candidate);
+        if (!(0, hbcTransform_1.transformHbcWithLayoutInPlace)(patched, pair.layout, true) ||
+            Buffer.compare(patched, newBuffer) !== 0) {
+            console.warn((0, i18n_1.t)('hbcTransformRoundTripFailed'));
+            return { patch: { kind: 'buffer', data: baseline } };
+        }
+        return {
+            patch: { kind: 'buffer', data: candidate },
+            hbcTransform: pair.meta,
+        };
+    }
+    catch {
+        return { patch: { kind: 'buffer', data: baseline } };
+    }
+}
+async function addBundlePatch(zipfile, entry, nextZipfile, diffFn, originSource, bundleOptions, hbcTransformMetas, workRoot) {
+    const shouldStream = !!bundleOptions.streamThresholdBytes &&
+        !!originSource &&
+        Math.max(bundleSourceSize(originSource), entry.uncompressedSize) >=
+            bundleOptions.streamThresholdBytes;
+    let newSource;
+    if (shouldStream) {
+        const nextRoot = fs.mkdtempSync(path_1.default.join(workRoot, 'next-'));
+        const nextPath = path_1.default.join(nextRoot, 'bundle.bin');
+        const startedAt = performance.now();
+        await (0, zip_entries_1.writeEntry)(entry, nextZipfile, nextPath);
+        newSource = {
+            kind: 'file',
+            path: nextPath,
+            size: entry.uncompressedSize,
+            materializeDurationMs: performance.now() - startedAt,
+        };
+    }
+    else {
+        newSource = { kind: 'buffer', data: await (0, zip_entries_1.readEntry)(entry, nextZipfile) };
+    }
+    const { patch, hbcTransform } = await buildBundlePatch(diffFn, originSource, newSource, bundleOptions, workRoot);
+    const patchEntryName = `${entry.fileName}.patch`;
+    if (hbcTransform) {
+        hbcTransformMetas[patchEntryName] = hbcTransform;
+    }
+    if (patch.kind === 'file') {
+        zipfile.addFile(patch.path, patchEntryName, (0, zip_options_1.zipOptionsForPatchEntry)());
+    }
+    else {
+        zipfile.addBuffer(patch.data, patchEntryName, (0, zip_options_1.zipOptionsForPatchEntry)());
+    }
+}
+async function readOriginBundleSource(entry, zipFile, bundleOptions, workRoot) {
+    if (!bundleOptions.streamThresholdBytes) {
+        return { kind: 'buffer', data: await (0, zip_entries_1.readEntry)(entry, zipFile) };
+    }
+    const originRoot = fs.mkdtempSync(path_1.default.join(workRoot, 'origin-'));
+    const originPath = path_1.default.join(originRoot, 'bundle.bin');
+    const startedAt = performance.now();
+    await (0, zip_entries_1.writeEntry)(entry, zipFile, originPath);
+    return {
+        kind: 'file',
+        path: originPath,
+        size: entry.uncompressedSize,
+        materializeDurationMs: performance.now() - startedAt,
+    };
+}
+async function addFileFromZipEntry(zipfile, entry, nextZipfile) {
+    const entryPrefix = await (0, zip_entries_1.readEntryPrefix)(entry, nextZipfile, zip_options_1.ZIP_ENTRY_SNIFF_BYTES);
+    await new Promise((resolve, reject) => {
+        nextZipfile.openReadStream(entry, (err, readStream) => {
+            if (err) {
+                return reject(err);
+            }
+            if (!readStream) {
+                return reject(new Error(`Unable to read zip entry: ${entry.fileName}`));
+            }
+            zipfile.addReadStream(readStream, entry.fileName, (0, zip_options_1.zipOptionsForPayloadEntry)(entry.fileName, entryPrefix));
+            readStream.on('error', reject);
+            readStream.on('end', () => {
+                resolve(void 0);
+            });
+        });
+    });
+}
+function finishDiffZip(zipfile, writePromise, manifest) {
+    const diffManifest = Buffer.from(JSON.stringify(manifest));
+    zipfile.addBuffer(diffManifest, '__diff.json', (0, zip_options_1.zipOptionsForManifestEntry)(diffManifest.length));
+    zipfile.end();
+    return writePromise;
+}
+async function diffFromPPK(origin, next, output, diffFn, bundleOptions, workRoot) {
+    const originEntries = {};
+    const originMap = {};
+    let originSource;
+    await (0, zip_entries_1.enumZipEntries)(origin, async (entry, zipFile) => {
+        originEntries[entry.fileName] = entry;
+        if (!/\/$/.test(entry.fileName)) {
+            // isFile
+            originMap[zipEntryContentKey(entry)] = entry.fileName;
+            if ((0, constants_1.isPPKBundleFileName)(entry.fileName)) {
+                // This is source.
+                originSource = await readOriginBundleSource(entry, zipFile, bundleOptions, workRoot);
+            }
+        }
+    });
+    if (!originSource) {
+        throw new Error((0, i18n_1.t)('bundleFileNotFound'));
+    }
+    const copies = {};
+    const bundleSource = originSource;
+    await writeDiffZip(output, async (zipfile) => {
+        const addedEntry = {};
+        function addEntry(fn) {
+            //console.log(fn);
+            if (!fn || addedEntry[fn]) {
+                return;
+            }
+            addedEntry[fn] = true;
+            const base = basename(fn);
+            if (base) {
+                addEntry(base);
+            }
+            zipfile.addEmptyDirectory(fn);
+        }
+        const newEntries = {};
+        const hbcTransformMetas = {};
+        await (0, zip_entries_1.enumZipEntries)(next, async (entry, nextZipfile) => {
+            newEntries[entry.fileName] = entry;
+            if (/\/$/.test(entry.fileName)) {
+                // Directory
+                if (!originEntries[entry.fileName]) {
+                    addEntry(entry.fileName);
+                }
+            }
+            else if ((0, constants_1.isPPKBundleFileName)(entry.fileName)) {
+                await addBundlePatch(zipfile, entry, nextZipfile, diffFn, bundleSource, bundleOptions, hbcTransformMetas, workRoot);
+            }
+            else {
+                // If same file.
+                const originEntry = originEntries[entry.fileName];
+                if (originEntry && zipEntriesHaveSameContent(originEntry, entry)) {
+                    // ignore
+                    return;
+                }
+                // If moved from other place
+                const movedFrom = originMap[zipEntryContentKey(entry)];
+                if (movedFrom) {
+                    const base = basename(entry.fileName);
+                    if (base && !originEntries[base]) {
+                        addEntry(base);
+                    }
+                    copies[entry.fileName] = movedFrom;
+                    return;
+                }
+                // New file.
+                const basePath = basename(entry.fileName);
+                if (basePath) {
+                    addEntry(basePath);
+                }
+                await addFileFromZipEntry(zipfile, entry, nextZipfile);
+            }
+        });
+        const deletes = {};
+        for (const k in originEntries) {
+            if (!newEntries[k]) {
+                console.log((0, i18n_1.t)('deleteFile', { file: k }));
+                deletes[k] = 1;
+            }
+        }
+        return {
+            copies,
+            deletes,
+            ...(Object.keys(hbcTransformMetas).length
+                ? { hbcTransform: hbcTransformMetas }
+                : {}),
+        };
+    });
+}
+async function diffFromPackage(origin, next, output, diffFn, platform, bundleOptions, workRoot) {
+    // 路径 → 内容键(crc32 + 解压后长度)
+    const originEntries = {};
+    const originMap = {};
+    let originSource;
+    // Content checksum (CRC32) for every copied entry, keyed by target path.
+    // Two consumers on the client: locating a file by content when its origin
+    // path is not present verbatim on device (APK baseline diff applied on an
+    // AAB/split-apk install whose res/ paths were shortened), and verifying
+    // that a path-matched file still has the expected bytes before copying
+    // (BUNDLEHASH_MIGRATION.md §4.2.1 — a rebuilt binary may keep the path but
+    // drift the content; mismatch must fall back to full instead of silently
+    // installing a wrong resource).
+    const copiesCrc = {};
+    await (0, zip_entries_1.enumZipEntries)(origin, async (entry, zipFile) => {
+        if (!/\/$/.test(entry.fileName)) {
+            const resolvedEntry = (0, native_package_1.resolveNativePackageEntry)(platform, entry.fileName);
+            if (!resolvedEntry) {
+                return;
+            }
+            const fn = resolvedEntry.diffPath;
+            //console.log(fn);
+            // isFile
+            const contentKey = zipEntryContentKey(entry);
+            originEntries[fn] = contentKey;
+            originMap[contentKey] = fn;
+            if (resolvedEntry.kind === 'bundle') {
+                // This is source.
+                originSource = await readOriginBundleSource(entry, zipFile, bundleOptions, workRoot);
+            }
+        }
+    });
+    if (!originSource) {
+        throw new Error((0, i18n_1.t)('bundleFileNotFound'));
+    }
+    const copies = {};
+    const bundleSource = originSource;
+    await writeDiffZip(output, async (zipfile) => {
+        const hbcTransformMetas = {};
+        await (0, zip_entries_1.enumZipEntries)(next, async (entry, nextZipfile) => {
+            if (/\/$/.test(entry.fileName)) {
+                // Directory
+                zipfile.addEmptyDirectory(entry.fileName);
+            }
+            else if ((0, constants_1.isPPKBundleFileName)(entry.fileName)) {
+                await addBundlePatch(zipfile, entry, nextZipfile, diffFn, bundleSource, bundleOptions, hbcTransformMetas, workRoot);
+            }
+            else {
+                // If same file.
+                const contentKey = zipEntryContentKey(entry);
+                if (originEntries[entry.fileName] === contentKey) {
+                    copies[entry.fileName] = '';
+                    copiesCrc[entry.fileName] = entry.crc32;
+                    return;
+                }
+                // If moved from other place
+                const movedFrom = originMap[contentKey];
+                if (movedFrom) {
+                    copies[entry.fileName] = movedFrom;
+                    copiesCrc[entry.fileName] = entry.crc32;
+                    return;
+                }
+                await addFileFromZipEntry(zipfile, entry, nextZipfile);
+            }
+        });
+        return {
+            copies,
+            copiesCrc,
+            ...(Object.keys(hbcTransformMetas).length
+                ? { hbcTransform: hbcTransformMetas }
+                : {}),
+        };
+    });
+}
+function resolveDiffImplementation(options) {
+    if (options.customDiff) {
+        return options.customDiff;
+    }
+    const hdiffModule = options.customHdiffModule ?? hdiff;
+    if (!hdiffModule?.diff) {
+        throw new Error((0, i18n_1.t)('nodeHdiffpatchRequired', { scriptName: constants_1.scriptName }));
+    }
+    return hdiffModule.diff;
+}
+// round-trip 自检需要 patch 能力;拿不到时禁用变换(安全优先),不报错
+function resolvePatchImplementation(options) {
+    if (options.customPatch) {
+        return options.customPatch;
+    }
+    const hdiffModule = options.customHdiffModule ?? hdiff;
+    return hdiffModule?.patch;
+}
+function resolveBundleDiffOptions(options) {
+    const hdiffModule = options.customHdiffModule ?? hdiff;
+    const streamOptions = {};
+    const observerOptions = typeof options.onDiffPhase === 'function'
+        ? { onDiffPhase: options.onDiffPhase }
+        : {};
+    if (typeof options.bundleStreamThreshold === 'number' &&
+        options.bundleStreamThreshold > 0) {
+        const singleDiffStreamFn = options.customDiffSingleStream ?? hdiffModule?.diffSingleStream;
+        const singlePatchStreamFn = options.customPatchSingleStream ?? hdiffModule?.patchSingleStream;
+        const diffStreamFn = options.customDiffStream ?? hdiffModule?.diffStream;
+        const patchStreamFn = options.customPatchStream ?? hdiffModule?.patchStream;
+        if (singleDiffStreamFn && singlePatchStreamFn) {
+            streamOptions.streamThresholdBytes = options.bundleStreamThreshold;
+            streamOptions.diffStreamFn = singleDiffStreamFn;
+            streamOptions.patchStreamFn = singlePatchStreamFn;
+            streamOptions.streamEmitsSingleFormat = true;
+            streamOptions.streamOutputVerified = options.customDiffSingleStream
+                ? options.customDiffSingleStreamVerified === true
+                : hdiffModule?.capabilities?.diffSingleStreamVerifiesOutput === true;
+        }
+        else if (diffStreamFn && patchStreamFn) {
+            streamOptions.streamThresholdBytes = options.bundleStreamThreshold;
+            streamOptions.diffStreamFn = diffStreamFn;
+            streamOptions.patchStreamFn = patchStreamFn;
+            streamOptions.streamEmitsSingleFormat = false;
+            streamOptions.streamOutputVerified = options.customDiffStream
+                ? options.customDiffStreamVerified === true
+                : hdiffModule?.capabilities?.diffStreamVerifiesOutput === true;
+        }
+        else {
+            console.warn((0, i18n_1.t)('bundleStreamNeedsHdiffpatch'));
+        }
+    }
+    if (!options.hbcTransform) {
+        return { ...observerOptions, ...streamOptions };
+    }
+    const patchFn = resolvePatchImplementation(options);
+    if (!patchFn) {
+        console.warn((0, i18n_1.t)('hbcTransformNeedsPatch'));
+        return { ...observerOptions, ...streamOptions };
+    }
+    return {
+        hbcTransform: true,
+        patchFn,
+        ...observerOptions,
+        ...streamOptions,
+        ...(typeof options.hbcTransformMinBaseline === 'number'
+            ? { minBaselineBytes: options.hbcTransformMinBaseline }
+            : {}),
+    };
+}
+function diffArgsCheck(args, options, diffFnName) {
+    const [origin, next] = args;
+    if (!origin || !next) {
+        throw new Error((0, i18n_1.t)('usageDiff', { command: diffFnName }));
+    }
+    const diffFn = resolveDiffImplementation(options);
+    const { output } = (0, utils_1.translateOptions)({
+        ...options,
+        tempDir: constants_1.tempDir,
+    });
+    if (typeof output !== 'string') {
+        throw new Error((0, i18n_1.t)('outputPathRequired'));
+    }
+    return {
+        origin,
+        next,
+        diffFn,
+        realOutput: output.replace(/\$\{time\}/g, `${Date.now()}`),
+    };
+}
+const createDiffCommand = ({ diffFnName, target }) => async ({ args, options }) => {
+    const { origin, next, realOutput, diffFn } = diffArgsCheck(args, options, diffFnName);
+    const bundleOptions = resolveBundleDiffOptions(options);
+    const workRoot = fs.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'rnu-bundle-diff-'));
+    try {
+        if (target.kind === 'ppk') {
+            await diffFromPPK(origin, next, realOutput, diffFn, bundleOptions, workRoot);
+        }
+        else {
+            await diffFromPackage(origin, next, realOutput, diffFn, target.platform, bundleOptions, workRoot);
+        }
+    }
+    finally {
+        fs.rmSync(workRoot, { recursive: true, force: true });
+    }
+    console.log((0, i18n_1.t)('diffPackageGenerated', { output: realOutput }));
+};
+exports.diffCommands = {
+    hdiff: createDiffCommand({
+        diffFnName: 'hdiff',
+        target: { kind: 'ppk' },
+    }),
+    hdiffFromApk: createDiffCommand({
+        diffFnName: 'hdiffFromApk',
+        target: {
+            kind: 'package',
+            platform: 'android',
+        },
+    }),
+    hdiffFromApp: createDiffCommand({
+        diffFnName: 'hdiffFromApp',
+        target: {
+            kind: 'package',
+            platform: 'harmony',
+        },
+    }),
+    hdiffFromIpa: createDiffCommand({
+        diffFnName: 'hdiffFromIpa',
+        target: {
+            kind: 'package',
+            platform: 'ios',
+        },
+    }),
+};