@bravemobile/react-native-code-push 13.0.0 → 13.1.0-beta.0

package/cli/commands/releaseCommand/release.ts

@@ -1,10 +1,24 @@
 import fs from "fs";
 import path from "path";
-import { bundleCodePush } from "../bundleCommand/bundleCodePush.js";
+import { bundleCodePush, resolveJsBundleName } from "../bundleCommand/bundleCodePush.js";
 import { addToReleaseHistory } from "./addToReleaseHistory.js";
 import type { CliConfigInterface } from "../../../typings/react-native-code-push.d.ts";
 import { generatePackageHashFromDirectory } from "../../utils/hash-utils.js";
 import { unzip } from "../../utils/unzip.js";
+import {
+    BINARY_PATCH_ARCHIVE_SUFFIX,
+    BINARY_PATCH_BASE_RECORD_NAME,
+    DEFAULT_OVERSIZED_PATCH_POLICY,
+    extractCodePushBundleContents,
+    formatBinaryPatchSummary,
+    hashBundleFile,
+    isPatchArchiveOversized,
+    makeBinaryPatchBundle,
+    readBinaryPatchBaseRecord,
+    type BinaryPatchBaseRecord,
+    type BinaryPatchBundle,
+    type OversizedPatchPolicy,
+} from "../../functions/makeBinaryPatchBundle.js";
 
 export async function release(
     bundleUploader: CliConfigInterface['bundleUploader'],
@@ -17,7 +31,7 @@ export async function release(
     identifier: string | undefined,
     outputPath: string,
     entryFile: string,
-    jsBundleName: string,
+    jsBundleName: string | undefined,
     mandatory: boolean,
     enable: boolean,
     rollout: number | undefined,
@@ -26,10 +40,19 @@ export async function release(
     bundleDirectory: string,
     outputMetroDir?: string,
     hashCalc?: boolean,
+    baseBundlePath?: string,
+    onOversizedPatch: OversizedPatchPolicy = DEFAULT_OVERSIZED_PATCH_POLICY,
 ): Promise<void> {
-    const bundleFileName = skipBundle
-        ? readBundleFileNameFrom(bundleDirectory)
-        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory, outputMetroDir);
+    if (baseBundlePath) {
+        // Checked before the bundler runs, so the wrong base bundle costs a second rather
+        // than a full build.
+        verifyExportedBaseBundleRecord(baseBundlePath, binaryVersion);
+    }
+
+    const codePushBundle = skipBundle
+        ? null
+        : await bundleCodePush(framework, platform, outputPath, entryFile, jsBundleName, bundleDirectory, outputMetroDir, baseBundlePath);
+    const bundleFileName = codePushBundle?.bundleFileName ?? readBundleFileNameFrom(bundleDirectory);
     const bundleFilePath = `${bundleDirectory}/${bundleFileName}`;
 
     const packageHash = await (() => {
@@ -40,20 +63,34 @@ export async function release(
         return bundleFileName;
     })();
 
-    const downloadUrl = await (async () => {
-        try {
-            const { downloadUrl } = await bundleUploader(bundleFilePath, platform, identifier);
-            return downloadUrl
-        } catch (error) {
-            console.error('Failed to upload the bundle file. Exiting the program.\n', error)
-            process.exit(1)
-        }
-    })();
+    const binaryPatch = baseBundlePath
+        ? await makeBinaryPatchArtifact({
+            baseBundlePath,
+            contentsPath: codePushBundle?.contentsPath,
+            bundleFilePath,
+            jsBundleName: codePushBundle?.jsBundleName ?? resolveJsBundleName(platform, jsBundleName),
+            bundleDirectory,
+            packageHash,
+            outputPath,
+            platform,
+            onOversizedPatch,
+        })
+        : null;
+
+    // Every artifact is uploaded before the release history is touched, so a failed
+    // upload leaves the history describing only updates that can actually be downloaded.
+    const downloadUrl = await uploadArtifact(bundleUploader, bundleFilePath, platform, identifier, 'bundle');
+    let patchDownloadUrl: string | undefined;
+    if (binaryPatch) {
+        patchDownloadUrl = await uploadArtifact(bundleUploader, binaryPatch.patchBundleFilePath, platform, identifier, 'binary patch bundle');
+        console.log(`log: Binary patch archive uploaded (download url: ${patchDownloadUrl})`);
+    }
 
     await addToReleaseHistory(
         appVersion,
         binaryVersion,
         downloadUrl,
+        patchDownloadUrl,
         packageHash,
         getReleaseHistory,
         setReleaseHistory,
@@ -74,7 +111,9 @@ function cleanUpOutputs(dir: string) {
 }
 
 function readBundleFileNameFrom(bundleDirectory: string): string {
-    const files = fs.readdirSync(bundleDirectory);
+    // A previous release of the same bundle may have left its patch archive here, and
+    // that archive is derived from the bundle file rather than a candidate for release.
+    const files = fs.readdirSync(bundleDirectory).filter((file) => !file.endsWith(BINARY_PATCH_ARCHIVE_SUFFIX));
     if (files.length !== 1) {
         console.error('The bundlePath must contain only one file.');
         process.exit(1);
@@ -101,3 +140,181 @@ async function calcHashFromBundleFile(bundleFilePath: string): Promise<string> {
         fs.rmSync(tempDir, { recursive: true, force: true });
     }
 }
+
+/**
+ * Builds the binary patch artifact of this release and reports what it saves, before
+ * anything is uploaded.
+ *
+ * A patch that is not smaller than the full archive is not worth publishing, and the
+ * CLI cannot ask: it runs unattended. `onOversizedPatch` decides instead - `skip`
+ * releases the full bundle alone, `fail` stops the release while nothing has been
+ * uploaded yet.
+ *
+ * @param contentsPath {string | undefined} Update contents of a bundle that was just built. Absent with `--skip-bundle`, where the bundle file being released is unpacked instead, so the patch describes exactly the bytes that go out.
+ * @return {Promise<BinaryPatchBundle | null>} The artifact to upload, or `null` when the patch was skipped.
+ */
+async function makeBinaryPatchArtifact({
+    baseBundlePath,
+    contentsPath,
+    bundleFilePath,
+    jsBundleName,
+    bundleDirectory,
+    packageHash,
+    outputPath,
+    platform,
+    onOversizedPatch,
+}: {
+    baseBundlePath: string;
+    contentsPath: string | undefined;
+    bundleFilePath: string;
+    jsBundleName: string;
+    bundleDirectory: string;
+    packageHash: string;
+    outputPath: string;
+    platform: 'ios' | 'android';
+    onOversizedPatch: OversizedPatchPolicy;
+}): Promise<BinaryPatchBundle | null> {
+    warnOnBaseBundleMismatch(outputPath, baseBundlePath);
+
+    let patchContentsPath = contentsPath;
+    let extractDir: string | null = null;
+    if (patchContentsPath === undefined) {
+        const extracted = await extractCodePushBundleContents(bundleFilePath, outputPath);
+        patchContentsPath = extracted.contentsPath;
+        extractDir = extracted.extractDir;
+    }
+
+    try {
+        const binaryPatch = await makeBinaryPatchBundle({
+            contentsPath: patchContentsPath,
+            baseBundlePath,
+            bundleRelativePath: jsBundleName,
+            bundleDirectory,
+            packageHash,
+        });
+
+        const fullArchiveSize = fs.statSync(bundleFilePath).size;
+        const patchArchiveSize = fs.statSync(binaryPatch.patchBundleFilePath).size;
+        const oversized = isPatchArchiveOversized(fullArchiveSize, patchArchiveSize);
+
+        console.log(formatBinaryPatchSummary({
+            platform,
+            baseBundleHash: binaryPatch.manifest.baseBundleHash,
+            targetBundleHash: binaryPatch.manifest.targetBundleHash,
+            fullArchiveSize,
+            patchArchiveSize,
+            patchSkipped: oversized && onOversizedPatch === 'skip',
+        }));
+
+        if (oversized) {
+            if (onOversizedPatch === 'fail') {
+                throw new Error(
+                    `The binary patch archive (${patchArchiveSize} bytes) is not smaller than the full archive (${fullArchiveSize} bytes), ` +
+                        'and --on-oversized-patch is set to "fail". Nothing was uploaded.',
+                );
+            }
+
+            console.warn(
+                `warn: The binary patch archive (${patchArchiveSize} bytes) is not smaller than the full archive (${fullArchiveSize} bytes). ` +
+                    'Releasing the full bundle only, without a binary patch.',
+            );
+            return null;
+        }
+
+        return binaryPatch;
+    } finally {
+        if (extractDir) {
+            fs.rmSync(extractDir, { recursive: true, force: true });
+        }
+    }
+}
+
+/**
+ * Cross-checks the base bundle against the record a build hook exported next to it.
+ *
+ * The base bundle is the one input a release cannot verify on its own: pass the bundle of
+ * a different build and everything still succeeds, only for the patch to be unappliable
+ * on every device. The record says which bytes and which binary the export came from, so
+ * when it is there, the two mistakes that produce a broken release - a base file that was
+ * replaced after it was exported, and a base exported from a different binary version -
+ * stop the release before anything is built or uploaded.
+ *
+ * A base bundle produced some other way has no record next to it, and releases exactly as
+ * it did before. A record that cannot be read only warns: it is a cross-check, and losing
+ * it must never be able to fail a release that is otherwise fine.
+ */
+function verifyExportedBaseBundleRecord(baseBundlePath: string, binaryVersion: string): void {
+    const recordPath = path.join(path.dirname(path.resolve(baseBundlePath)), BINARY_PATCH_BASE_RECORD_NAME);
+
+    let contents: string;
+    try {
+        contents = fs.readFileSync(recordPath, 'utf8');
+    } catch {
+        return;
+    }
+
+    let record: Partial<BinaryPatchBaseRecord> = {};
+    try {
+        record = (JSON.parse(contents) as Partial<BinaryPatchBaseRecord> | null) ?? {};
+    } catch {
+        // Left empty, which is reported below as a record that says nothing to check.
+    }
+    if (typeof record.baseBundleHash !== 'string') {
+        console.warn(
+            `warn: "${recordPath}" is not a readable binary patch base record, so the base bundle was released without cross-checking it.`,
+        );
+        return;
+    }
+
+    const baseBundleHash = hashBundleFile(baseBundlePath);
+    if (record.baseBundleHash !== baseBundleHash) {
+        throw new Error(
+            `The base bundle "${baseBundlePath}" does not match the record exported next to it: the record describes ${record.baseBundleHash}, ` +
+                `but the file hashes to ${baseBundleHash}. Export the bundle again from the build that produced the binary.`,
+        );
+    }
+
+    if (typeof record.binaryVersion === 'string' && record.binaryVersion !== binaryVersion) {
+        throw new Error(
+            `The base bundle "${baseBundlePath}" was exported from binary version ${record.binaryVersion}, but this release targets ${binaryVersion} ` +
+                '(--binary-version). Release against the bundle of the binary being targeted.',
+        );
+    }
+}
+
+/**
+ * The bundle being released may have been compiled by an earlier `bundle` run against a
+ * different base. The patch stays valid - it is always computed against the base given
+ * here - but the bytecode alignment that keeps it small is lost, which is worth saying
+ * out loud instead of leaving it to be noticed in the size summary.
+ */
+function warnOnBaseBundleMismatch(outputPath: string, baseBundlePath: string): void {
+    const record = readBinaryPatchBaseRecord(outputPath);
+    if (!record) {
+        return;
+    }
+
+    const baseBundleHash = hashBundleFile(baseBundlePath);
+    if (record.baseBundleHash !== baseBundleHash) {
+        console.warn(
+            `warn: The bundle was compiled against base bundle ${record.baseBundleHash}, but this release patches against ${baseBundleHash}. ` +
+                'The patch is valid but larger than an aligned one.',
+        );
+    }
+}
+
+async function uploadArtifact(
+    bundleUploader: CliConfigInterface['bundleUploader'],
+    filePath: string,
+    platform: 'ios' | 'android',
+    identifier: string | undefined,
+    artifactName: string,
+): Promise<string> {
+    try {
+        const { downloadUrl } = await bundleUploader(filePath, platform, identifier);
+        return downloadUrl
+    } catch (error) {
+        console.error(`Failed to upload the ${artifactName} file. Exiting the program.\n`, error)
+        process.exit(1)
+    }
+}

package/cli/dist/commands/bundleCommand/bundleCodePush.js

@@ -4,21 +4,30 @@ import { prepareToBundleJS } from "../../functions/prepareToBundleJS.js";
 import { runReactNativeBundleCommand } from "../../functions/runReactNativeBundleCommand.js";
 import { runExpoBundleCommand } from "../../functions/runExpoBundleCommand.js";
 import { getReactTempDir } from "../../functions/getReactTempDir.js";
-import { runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
+import { resolveBaseBytecodeHermesFlags, runHermesEmitBinaryCommand } from "../../functions/runHermesEmitBinaryCommand.js";
 import { makeCodePushBundle } from "../../functions/makeCodePushBundle.js";
+import { hashBundleFile, writeBinaryPatchBaseRecord } from "../../functions/makeBinaryPatchBundle.js";
 import { ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 /**
- * @return {Promise<string>} CodePush bundle file name (equals to packageHash)
+ * JS bundle file name react-native writes, which is also the name the app looks for
+ * inside an update, so it has to be decided the same way everywhere.
+ */
+export function resolveJsBundleName(platform, jsBundleName) {
+    const DEFAULT_JS_BUNDLE_NAME = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
+    return jsBundleName || DEFAULT_JS_BUNDLE_NAME;
+}
+/**
+ * @param baseBundlePath {string} JS bundle from the target binary. When given, the compilation is aligned with it and the base is recorded for a later `release`.
+ * @return {Promise<CodePushBundleResult>} CodePush bundle file name (equals to packageHash) and the contents it was made of
  */
 export async function bundleCodePush(framework, platform = 'ios', outputRootPath = ROOT_OUTPUT_DIR, entryFile = ENTRY_FILE, jsBundleName, // JS bundle file name (not CodePush bundle file)
 bundleDirectory, // CodePush bundle output directory
-outputMetroDir) {
+outputMetroDir, baseBundlePath) {
     if (fs.existsSync(outputRootPath)) {
         fs.rmSync(outputRootPath, { recursive: true });
     }
     const OUTPUT_CONTENT_PATH = `${outputRootPath}/CodePush`;
-    const DEFAULT_JS_BUNDLE_NAME = platform === 'ios' ? 'main.jsbundle' : 'index.android.bundle';
-    const _jsBundleName = jsBundleName || DEFAULT_JS_BUNDLE_NAME; // react-native JS bundle output name
+    const _jsBundleName = resolveJsBundleName(platform, jsBundleName); // react-native JS bundle output name
     const SOURCEMAP_OUTPUT = `${outputRootPath}/${_jsBundleName}.map`;
     prepareToBundleJS({ deleteDirs: [outputRootPath, getReactTempDir()], makeDir: OUTPUT_CONTENT_PATH });
     if (framework === 'expo') {
@@ -29,11 +38,21 @@ outputMetroDir) {
     }
     console.log('log: JS bundling complete');
     copyMetroOutputsIfNeeded(outputRootPath, outputMetroDir, OUTPUT_CONTENT_PATH, _jsBundleName, SOURCEMAP_OUTPUT);
-    await runHermesEmitBinaryCommand(_jsBundleName, OUTPUT_CONTENT_PATH, SOURCEMAP_OUTPUT);
+    await runHermesEmitBinaryCommand(_jsBundleName, OUTPUT_CONTENT_PATH, SOURCEMAP_OUTPUT, baseBundlePath ? resolveBaseBytecodeHermesFlags(baseBundlePath) : []);
     console.log('log: Hermes compilation complete');
     const { bundleFileName: codePushBundleFileName } = await makeCodePushBundle(OUTPUT_CONTENT_PATH, bundleDirectory);
     console.log(`log: CodePush bundle created (file path: ./${bundleDirectory}/${codePushBundleFileName})`);
-    return codePushBundleFileName;
+    if (baseBundlePath) {
+        // Written after the bundle file, and to the output root instead of the update
+        // contents, so recording the base cannot change what was just packed or its hash.
+        const recordPath = writeBinaryPatchBaseRecord(outputRootPath, hashBundleFile(baseBundlePath));
+        console.log(`log: Binary patch base recorded (file path: ${recordPath})`);
+    }
+    return {
+        bundleFileName: codePushBundleFileName,
+        contentsPath: OUTPUT_CONTENT_PATH,
+        jsBundleName: _jsBundleName,
+    };
 }
 function copyMetroOutputsIfNeeded(outputRootPath, outputMetroDir, outputContentPath, jsBundleName, sourceMapOutputPath) {
     if (!outputMetroDir) {

package/cli/dist/commands/bundleCommand/index.js

@@ -1,5 +1,6 @@
 import { program, Option } from "commander";
 import { bundleCodePush } from "./bundleCodePush.js";
+import { resolveBinaryBundlePathOption } from "../../functions/makeBinaryPatchBundle.js";
 import { OUTPUT_BUNDLE_DIR, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 program.command('bundle')
     .description('Creates a CodePush bundle file (assumes Hermes is enabled).')
@@ -10,6 +11,9 @@ program.command('bundle')
     .option('-b, --bundle-name <string>', 'bundle file name (default-ios: "main.jsbundle" / default-android: "index.android.bundle")')
     .option('--output-metro-dir <string>', 'name of directory to copy the Metro JS bundle and sourcemap before Hermes compilation')
     .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .option('--binary-bundle-path <string>', 'path to the JS bundle of the target binary. Aligns the Hermes compilation with it and records it as the binary patch base.')
     .action((options) => {
-    bundleCodePush(options.framework, options.platform, options.outputPath, options.entryFile, options.bundleName, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir);
+    // Resolved before bundling so a wrong path fails now rather than after a build.
+    const baseBundlePath = resolveBinaryBundlePathOption(options.binaryBundlePath);
+    bundleCodePush(options.framework, options.platform, options.outputPath, options.entryFile, options.bundleName, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir, baseBundlePath);
 });

package/cli/dist/commands/releaseCommand/addToReleaseHistory.js

@@ -1,6 +1,6 @@
 import path from "path";
 import fs from "fs";
-export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
+export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownloadUrl, binaryPatchDownloadUrl, packageHash, getReleaseHistory, setReleaseHistory, platform, identifier, mandatory, enable, rollout) {
     const releaseHistory = await getReleaseHistory(binaryVersion, platform, identifier);
     const updateInfo = releaseHistory[appVersion];
     if (updateInfo) {
@@ -14,6 +14,11 @@ export async function addToReleaseHistory(appVersion, binaryVersion, bundleDownl
         downloadUrl: bundleDownloadUrl,
         packageHash: packageHash,
     };
+    // A release without a binary patch says nothing about one, so that a client reading
+    // this history downloads the full bundle exactly as it did before patches existed.
+    if (binaryPatchDownloadUrl) {
+        newReleaseHistory[appVersion].binaryPatchDownloadUrl = binaryPatchDownloadUrl;
+    }
     if (typeof rollout === 'number') {
         newReleaseHistory[appVersion].rollout = rollout;
     }

package/cli/dist/commands/releaseCommand/index.js

@@ -1,6 +1,7 @@
 import { program, Option } from "commander";
 import { findAndReadConfigFile } from "../../utils/fsUtils.js";
 import { release } from "./release.js";
+import { DEFAULT_OVERSIZED_PATCH_POLICY, OVERSIZED_PATCH_POLICIES, resolveBinaryBundlePathOption, } from "../../functions/makeBinaryPatchBundle.js";
 import { OUTPUT_BUNDLE_DIR, CONFIG_FILE_NAME, ROOT_OUTPUT_DIR, ENTRY_FILE } from "../../constant.js";
 program.command('release')
     .description('Deploys a new CodePush update for a target binary app.\nAfter creating the CodePush bundle, it uploads the file and updates the ReleaseHistory information.\n`bundleUploader`, `getReleaseHistory`, and `setReleaseHistory` functions should be implemented in the config file.')
@@ -21,6 +22,10 @@ program.command('release')
     .option('--skip-cleanup <bool>', 'skip cleanup process', parseBoolean, false)
     .option('--output-metro-dir <string>', 'name of directory to copy the Metro JS bundle and sourcemap before Hermes compilation')
     .option('--output-bundle-dir <string>', 'name of directory containing the bundle file created by the "bundle" command', OUTPUT_BUNDLE_DIR)
+    .option('--binary-bundle-path <string>', 'path to the JS bundle of the target binary. Releases an additional binary patch bundle against it, and aligns the Hermes compilation with it.')
+    .addOption(new Option('--on-oversized-patch <policy>', 'what to do when the binary patch bundle is not smaller than the full bundle: "skip" releases the full bundle only, "fail" stops the release before any upload')
+    .choices(OVERSIZED_PATCH_POLICIES)
+    .default(DEFAULT_OVERSIZED_PATCH_POLICY))
     .action(async (options) => {
     const config = findAndReadConfigFile(process.cwd(), options.config);
     if (typeof options.rollout === 'number' && (options.rollout < 0 || options.rollout > 100)) {
@@ -31,7 +36,9 @@ program.command('release')
         console.error('--hash-calc option can be used only when --skip-bundle is set to true.');
         process.exit(1);
     }
-    await release(config.bundleUploader, config.getReleaseHistory, config.setReleaseHistory, options.binaryVersion, options.appVersion, options.framework, options.platform, options.identifier, options.outputPath, options.entryFile, options.bundleName, options.mandatory, options.enable, options.rollout, options.skipBundle, options.skipCleanup, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir, options.hashCalc);
+    // Resolved before bundling so a wrong path fails now rather than after a build.
+    const baseBundlePath = resolveBinaryBundlePathOption(options.binaryBundlePath);
+    await release(config.bundleUploader, config.getReleaseHistory, config.setReleaseHistory, options.binaryVersion, options.appVersion, options.framework, options.platform, options.identifier, options.outputPath, options.entryFile, options.jsBundleName, options.mandatory, options.enable, options.rollout, options.skipBundle, options.skipCleanup, `${options.outputPath}/${options.outputBundleDir}`, options.outputMetroDir, options.hashCalc, baseBundlePath, options.onOversizedPatch);
     console.log('🚀 Release completed.');
 });
 function parseBoolean(value) {

package/cli/dist/commands/releaseCommand/index.test.js

@@ -0,0 +1,96 @@
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it, jest } from "@jest/globals";
+/**
+ * Checks the command definition against the arguments it forwards, which is where an
+ * option name can silently drift: commander derives the name it stores from the flag,
+ * so reading a differently named property yields `undefined` for every release rather
+ * than an error, and every downstream default looks as if it had been chosen.
+ */
+jest.mock("./release.js");
+jest.mock("../../utils/fsUtils.js", () => ({
+    findAndReadConfigFile: () => ({
+        bundleUploader: async () => ({ downloadUrl: 'https://cdn.example.com/bundle' }),
+        getReleaseHistory: async () => ({}),
+        setReleaseHistory: async () => undefined,
+    }),
+}));
+/**
+ * `release()` takes positional arguments; these are the positions this suite asserts on.
+ */
+const ARG_INDEX = {
+    platform: 6,
+    outputPath: 8,
+    entryFile: 9,
+    jsBundleName: 10,
+    skipBundle: 14,
+    bundleDirectory: 16,
+    baseBundlePath: 19,
+    onOversizedPatch: 20,
+};
+/**
+ * Parses a `release` invocation against the real command definition. Commander is asked
+ * to throw instead of exiting, and to keep its diagnostics to itself, so a rejected
+ * option can be asserted on without ending the worker or the output.
+ */
+async function parseReleaseCommand(args) {
+    const { program } = await import("commander");
+    await import("./index.js");
+    const releaseCommand = program.commands.find((command) => command.name() === 'release');
+    releaseCommand?.exitOverride();
+    releaseCommand?.configureOutput({ writeErr: () => { } });
+    await program.parseAsync(['release', ...args], { from: 'user' });
+}
+async function runReleaseCommand(args) {
+    const { release } = await import("./release.js");
+    await parseReleaseCommand(args);
+    const releaseMock = jest.mocked(release);
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+    return releaseMock.mock.calls[0];
+}
+beforeEach(() => {
+    jest.resetModules();
+    jest.spyOn(console, 'log').mockImplementation(() => { });
+});
+afterEach(() => {
+    jest.restoreAllMocks();
+});
+/** Relative to the CLI workspace root, which is where the test runner starts. */
+const BASE_BUNDLE_FIXTURE = 'fixtures/binary-patch/base.bundle';
+describe("release command options", () => {
+    it("passes the JS bundle name from -j through to the release", async () => {
+        const args = await runReleaseCommand([
+            '-b', '1.0.0',
+            '-v', '1.0.1',
+            '-p', 'android',
+            '-j', 'custom.jsbundle',
+            '--skip-bundle', 'true',
+            '--binary-bundle-path', BASE_BUNDLE_FIXTURE,
+        ]);
+        expect(args[ARG_INDEX.jsBundleName]).toBe('custom.jsbundle');
+        expect(args[ARG_INDEX.platform]).toBe('android');
+        expect(args[ARG_INDEX.skipBundle]).toBe(true);
+        expect(args[ARG_INDEX.baseBundlePath]).toBe(path.resolve(BASE_BUNDLE_FIXTURE));
+    });
+    it("leaves the JS bundle name unset when -j is not given, so the platform default applies", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1']);
+        expect(args[ARG_INDEX.jsBundleName]).toBeUndefined();
+        expect(args[ARG_INDEX.baseBundlePath]).toBeUndefined();
+        expect(args[ARG_INDEX.outputPath]).toBe('build');
+        expect(args[ARG_INDEX.entryFile]).toBe('index.ts');
+        expect(args[ARG_INDEX.bundleDirectory]).toBe('build/bundleOutput');
+    });
+    it("defaults the oversized patch policy to skipping the patch", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1']);
+        expect(args[ARG_INDEX.onOversizedPatch]).toBe('skip');
+    });
+    it("passes the chosen oversized patch policy through to the release", async () => {
+        const args = await runReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--on-oversized-patch', 'fail']);
+        expect(args[ARG_INDEX.onOversizedPatch]).toBe('fail');
+    });
+    it("rejects an oversized patch policy it does not know", async () => {
+        await expect(parseReleaseCommand(['-b', '1.0.0', '-v', '1.0.1', '--on-oversized-patch', 'ask']))
+            .rejects.toThrow(/--on-oversized-patch.*'ask'.*skip, fail/s);
+        const { release } = await import("./release.js");
+        expect(jest.mocked(release)).not.toHaveBeenCalled();
+    });
+});