rn-update-cli 1.0.0

package/lib/bundle-runner.js

@@ -0,0 +1,1305 @@
+"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.hasProjectDependency = hasProjectDependency;
+exports.resolveExpoCli = resolveExpoCli;
+exports.runReactNativeBundleCommand = runReactNativeBundleCommand;
+exports.assertSafeToEmpty = assertSafeToEmpty;
+exports.detectHermesEnabled = detectHermesEnabled;
+exports.detectIosHermes = detectIosHermes;
+exports.resolveHermesCommand = resolveHermesCommand;
+exports.summarizeHermescStderr = summarizeHermescStderr;
+exports.buildHermescArgs = buildHermescArgs;
+exports.compileHermesByteCode = compileHermesByteCode;
+exports.hermesBaseErrorLogPath = hermesBaseErrorLogPath;
+exports.hermesBaseDumpPaths = hermesBaseDumpPaths;
+exports.startHermesBaseSelection = startHermesBaseSelection;
+exports.copyDebugidForSentry = copyDebugidForSentry;
+exports.prepareSentryUploadArtifacts = prepareSentryUploadArtifacts;
+exports.readSourcemapDebugId = readSourcemapDebugId;
+exports.resolveSentryUploadMode = resolveSentryUploadMode;
+exports.buildSentrySourcemapsUploadArgs = buildSentrySourcemapsUploadArgs;
+exports.uploadSourcemapForSentry = uploadSourcemapForSentry;
+/**
+ * [INPUT]: 依赖 Node 子进程、React Native bundle、Hermes 编译器与安全临时目录校验
+ * [OUTPUT]: 对外提供 bundle 执行、Hermes base 编译与等价结果、Sourcemap 上传参数和中间目录安全断言
+ * [POS]: CLI 原生打包编排层，连接 Metro/Hermes 与 ppk 制品生成，不负责 HTTP 发布
+ */
+const child_process_1 = require("child_process");
+const compare_versions_1 = require("compare-versions");
+const fs = __importStar(require("fs-extra"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const api_1 = require("./api");
+const dep_versions_1 = require("./utils/dep-versions");
+const hermes_base_1 = require("./utils/hermes-base");
+const i18n_1 = require("./utils/i18n");
+const runtime_1 = require("./utils/runtime");
+const g2js = require('gradle-to-js/lib/parser');
+const properties = require('properties');
+const dependencyFields = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies',
+];
+const ANDROID_SENTRY_BUNDLE_NAME = 'index.android.bundle';
+function hasProjectDependency(dependencyName, projectRoot = process.cwd()) {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(path_1.default.join(projectRoot, 'package.json'), 'utf8'));
+        return dependencyFields.some((field) => {
+            const dependencies = packageJson[field];
+            if (typeof dependencies !== 'object' || dependencies === null) {
+                return false;
+            }
+            return dependencyName in dependencies;
+        });
+    }
+    catch {
+        return false;
+    }
+}
+function resolveExpoCli(projectRoot = process.cwd()) {
+    if (!hasProjectDependency('expo', projectRoot)) {
+        return {
+            cliPath: '',
+            usingExpo: false,
+        };
+    }
+    try {
+        const searchPaths = [projectRoot];
+        try {
+            const expoPackageJsonPath = require.resolve('expo/package.json', {
+                paths: [projectRoot],
+            });
+            searchPaths.push(path_1.default.dirname(expoPackageJsonPath));
+        }
+        catch {
+            // expo 包不存在，忽略
+        }
+        const cliPath = require.resolve('@expo/cli', {
+            paths: searchPaths,
+        });
+        const expoCliVersion = JSON.parse(fs.readFileSync(require.resolve('@expo/cli/package.json', {
+            paths: searchPaths,
+        }), 'utf8')).version;
+        if (!(0, compare_versions_1.satisfies)(expoCliVersion, '>= 0.10.17')) {
+            return {
+                cliPath: '',
+                usingExpo: false,
+            };
+        }
+        return {
+            cliPath,
+            usingExpo: true,
+        };
+    }
+    catch {
+        return {
+            cliPath: '',
+            usingExpo: false,
+        };
+    }
+}
+async function runReactNativeBundleCommand({ bundleName, dev, entryFile, outputFolder, platform, sourcemapOutput, config, forceHermes, hermesBase, resetCache = true, cli, isSentry, }) {
+    let gradleConfig = {};
+    if (platform === 'android') {
+        gradleConfig = await checkGradleConfig(process.cwd());
+        if (gradleConfig.crunchPngs !== false) {
+            console.warn((0, i18n_1.t)('androidCrunchPngsWarning'));
+        }
+    }
+    const reactNativeBundleArgs = [];
+    const envArgs = process.env.PAKTA_ENV_ARGS;
+    if (envArgs) {
+        reactNativeBundleArgs.push(...envArgs.trim().split(/\s+/));
+    }
+    outputFolder = assertSafeToEmpty(outputFolder);
+    fs.emptyDirSync(outputFolder);
+    let cliPath = '';
+    let usingExpo = false;
+    const getExpoCli = () => {
+        const resolvedExpoCli = resolveExpoCli();
+        cliPath = resolvedExpoCli.cliPath;
+        usingExpo = resolvedExpoCli.usingExpo;
+    };
+    const getRnCli = () => {
+        try {
+            cliPath = require.resolve('react-native/local-cli/cli.js', {
+                paths: [process.cwd()],
+            });
+        }
+        catch {
+            cliPath = require.resolve('@react-native-community/cli/build/bin.js', {
+                paths: [process.cwd()],
+            });
+        }
+    };
+    const getTaroCli = () => {
+        try {
+            cliPath = require.resolve('@tarojs/cli/bin/taro', {
+                paths: [process.cwd()],
+            });
+        }
+        catch {
+            // fallback 到 RN CLI
+        }
+    };
+    if (cli.expo) {
+        getExpoCli();
+    }
+    else if (cli.taro) {
+        getTaroCli();
+    }
+    else if (cli.rncli) {
+        getRnCli();
+    }
+    if (!cliPath) {
+        getExpoCli();
+        if (!usingExpo) {
+            getRnCli();
+        }
+    }
+    if (isSentry) {
+        if (platform === 'ios') {
+            process.env.SENTRY_PROPERTIES = 'ios/sentry.properties';
+        }
+        else if (platform === 'android') {
+            process.env.SENTRY_PROPERTIES = 'android/sentry.properties';
+        }
+        else if (platform === 'harmony' &&
+            fs.existsSync('harmony/sentry.properties')) {
+            process.env.SENTRY_PROPERTIES = 'harmony/sentry.properties';
+        }
+    }
+    let bundleCommand = 'bundle';
+    if (usingExpo) {
+        bundleCommand = 'export:embed';
+    }
+    else if (platform === 'harmony') {
+        bundleCommand = 'bundle-harmony';
+    }
+    else if (cli.taro) {
+        bundleCommand = 'build';
+    }
+    if (platform === 'harmony') {
+        bundleName = 'bundle.harmony.js';
+        if (forceHermes === undefined) {
+            forceHermes = true;
+        }
+    }
+    reactNativeBundleArgs.push(cliPath, bundleCommand, '--assets-dest', outputFolder, '--bundle-output', path_1.default.join(outputFolder, bundleName));
+    if (platform !== 'harmony') {
+        reactNativeBundleArgs.push('--platform', platform);
+        if (resetCache)
+            reactNativeBundleArgs.push('--reset-cache');
+    }
+    if (cli.taro) {
+        reactNativeBundleArgs.push('--type', 'rn');
+    }
+    else {
+        reactNativeBundleArgs.push('--dev', dev, '--entry-file', entryFile);
+    }
+    if (sourcemapOutput) {
+        reactNativeBundleArgs.push('--sourcemap-output', sourcemapOutput);
+    }
+    if (config) {
+        reactNativeBundleArgs.push('--config', config);
+    }
+    // Decide about Hermes before Metro runs so the base lookup (server query,
+    // Range download, cache) overlaps the bundling instead of following it.
+    const hermesEnabled = await detectHermesEnabled(platform, forceHermes, gradleConfig);
+    const jsRuntime = (0, runtime_1.getJavaScriptRuntime)();
+    const reactNativeBundleProcess = (0, runtime_1.spawnJavaScript)(reactNativeBundleArgs);
+    console.log(`Running bundle command: ${jsRuntime} ${reactNativeBundleArgs.join(' ')}`);
+    // Metro is running; the synchronous head of the selection (hermesc lookup,
+    // HBC version probe) now overlaps it instead of delaying its start.
+    const pendingBase = hermesEnabled && hermesBase
+        ? startHermesBaseSelection(hermesBase)
+        : undefined;
+    let hermesResult = null;
+    await new Promise((resolve, reject) => {
+        reactNativeBundleProcess.stdout.on('data', (data) => {
+            console.log(data.toString().trim());
+        });
+        reactNativeBundleProcess.stderr.on('data', (data) => {
+            console.error(data.toString().trim());
+        });
+        reactNativeBundleProcess.once('error', reject);
+        reactNativeBundleProcess.on('close', async (exitCode) => {
+            if (exitCode) {
+                reject(new Error((0, i18n_1.t)('bundleCommandError', { code: exitCode })));
+                return;
+            }
+            try {
+                if (hermesEnabled) {
+                    hermesResult = await compileHermesByteCode({
+                        bundleName,
+                        outputFolder,
+                        sourcemapOutput,
+                        shouldCleanSourcemap: !isSentry,
+                        baseRequest: hermesBase,
+                        pendingBase,
+                    });
+                }
+                if (platform === 'harmony') {
+                    const harmonyRawAssetsPath = 'harmony/entry/src/main/resources/rawfile/assets';
+                    fs.ensureDirSync(harmonyRawAssetsPath);
+                    fs.copySync(outputFolder, harmonyRawAssetsPath, {
+                        overwrite: true,
+                        // sourcemaps must not ship inside the native package
+                        filter: (src) => !src.endsWith('.map'),
+                    });
+                    fs.moveSync(`${harmonyRawAssetsPath}/bundle.harmony.js`, `${harmonyRawAssetsPath}/../bundle.harmony.js`, { overwrite: true });
+                }
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    });
+    return hermesResult;
+}
+/**
+ * Validate the intermediate directory before it is emptied and return the
+ * canonical path that was validated. The caller must use this returned path:
+ * validating one spelling and deleting through another re-opens symlink
+ * redirection.
+ */
+function assertSafeToEmpty(dir, cwd = process.cwd()) {
+    const requested = path_1.default.resolve(cwd, dir);
+    const lexicalCwd = path_1.default.resolve(cwd);
+    const lexicalHome = path_1.default.resolve(os_1.default.homedir());
+    const lexicalTmp = path_1.default.resolve(os_1.default.tmpdir());
+    const contains = (parent, child) => {
+        const relative = path_1.default.relative(parent, child);
+        return (relative === '' ||
+            (!relative.startsWith('..') && !path_1.default.isAbsolute(relative)));
+    };
+    const samePath = (left, right) => {
+        const normalize = (value) => {
+            const resolved = path_1.default.resolve(value);
+            return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+        };
+        return normalize(left) === normalize(right);
+    };
+    const reject = (target) => {
+        throw new Error((0, i18n_1.t)('unsafeIntermediateDir', { dir: target }));
+    };
+    const validate = (target, projectRoot, home, tmpRoot) => {
+        // Reject each protected directory and all of its ancestors.
+        for (const protectedPath of [
+            path_1.default.parse(target).root,
+            projectRoot,
+            home,
+            tmpRoot,
+        ]) {
+            if (contains(target, protectedPath))
+                reject(target);
+        }
+        // Never allow build cleanup inside source-control metadata.
+        for (const metadata of ['.git', '.hg', '.svn']) {
+            if (contains(path_1.default.join(projectRoot, metadata), target))
+                reject(target);
+        }
+    };
+    validate(requested, lexicalCwd, lexicalHome, lexicalTmp);
+    // A final-component symlink is the direct dangerous case: emptyDirSync would
+    // enumerate and remove entries from its target rather than removing the link.
+    if (fs.existsSync(requested) && fs.lstatSync(requested).isSymbolicLink()) {
+        reject(requested);
+    }
+    // emptyDirSync creates a missing directory too; create it first so it can be
+    // canonicalized and the exact validated path can be passed to deletion.
+    fs.ensureDirSync(requested);
+    const canonical = (value, allowWindowsLexicalFallback = false) => {
+        try {
+            return fs.realpathSync.native(value);
+        }
+        catch (error) {
+            // Windows 安全策略可能拒绝读取用户目录的最终句柄；这里的目录
+            // 已经通过词法边界校验，回退词法路径只用于比较受保护根目录，
+            // 不能替代目标目录本身的 canonicalize，避免重新打开 symlink 绕过。
+            if (process.platform === 'win32' && allowWindowsLexicalFallback) {
+                return path_1.default.resolve(value);
+            }
+            throw error;
+        }
+    };
+    const target = canonical(requested);
+    const canonicalCwd = canonical(lexicalCwd);
+    const canonicalHome = canonical(lexicalHome, true);
+    const canonicalTmp = canonical(lexicalTmp, true);
+    validate(target, canonicalCwd, canonicalHome, canonicalTmp);
+    // Reject a symlink in any component below a known safe base. System aliases
+    // such as macOS /var -> /private/var remain valid because the base itself is
+    // canonicalized before the relative suffix is appended.
+    for (const [lexicalBase, canonicalBase] of [
+        [lexicalCwd, canonicalCwd],
+        [lexicalHome, canonicalHome],
+        [lexicalTmp, canonicalTmp],
+    ]) {
+        const relative = path_1.default.relative(lexicalBase, requested);
+        if (relative === '' ||
+            (!relative.startsWith('..') && !path_1.default.isAbsolute(relative))) {
+            if (!samePath(path_1.default.resolve(canonicalBase, relative), target)) {
+                reject(target);
+            }
+            break;
+        }
+    }
+    return target;
+}
+/**
+ * Whether the app runs Hermes, i.e. whether the bundle must be compiled to
+ * bytecode. A JS bundle shipped to a Hermes app still runs, but starts slower
+ * and cannot use the Hermes base delta, so false negatives are what this
+ * guards against.
+ *
+ * Android: `hermesEnabled` in gradle.properties wins; then the legacy
+ * `project.ext.react.enableHermes` of build.gradle; with neither, the React
+ * Native gradle plugin (0.71+) defaults to Hermes and older versions to JSC.
+ * iOS: an installed `Pods/hermes-engine`; when `pod install` has not run on
+ * this machine (CI), Expo's `Podfile.properties.json` or the pod listed in
+ * `Podfile.lock` tell the same.
+ */
+async function detectHermesEnabled(platform, forceHermes, gradleConfig, projectRoot = process.cwd()) {
+    if (forceHermes) {
+        console.log((0, i18n_1.t)('forceHermes'));
+        return true;
+    }
+    if (platform === 'android') {
+        const gradleProperties = await readGradleProperties(path_1.default.join(projectRoot, 'android', 'gradle.properties'));
+        if (typeof gradleProperties.hermesEnabled === 'boolean') {
+            return gradleProperties.hermesEnabled;
+        }
+        if (typeof gradleConfig.enableHermes === 'boolean') {
+            return gradleConfig.enableHermes;
+        }
+        return reactNativeDefaultsToHermes(projectRoot);
+    }
+    if (platform === 'ios') {
+        return detectIosHermes(projectRoot);
+    }
+    return false;
+}
+/** parsed gradle.properties; a missing file is simply empty */
+function readGradleProperties(file) {
+    return new Promise((resolve) => {
+        properties.parse(file, { path: true }, (error, props = {}) => {
+            if (error) {
+                if (error.code !== 'ENOENT') {
+                    console.warn(`${file}: ${error.message ?? error}`);
+                }
+                resolve({});
+                return;
+            }
+            resolve(props);
+        });
+    });
+}
+/** React Native's gradle plugin (0.71+) enables Hermes unless a property says otherwise */
+function reactNativeDefaultsToHermes(projectRoot) {
+    const version = (0, dep_versions_1.getDepVersion)('react-native', projectRoot);
+    // major.minor by hand: React Native is 0.x, and the check must not depend
+    // on a semver library (tests replace compare-versions wholesale)
+    const match = version ? /^(\d+)\.(\d+)\./.exec(version) : null;
+    if (!match) {
+        return false;
+    }
+    const [major, minor] = [Number(match[1]), Number(match[2])];
+    return major > 0 || minor >= 71;
+}
+/** Remove Ruby comments without treating a # inside a quoted string as one. */
+function stripRubyComments(source) {
+    return source
+        .split(/\r?\n/)
+        .map((line) => {
+        let quote;
+        let escaped = false;
+        for (let index = 0; index < line.length; index++) {
+            const char = line[index];
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (quote) {
+                if (char === '\\') {
+                    escaped = true;
+                }
+                else if (char === quote) {
+                    quote = undefined;
+                }
+                continue;
+            }
+            if (char === "'" || char === '"') {
+                quote = char;
+            }
+            else if (char === '#') {
+                return line.slice(0, index);
+            }
+        }
+        return line;
+    })
+        .join('\n');
+}
+/**
+ * Read explicit iOS engine configuration. An explicit JSC/disabled-Hermes
+ * setting wins over installed pods because CocoaPods may still fetch the
+ * hermes-engine dependency for a JSC build.
+ */
+function configuredIosEngine(ios) {
+    let expoEngine;
+    try {
+        const value = JSON.parse(fs.readFileSync(path_1.default.join(ios, 'Podfile.properties.json'), 'utf8'))?.['expo.jsEngine'];
+        if (value === 'hermes' || value === 'jsc')
+            expoEngine = value;
+    }
+    catch {
+        // no Expo properties file
+    }
+    let podfile = '';
+    try {
+        podfile = fs.readFileSync(path_1.default.join(ios, 'Podfile'), 'utf8');
+    }
+    catch {
+        // no Podfile
+    }
+    const activePodfile = stripRubyComments(podfile);
+    const envValue = (name) => new RegExp(`ENV\\s*\\[\\s*['"]${name}['"]\\s*\\]\\s*(?:\\|\\|=|=)\\s*['"]([^'"]+)['"]`, 'i')
+        .exec(activePodfile)?.[1]
+        ?.toLowerCase();
+    const useHermes = envValue('USE_HERMES');
+    const useThirdPartyJsc = envValue('USE_THIRD_PARTY_JSC');
+    const hermesOption = /(?:^|[,(]\s*)(?::hermes_enabled\s*=>|hermes_enabled\s*:)\s*(true|false)\b/im
+        .exec(activePodfile)?.[1]
+        ?.toLowerCase();
+    if (useThirdPartyJsc === '1' ||
+        useThirdPartyJsc === 'true' ||
+        useHermes === '0' ||
+        useHermes === 'false' ||
+        hermesOption === 'false' ||
+        expoEngine === 'jsc') {
+        return 'jsc';
+    }
+    if (useHermes === '1' ||
+        useHermes === 'true' ||
+        hermesOption === 'true' ||
+        expoEngine === 'hermes') {
+        return 'hermes';
+    }
+    return undefined;
+}
+/** Hermes on iOS: explicit configuration first, installed artifacts second. */
+function detectIosHermes(projectRoot) {
+    const ios = path_1.default.join(projectRoot, 'ios');
+    const configured = configuredIosEngine(ios);
+    if (configured)
+        return configured === 'hermes';
+    if (fs.existsSync(path_1.default.join(ios, 'Pods', 'hermes-engine'))) {
+        return true;
+    }
+    // CI may not have run pod install, so use the lockfile only as weak evidence.
+    try {
+        const lock = fs.readFileSync(path_1.default.join(ios, 'Podfile.lock'), 'utf8');
+        if (/^\s*-\s+hermes-engine\b/m.test(lock))
+            return true;
+    }
+    catch {
+        // no lockfile either
+    }
+    return false;
+}
+function getHermesOSBin() {
+    if (os_1.default.platform() === 'win32')
+        return 'win64-bin';
+    if (os_1.default.platform() === 'darwin')
+        return 'osx-bin';
+    if (os_1.default.platform() === 'linux')
+        return 'linux64-bin';
+}
+function getHermesExecutableName() {
+    return os_1.default.platform() === 'win32' ? 'hermesc.exe' : 'hermesc';
+}
+function dirnameOfPackage(packageJsonPath, projectRoot = process.cwd()) {
+    return path_1.default.dirname(require.resolve(packageJsonPath, {
+        paths: [projectRoot],
+    }));
+}
+function assertSuccessfulSyncProcess(result, command) {
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(`${command} failed with ${result.status === null
+            ? `signal ${result.signal}`
+            : `exit code ${result.status}`}`);
+    }
+}
+function normalizeString(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}
+function resolveHermesCommand(projectRoot = process.cwd()) {
+    const osBin = getHermesOSBin();
+    if (!osBin) {
+        throw new Error((0, i18n_1.t)('unsupportedPlatformForHermes', { platform: os_1.default.platform() }));
+    }
+    const executableName = getHermesExecutableName();
+    const candidates = [];
+    try {
+        const rnDir = dirnameOfPackage('react-native/package.json', projectRoot);
+        candidates.push(path_1.default.join(rnDir, 'sdks', 'hermesc', osBin, executableName));
+    }
+    catch {
+        // react-native is required for normal RN projects; keep looking so the
+        // final error can include all candidates we were able to infer.
+    }
+    try {
+        const hermesCompilerDir = dirnameOfPackage('hermes-compiler/package.json', projectRoot);
+        candidates.push(path_1.default.join(hermesCompilerDir, 'hermesc', osBin, executableName));
+    }
+    catch {
+        // RN 0.85+ uses hermes-compiler, older projects may still use other paths.
+    }
+    try {
+        const hermesEngineDir = dirnameOfPackage('hermes-engine/package.json', projectRoot);
+        candidates.push(path_1.default.join(hermesEngineDir, osBin, executableName), path_1.default.join(hermesEngineDir, 'hermesc', osBin, executableName));
+    }
+    catch {
+        // RN 0.70-era projects commonly used hermes-engine; optional for newer RN.
+    }
+    const hermesCommand = candidates.find((candidate) => fs.existsSync(candidate));
+    if (hermesCommand) {
+        return hermesCommand;
+    }
+    throw new Error(`Cannot find hermesc. Tried:\n${candidates.map((candidate) => `- ${candidate}`).join('\n')}`);
+}
+async function checkGradleConfig(projectRoot) {
+    // undefined when build.gradle does not mention Hermes at all (React Native
+    // 0.71+ moved the switch to gradle.properties; see detectHermesEnabled)
+    let enableHermes;
+    let crunchPngs;
+    try {
+        const gradleConfig = await g2js.parseFile(path_1.default.join(projectRoot, 'android', 'app', 'build.gradle'));
+        crunchPngs = gradleConfig.android.buildTypes.release.crunchPngs;
+        const projectConfig = gradleConfig['project.ext.react'];
+        if (projectConfig) {
+            for (const packagerConfig of projectConfig) {
+                if (packagerConfig.includes('enableHermes')) {
+                    enableHermes = packagerConfig.includes('true');
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        // ignore parsing failures
+    }
+    return {
+        enableHermes,
+        crunchPngs,
+    };
+}
+/**
+ * hermesc argument policy. `-output-source-map` is always passed: hermesc then
+ * strips the debug info section from the bytecode (like React Native's own
+ * release builds, 15-40% smaller bytecode and smaller hot-update patches) and
+ * writes its own `<bundle>.map` next to the output. When the user asked for a
+ * sourcemap that file is composed with the packager map as before; otherwise it
+ * simply stays in the intermediate directory (never packed into the ppk) so
+ * `address at` stack frames can still be symbolicated later.
+ */
+/**
+ * hermesc echoes every diagnostic as three lines (header, the offending source
+ * line, a caret line). Minified bundles put a whole module on one line, so a
+ * single warning can be 100k+ characters and blindly keeping the tail of stderr
+ * buries the actual error under warning noise. Keep the diagnostic headers,
+ * prefer errors over warnings, and cap the length of whatever survives.
+ */
+function summarizeHermescStderr(stderr) {
+    const raw = String(stderr ?? '').split(/\r?\n/);
+    const kept = [];
+    for (let i = 0; i < raw.length; i++) {
+        const line = raw[i].trim();
+        if (!line)
+            continue;
+        if (/^\^~*$/.test(line))
+            continue; // caret line
+        // the line before a caret is the echoed source, never the message
+        const next = raw[i + 1]?.trim();
+        if (next && /^\^~*$/.test(next))
+            continue;
+        kept.push(line.length > 300 ? `${line.slice(0, 300)}…` : line);
+    }
+    if (kept.length === 0)
+        return '';
+    const isError = (line) => /(?::\s*|^)(?:fatal error|error)\b/i.test(line) ||
+        /^(?:Assertion|Stack dump|PLEASE submit a bug report)/i.test(line);
+    const errors = kept.filter(isError);
+    if (errors.length > 0)
+        return errors.slice(-3).join(' ');
+    const notWarnings = kept.filter((line) => !/:\s*(?:warning|note):/i.test(line));
+    return (notWarnings.length > 0 ? notWarnings : kept).slice(-3).join(' ');
+}
+/** hermesc arguments writing `bundlePath` from `input` (in place by default) */
+function buildHermescArgs(bundlePath, input = bundlePath) {
+    return [
+        '-emit-binary',
+        '-out',
+        bundlePath,
+        input,
+        '-O',
+        '-output-source-map',
+    ];
+}
+/** captured stderr is bounded to this much head and this much tail */
+const STDERR_KEEP_BYTES = 512 * 1024;
+/** spawn without blocking the event loop, so two hermesc runs can overlap */
+function runProcess(command, args, captureStderr) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            stdio: ['ignore', 'ignore', captureStderr ? 'pipe' : 'ignore'],
+        });
+        // hermesc echoes whole (minified) source lines per diagnostic: keep the
+        // head and the tail, never an unbounded transcript
+        const head = [];
+        const tail = [];
+        let headBytes = 0;
+        let tailBytes = 0;
+        let dropped = false;
+        child.stderr?.on('data', (chunk) => {
+            if (headBytes < STDERR_KEEP_BYTES) {
+                head.push(chunk);
+                headBytes += chunk.length;
+                return;
+            }
+            tail.push(chunk);
+            tailBytes += chunk.length;
+            while (tail.length > 1 && tailBytes > STDERR_KEEP_BYTES) {
+                tailBytes -= tail.shift().length;
+                dropped = true;
+            }
+        });
+        let settled = false;
+        const finish = (outcome) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(outcome);
+        };
+        child.once('error', (error) => finish({ status: null, signal: null, stderr: '', error }));
+        child.once('close', (status, signal) => finish({
+            status,
+            signal,
+            stderr: Buffer.concat(head).toString() +
+                (dropped ? '\n[... output truncated ...]\n' : '') +
+                Buffer.concat(tail).toString(),
+        }));
+    });
+}
+/** how long the compile phase waits for a base that is still being fetched */
+const HERMES_BASE_WAIT_MS = 60_000;
+/**
+ * The selection runs while Metro bundles; when Metro is done first, wait a
+ * bounded time for it — a stalled download must never hold up the compile.
+ */
+async function awaitPendingBase(pending) {
+    const waitMs = Number(process.env.PAKTA_HERMES_BASE_WAIT_MS) || HERMES_BASE_WAIT_MS;
+    let timer;
+    const gaveUp = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({
+            base: null,
+            bytecodeVersion: null,
+            logs: [
+                (0, i18n_1.t)('hermesBaseNone', {
+                    reason: `base not ready after ${Math.round(waitMs / 1000)}s`,
+                }),
+            ],
+        }), waitMs);
+    });
+    try {
+        return await Promise.race([pending, gaveUp]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** plain compile of `input` into `out`; throws when hermesc fails */
+async function compilePlain(hermesCommand, out, input = out) {
+    const args = buildHermescArgs(out, input);
+    console.log((0, i18n_1.t)('runningHermesc', { command: hermesCommand, args: args.join(' ') }));
+    assertSuccessfulSyncProcess(await runProcess(hermesCommand, args, false), hermesCommand);
+}
+/**
+ * Merge the packager map with the hermes map into `sourcemapOutput` (which is
+ * normally the hermes map's own path). Resolves false when React Native's
+ * composer cannot be found; throws when it fails.
+ */
+async function composeSourceMaps(packagerMap, hermesMap, sourcemapOutput) {
+    let composerPath;
+    try {
+        // resolve through the project so hoisted node_modules (monorepos) work.
+        // Extensionless first: RN >= 0.87 maps "./scripts/*" to "./scripts/*.js"
+        // in its exports, so the ".js" specifier resolves to ".js.js" and
+        // fails; CJS resolution adds the extension itself on older RN.
+        composerPath = require.resolve('react-native/scripts/compose-source-maps', {
+            paths: [process.cwd()],
+        });
+    }
+    catch {
+        try {
+            composerPath = require.resolve('react-native/scripts/compose-source-maps.js', { paths: [process.cwd()] });
+        }
+        catch {
+            console.warn((0, i18n_1.t)('composeSourceMapsNotFound'));
+            return false;
+        }
+    }
+    console.log((0, i18n_1.t)('composingSourceMap'));
+    assertSuccessfulSyncProcess(await runProcess((0, runtime_1.getJavaScriptRuntime)(), [composerPath, packagerMap, hermesMap, '-o', sourcemapOutput], false), composerPath);
+    return true;
+}
+async function compileHermesByteCode({ bundleName, outputFolder, sourcemapOutput, shouldCleanSourcemap, baseRequest, pendingBase, hermesCommand, }) {
+    console.log((0, i18n_1.t)('hermesEnabledCompiling'));
+    const bundlePath = path_1.default.join(outputFolder, bundleName);
+    const hermesMap = `${bundlePath}.map`;
+    const packagerMap = path_1.default.join(outputFolder, `${bundleName}.txt.map`);
+    if (sourcemapOutput) {
+        // hermesc is about to write its own map at `<bundle>.map`, which is where
+        // the packager map normally sits: move it aside (copy only when elsewhere)
+        if (path_1.default.resolve(sourcemapOutput) === path_1.default.resolve(hermesMap)) {
+            fs.renameSync(sourcemapOutput, packagerMap);
+        }
+        else {
+            fs.copyFileSync(sourcemapOutput, packagerMap);
+        }
+    }
+    else {
+        console.log((0, i18n_1.t)('hermesSourcemapKept', { file: hermesMap }));
+    }
+    // the selection already resolved hermesc while Metro ran; only look it up
+    // again when there was no selection (or it could not find the binary)
+    let selection = pendingBase ? await awaitPendingBase(pendingBase) : null;
+    const command = hermesCommand ?? selection?.hermesCommand ?? resolveHermesCommand();
+    if (!selection || selection.commandUnavailable) {
+        selection = await selectHermesBase(command, baseRequest);
+    }
+    for (const line of selection.logs)
+        console.log(line);
+    const result = {
+        bytecodeVersion: selection.bytecodeVersion,
+        base: null,
+        outcome: 'none',
+    };
+    const base = selection.base;
+    // the packager + hermes maps merged into sourcemapOutput
+    let composed = false;
+    if (!base) {
+        await compilePlain(command, bundlePath);
+    }
+    else {
+        // The JS bundle moves into a work dir and both hermesc runs read it there
+        // (no copies); the base compile writes the real output, and with
+        // verification on the plain compile the check needs runs concurrently
+        // into `plain/` — it simply becomes the result when the base is rejected,
+        // so a rejected base never costs a third compile.
+        const workDir = path_1.default.join(outputFolder, '.hermes-base');
+        const jsSource = path_1.default.join(workDir, bundleName);
+        const plainPath = path_1.default.join(workDir, 'plain', bundleName);
+        const wantPlain = Boolean(baseRequest?.verify);
+        fs.ensureDirSync(path_1.default.dirname(plainPath));
+        fs.renameSync(bundlePath, jsSource);
+        const args = (0, hermes_base_1.hermescArgsWithBase)(buildHermescArgs(bundlePath, jsSource), base.path);
+        console.log((0, i18n_1.t)('runningHermesc', { command, args: args.join(' ') }));
+        const [attempt, plain] = await Promise.all([
+            // -w: warnings only bloat the captured stderr, errors still print
+            runProcess(command, [...args, '-w'], true),
+            wantPlain
+                ? runProcess(command, buildHermescArgs(plainPath, jsSource), false)
+                : Promise.resolve(null),
+        ]);
+        let usedBase = attempt.status === 0 && !attempt.error;
+        if (!usedBase) {
+            const fullStderr = attempt.error
+                ? String(attempt.error.message ?? attempt.error)
+                : attempt.stderr;
+            const reason = summarizeHermescStderr(fullStderr);
+            console.warn((0, i18n_1.t)('hermesBaseCompileFailed', {
+                reason: reason || `exit ${attempt.status}`,
+            }));
+            result.outcomeDetail = `base compile failed: ${reason || `exit ${attempt.status}`}`;
+            if (fullStderr.trim()) {
+                // the summary drops noise; keep everything for bug reports — next to
+                // the intermediate dir, never inside it (its content is packed)
+                const logPath = hermesBaseErrorLogPath(outputFolder);
+                try {
+                    fs.writeFileSync(logPath, fullStderr);
+                    console.warn((0, i18n_1.t)('hermesBaseCompileFailedLog', { file: logPath }));
+                }
+                catch { }
+            }
+        }
+        const plainOk = plain !== null && plain.status === 0 && !plain.error;
+        // compose the base output's map while the disassembly compare runs; it is
+        // redone from the plain map in the rare case the base is rejected
+        const speculativeCompose = usedBase && sourcemapOutput
+            ? composeSourceMaps(packagerMap, hermesMap, sourcemapOutput)
+            : null;
+        if (usedBase && wantPlain) {
+            if (!plainOk) {
+                // The check could not run. That is not evidence against the base,
+                // but verification was asked for and did not happen, so the base is
+                // dropped exactly like a dump that could not be read: never ship
+                // unverified when asked to verify. The plain compile is simply
+                // repeated below (compilePlain), which surfaces a real compiler
+                // failure as the build error it is.
+                const reason = (plain?.error && String(plain.error.message ?? plain.error)) ||
+                    `exit ${plain?.status}`;
+                console.warn((0, i18n_1.t)('hermesBasePlainCompileFailed', { reason }));
+                result.outcome = 'dump-failed';
+                result.outcomeDetail = `plain compile failed: ${reason}`;
+                usedBase = false;
+            }
+            else {
+                const dumpTo = hermesBaseDumpPaths(outputFolder);
+                let outcome;
+                try {
+                    outcome = await (0, hermes_base_1.compareHermesBytecode)(command, bundlePath, plainPath, {
+                        dumpTo,
+                    });
+                }
+                catch (error) {
+                    outcome = {
+                        status: 'dump-failed',
+                        detail: String(error?.message ?? error),
+                        functions: 0,
+                    };
+                }
+                result.verified = outcome.status === 'equivalent';
+                if (outcome.status !== 'equivalent') {
+                    result.outcome =
+                        outcome.status === 'different' ? 'rejected' : 'dump-failed';
+                    result.outcomeDetail = outcome.detail;
+                }
+                if (outcome.status === 'equivalent') {
+                    console.log((0, i18n_1.t)('hermesBaseVerified', { functions: outcome.functions }));
+                }
+                else {
+                    // a dump that could not be read is not evidence either way; the
+                    // base is still dropped (never ship unverified when asked to
+                    // verify), but the log says which case this is
+                    console.warn((0, i18n_1.t)(outcome.status === 'different'
+                        ? 'hermesBaseVerifyFailed'
+                        : 'hermesBaseVerifyDumpFailed', { detail: outcome.detail ?? '' }));
+                    if (dumpTo) {
+                        console.warn((0, i18n_1.t)('hermesBaseVerifyDumpsWritten', {
+                            withBase: dumpTo.withBase,
+                            plain: dumpTo.plain,
+                        }));
+                    }
+                    usedBase = false;
+                }
+            }
+        }
+        if (speculativeCompose) {
+            const done = await speculativeCompose.catch((error) => {
+                if (usedBase)
+                    throw error;
+                return false;
+            });
+            composed = usedBase && done;
+        }
+        if (!usedBase) {
+            if (plainOk) {
+                fs.moveSync(plainPath, bundlePath, { overwrite: true });
+                if (fs.existsSync(`${plainPath}.map`)) {
+                    fs.moveSync(`${plainPath}.map`, hermesMap, { overwrite: true });
+                }
+            }
+            else {
+                await compilePlain(command, bundlePath, jsSource);
+            }
+        }
+        fs.removeSync(workDir);
+        result.base = usedBase ? base : null;
+        if (usedBase)
+            result.outcome = 'used';
+    }
+    if (sourcemapOutput && !composed) {
+        await composeSourceMaps(packagerMap, hermesMap, sourcemapOutput);
+    }
+    if (shouldCleanSourcemap) {
+        fs.removeSync(packagerMap);
+    }
+    return result;
+}
+/** where a failed base attempt's full hermesc output goes (never packed) */
+function hermesBaseErrorLogPath(outputFolder) {
+    return path_1.default.join(path_1.default.dirname(path_1.default.resolve(outputFolder)), 'hermes-base-error.log');
+}
+/**
+ * With PAKTA_HERMES_BASE_DEBUG set, both disassemblies of the equivalence
+ * check are kept next to the intermediate directory (never packed) so a
+ * rejected base can be reported with the exact difference.
+ */
+function hermesBaseDumpPaths(outputFolder, env = process.env) {
+    const flag = env.PAKTA_HERMES_BASE_DEBUG?.trim().toLowerCase();
+    if (!flag || flag === '0' || flag === 'false')
+        return undefined;
+    const dir = path_1.default.dirname(path_1.default.resolve(outputFolder));
+    return {
+        withBase: path_1.default.join(dir, 'hermes-base-dump-base.txt'),
+        plain: path_1.default.join(dir, 'hermes-base-dump-plain.txt'),
+    };
+}
+/**
+ * Begin resolving the base right away (before Metro); the compile phase awaits
+ * the result. Never rejects: any failure is reported there instead.
+ */
+function startHermesBaseSelection(request) {
+    return (async () => {
+        let hermesCommand;
+        try {
+            hermesCommand = resolveHermesCommand();
+        }
+        catch {
+            return {
+                base: null,
+                bytecodeVersion: null,
+                logs: [],
+                commandUnavailable: true,
+            };
+        }
+        try {
+            return await selectHermesBase(hermesCommand, request);
+        }
+        catch (error) {
+            return {
+                base: null,
+                bytecodeVersion: null,
+                logs: [
+                    (0, i18n_1.t)('hermesBaseNone', { reason: error?.message ?? String(error) }),
+                ],
+                hermesCommand,
+            };
+        }
+    })();
+}
+async function selectHermesBase(hermesCommand, request) {
+    const logs = [];
+    const none = (bytecodeVersion = null) => ({
+        base: null,
+        bytecodeVersion,
+        logs,
+        hermesCommand,
+    });
+    if (!request || request.option === 'none') {
+        if (request) {
+            logs.push((0, i18n_1.t)('hermesBaseNone', { reason: 'disabled by option' }));
+        }
+        return none();
+    }
+    const gate = (0, hermes_base_1.classifyHermesCommand)(hermesCommand);
+    if (!gate.allowed) {
+        logs.push((0, i18n_1.t)('hermesBaseNone', { reason: gate.reason ?? 'hermesc not eligible' }));
+        return none();
+    }
+    const bytecodeVersion = (0, hermes_base_1.probeHbcVersion)(hermesCommand);
+    if (bytecodeVersion === null) {
+        logs.push((0, i18n_1.t)('hermesBaseNone', { reason: 'could not probe HBC version' }));
+        return none();
+    }
+    try {
+        const base = await (0, hermes_base_1.resolveHermesBase)({
+            option: request.option,
+            hermesCommand,
+            bytecodeVersion,
+            appId: request.appId,
+            cacheMaxMb: request.cacheMaxMb,
+            fetchBase: api_1.getHermesBase,
+            log: (message) => logs.push(message),
+        });
+        return { base, bytecodeVersion, logs, hermesCommand };
+    }
+    catch (error) {
+        logs.push((0, i18n_1.t)('hermesBaseNone', { reason: error?.message ?? String(error) }));
+        return none(bytecodeVersion);
+    }
+}
+async function copyDebugidForSentry(bundleName, outputFolder, sourcemapOutput) {
+    if (sourcemapOutput) {
+        let copyDebugidPath;
+        try {
+            copyDebugidPath = require.resolve('@sentry/react-native/scripts/copy-debugid.js', {
+                paths: [process.cwd()],
+            });
+        }
+        catch {
+            console.error((0, i18n_1.t)('sentryReactNativeNotFound'));
+            return;
+        }
+        if (!fs.existsSync(copyDebugidPath)) {
+            return;
+        }
+        console.log((0, i18n_1.t)('copyingDebugId'));
+        assertSuccessfulSyncProcess((0, runtime_1.spawnJavaScriptSync)([
+            copyDebugidPath,
+            path_1.default.join(outputFolder, `${bundleName}.txt.map`),
+            path_1.default.join(outputFolder, `${bundleName}.map`),
+        ], {
+            stdio: 'ignore',
+        }), copyDebugidPath);
+    }
+    fs.removeSync(path_1.default.join(outputFolder, `${bundleName}.txt.map`));
+}
+async function prepareSentryUploadArtifacts(bundleName, outputFolder, platform) {
+    const bundlePath = path_1.default.join(outputFolder, bundleName);
+    const sourcemapPath = path_1.default.join(outputFolder, `${bundleName}.map`);
+    if (platform !== 'android' || bundleName === ANDROID_SENTRY_BUNDLE_NAME) {
+        return {
+            bundlePath,
+            sourcemapPath,
+        };
+    }
+    const androidBundlePath = path_1.default.join(outputFolder, ANDROID_SENTRY_BUNDLE_NAME);
+    const androidSourcemapPath = path_1.default.join(outputFolder, `${ANDROID_SENTRY_BUNDLE_NAME}.map`);
+    await fs.promises.copyFile(bundlePath, androidBundlePath);
+    const sourcemap = JSON.parse(await fs.promises.readFile(sourcemapPath, 'utf8'));
+    sourcemap.file = ANDROID_SENTRY_BUNDLE_NAME;
+    await fs.promises.writeFile(androidSourcemapPath, JSON.stringify(sourcemap));
+    return {
+        bundlePath: androidBundlePath,
+        sourcemapPath: androidSourcemapPath,
+    };
+}
+async function readSourcemapDebugId(sourcemapPath) {
+    try {
+        const sourcemap = JSON.parse(await fs.promises.readFile(sourcemapPath, 'utf8'));
+        const debugId = sourcemap.debugId ?? sourcemap.debug_id;
+        return typeof debugId === 'string' ? normalizeString(debugId) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function resolveSentryReleaseFromValues(releaseValue, distValue) {
+    const release = normalizeString(releaseValue);
+    if (!release) {
+        return undefined;
+    }
+    return {
+        release,
+        dist: normalizeString(distValue),
+    };
+}
+async function resolveSentryUploadMode(sourcemapPath, options = {}) {
+    const optionRelease = resolveSentryReleaseFromValues(options.sentryRelease, options.sentryDist);
+    if (optionRelease) {
+        return {
+            type: 'release',
+            ...optionRelease,
+        };
+    }
+    const debugId = await readSourcemapDebugId(sourcemapPath);
+    if (debugId) {
+        return {
+            type: 'debug-id',
+            debugId,
+        };
+    }
+    const environmentRelease = resolveSentryReleaseFromValues(process.env.SENTRY_RELEASE, process.env.SENTRY_DIST);
+    if (environmentRelease) {
+        return {
+            type: 'release',
+            ...environmentRelease,
+        };
+    }
+    throw new Error('[pakta/sentry] Generated source map does not contain a Debug ID. ' +
+        'Add @sentry/react-native/metro to metro.config.js so the OTA bundle can be matched by Debug ID, ' +
+        'or set --sentry-release/--sentry-dist (or SENTRY_RELEASE/SENTRY_DIST) for legacy release matching.');
+}
+function buildSentrySourcemapsUploadArgs({ sentryCliPath, bundlePath, sourcemapPath, release, dist, stripPrefix = process.cwd(), debugIdReference = false, useStandaloneSourcemapsCommand = true, }) {
+    const uploadArgs = ['--strip-prefix', stripPrefix, bundlePath, sourcemapPath];
+    if (debugIdReference) {
+        if (!useStandaloneSourcemapsCommand) {
+            throw new Error('[pakta/sentry] Debug ID upload requires sentry-cli sourcemaps upload.');
+        }
+        return [
+            sentryCliPath,
+            'sourcemaps',
+            'upload',
+            '--debug-id-reference',
+            ...uploadArgs,
+        ];
+    }
+    if (!release) {
+        throw new Error('[pakta/sentry] Legacy Sentry sourcemap upload requires a release.');
+    }
+    if (!useStandaloneSourcemapsCommand) {
+        return [
+            sentryCliPath,
+            'releases',
+            'files',
+            release,
+            'upload-sourcemaps',
+            ...(dist ? ['--dist', dist] : []),
+            ...uploadArgs,
+        ];
+    }
+    return [
+        sentryCliPath,
+        'sourcemaps',
+        'upload',
+        '--release',
+        release,
+        ...(dist ? ['--dist', dist] : []),
+        ...uploadArgs,
+    ];
+}
+function supportsStandaloneSentrySourcemapsUpload(sentryCliPath) {
+    const result = (0, runtime_1.spawnJavaScriptSync)([sentryCliPath, 'sourcemaps', 'upload', '--help'], {
+        stdio: 'ignore',
+    });
+    return !result.error && result.status === 0;
+}
+function supportsSentryDebugIdReference(sentryCliPath) {
+    const result = (0, runtime_1.spawnJavaScriptSync)([sentryCliPath, 'sourcemaps', 'upload', '--help'], {
+        encoding: 'utf8',
+    });
+    return (!result.error &&
+        result.status === 0 &&
+        typeof result.stdout === 'string' &&
+        result.stdout.includes('--debug-id-reference'));
+}
+function runSentryCli(args) {
+    return (0, runtime_1.spawnJavaScriptSync)(args, {
+        stdio: 'inherit',
+    });
+}
+function uploadSourcemapsWithRelease({ sentryCliPath, bundlePath, sourcemapPath, release, dist, useStandaloneSourcemapsCommand, }) {
+    assertSuccessfulSyncProcess(runSentryCli([sentryCliPath, 'releases', 'set-commits', release, '--auto']), sentryCliPath);
+    console.log((0, i18n_1.t)('sentryReleaseCreated', { version: release }));
+    console.log((0, i18n_1.t)('uploadingSourcemap'));
+    assertSuccessfulSyncProcess(runSentryCli(buildSentrySourcemapsUploadArgs({
+        sentryCliPath,
+        bundlePath,
+        sourcemapPath,
+        release,
+        dist,
+        useStandaloneSourcemapsCommand,
+    })), sentryCliPath);
+}
+async function uploadSourcemapForSentry(bundleName, outputFolder, sourcemapOutput, platform = '', sentryOptions = {}) {
+    if (!sourcemapOutput) {
+        return;
+    }
+    let sentryCliPath;
+    try {
+        sentryCliPath = require.resolve('@sentry/cli/bin/sentry-cli', {
+            paths: [process.cwd()],
+        });
+    }
+    catch {
+        console.error((0, i18n_1.t)('sentryCliNotFound'));
+        return;
+    }
+    if (!fs.existsSync(sentryCliPath)) {
+        return;
+    }
+    const { bundlePath, sourcemapPath } = await prepareSentryUploadArtifacts(bundleName, outputFolder, platform);
+    const uploadMode = await resolveSentryUploadMode(sourcemapPath, sentryOptions);
+    const useStandaloneSourcemapsCommand = supportsStandaloneSentrySourcemapsUpload(sentryCliPath);
+    if (uploadMode.type === 'release') {
+        uploadSourcemapsWithRelease({
+            sentryCliPath,
+            bundlePath,
+            sourcemapPath,
+            release: uploadMode.release,
+            dist: uploadMode.dist,
+            useStandaloneSourcemapsCommand,
+        });
+        return;
+    }
+    console.log((0, i18n_1.t)('uploadingSourcemap'));
+    if (!useStandaloneSourcemapsCommand ||
+        !supportsSentryDebugIdReference(sentryCliPath)) {
+        const explicitRelease = resolveSentryReleaseFromValues(sentryOptions.sentryRelease, sentryOptions.sentryDist) ??
+            resolveSentryReleaseFromValues(process.env.SENTRY_RELEASE, process.env.SENTRY_DIST);
+        if (!explicitRelease) {
+            throw new Error('[pakta/sentry] sentry-cli does not support Debug ID source map upload. ' +
+                'Upgrade @sentry/cli, or set --sentry-release/--sentry-dist for legacy release matching.');
+        }
+        uploadSourcemapsWithRelease({
+            sentryCliPath,
+            bundlePath,
+            sourcemapPath,
+            release: explicitRelease.release,
+            dist: explicitRelease.dist,
+            useStandaloneSourcemapsCommand,
+        });
+        return;
+    }
+    console.log(`[pakta/sentry] Using source map Debug ID: ${uploadMode.debugId}`);
+    const debugIdResult = runSentryCli(buildSentrySourcemapsUploadArgs({
+        sentryCliPath,
+        bundlePath,
+        sourcemapPath,
+        debugIdReference: true,
+        useStandaloneSourcemapsCommand,
+    }));
+    if (debugIdResult.status === 0 && !debugIdResult.error) {
+        return;
+    }
+    const explicitRelease = resolveSentryReleaseFromValues(sentryOptions.sentryRelease, sentryOptions.sentryDist) ??
+        resolveSentryReleaseFromValues(process.env.SENTRY_RELEASE, process.env.SENTRY_DIST);
+    if (!explicitRelease) {
+        assertSuccessfulSyncProcess(debugIdResult, sentryCliPath);
+        return;
+    }
+    console.warn('[pakta/sentry] Debug ID source map upload failed; falling back to explicit release/dist upload.');
+    uploadSourcemapsWithRelease({
+        sentryCliPath,
+        bundlePath,
+        sourcemapPath,
+        release: explicitRelease.release,
+        dist: explicitRelease.dist,
+        useStandaloneSourcemapsCommand,
+    });
+}