@hot-updater/expo 0.36.7 → 1.0.0-rc.0

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require("./plugin/build/withHotUpdater");

package/package.json

@@ -1,8 +1,7 @@
 {
   "name": "@hot-updater/expo",
-  "type": "module",
-  "version": "0.36.7",
-  "description": "React Native OTA solution for self-hosted",
+  "version": "1.0.0-rc.0",
+  "description": "Hot Updater build and config plugin for Expo",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.cts",
@@ -21,20 +20,24 @@
   },
   "files": [
     "dist",
+    "app.plugin.js",
+    "plugin/build",
     "package.json"
   ],
   "dependencies": {
     "@babel/core": "7.26.0",
     "@babel/types": "7.26.0",
     "uuidv7": "^1.0.2",
-    "@hot-updater/cli-tools": "0.36.7",
-    "@hot-updater/plugin-core": "0.36.7",
-    "@hot-updater/bare": "0.36.7"
+    "@hot-updater/bare": "1.0.0-rc.0",
+    "@hot-updater/cli-tools": "1.0.0-rc.0",
+    "@hot-updater/plugin-core": "1.0.0-rc.0"
   },
   "devDependencies": {
     "@types/node": "^20",
+    "expo": "^50.0.0",
     "execa": "9.5.2",
-    "vitest": "4.1.4"
+    "vitest": "4.1.4",
+    "hot-updater": "1.0.0-rc.0"
   },
   "exports": {
     ".": {
@@ -45,8 +48,21 @@
       "import": "./dist/babel-plugin.mjs",
       "require": "./dist/babel-plugin.cjs"
     },
+    "./app.plugin.js": "./app.plugin.js",
     "./package.json": "./package.json"
   },
+  "peerDependencies": {
+    "expo": ">=50.0.0",
+    "hot-updater": "*"
+  },
+  "peerDependenciesMeta": {
+    "expo": {
+      "optional": true
+    },
+    "hot-updater": {
+      "optional": true
+    }
+  },
   "inlinedDependencies": {
     "@sec-ant/readable-stream": "0.4.1",
     "@sindresorhus/merge-streams": "4.0.0",
@@ -75,7 +91,7 @@
     "yoctocolors": "2.1.2"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && tsc -p plugin/tsconfig.build.json",
     "test": "vitest run",
     "test:type": "tsc --noEmit"
   }

package/plugin/build/transformers.js

@@ -0,0 +1,314 @@
+"use strict";
+/**
+ * Pure transformation functions for HotUpdater code injection
+ * These utilities handle code transformations for different React Native patterns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformAndroid = transformAndroid;
+exports.transformIOS = transformIOS;
+function findMatchingClosingParen(source, openParenIndex) {
+    let depth = 0;
+    for (let i = openParenIndex; i < source.length; i += 1) {
+        const char = source[i];
+        if (char === "(") {
+            depth += 1;
+            continue;
+        }
+        if (char === ")") {
+            depth -= 1;
+            if (depth === 0) {
+                return i;
+            }
+        }
+    }
+    return -1;
+}
+/**
+ * Helper to add lines if they don't exist, anchored by a specific string.
+ */
+function addLinesOnce(contents, anchor, linesToAdd) {
+    if (linesToAdd.every((line) => contents.includes(line))) {
+        // All lines already exist, do nothing
+        return contents;
+    }
+    // Check if the anchor exists
+    if (!contents.includes(anchor)) {
+        // Anchor not found, cannot add lines reliably.
+        return contents;
+    }
+    // Add lines after the anchor
+    return contents.replace(anchor, `${anchor}\n${linesToAdd.join("\n")}`);
+}
+/**
+ * Android: handle getDefaultReactHost pattern (RN 0.82+ style).
+ * Adds jsBundleFilePath parameter to the call.
+ */
+function transformAndroidReactHost(contents) {
+    const kotlinImport = "import com.hotupdater.HotUpdater";
+    const kotlinImportAnchor = "import com.facebook.react.ReactApplication";
+    // Quick pattern detection: only touch files using getDefaultReactHost
+    // with the new RN 0.82+ parameter style.
+    if (!contents.includes("getDefaultReactHost(") ||
+        !contents.includes("packageList =")) {
+        return contents;
+    }
+    // 1. Ensure HotUpdater import exists (idempotent via addLinesOnce)
+    const result = addLinesOnce(contents, kotlinImportAnchor, [kotlinImport]);
+    const callNeedle = "getDefaultReactHost(";
+    const callStartIndex = result.indexOf(callNeedle);
+    if (callStartIndex === -1) {
+        return result;
+    }
+    const openParenIndex = callStartIndex + callNeedle.length - 1;
+    const closeParenIndex = findMatchingClosingParen(result, openParenIndex);
+    if (closeParenIndex === -1) {
+        return result;
+    }
+    const callContents = result.slice(callStartIndex, closeParenIndex + 1);
+    const kotlinLegacyBundlePathRegex = /^([ \t]*)jsBundleFilePath = HotUpdater\.getJSBundleFile\(applicationContext\),[ \t]*\r?$/m;
+    const legacyBundlePathMatch = callContents.match(kotlinLegacyBundlePathRegex);
+    if (legacyBundlePathMatch) {
+        const paramIndent = legacyBundlePathMatch[1];
+        const jsBundleLines = [
+            `${paramIndent}jsBundleFilePath = if (BuildConfig.DEBUG) {`,
+            `${paramIndent}  null`,
+            `${paramIndent}} else {`,
+            `${paramIndent}  HotUpdater.getJSBundleFile(applicationContext)`,
+            `${paramIndent}},`,
+        ];
+        const migratedCallContents = callContents.replace(kotlinLegacyBundlePathRegex, jsBundleLines.join("\n"));
+        return `${result.slice(0, callStartIndex)}${migratedCallContents}${result.slice(closeParenIndex + 1)}`;
+    }
+    if (callContents.includes("jsBundleFilePath")) {
+        return result;
+    }
+    const callLines = callContents.split("\n");
+    // Determine the indentation used for parameters (e.g. "      ")
+    let paramIndent = "";
+    for (let i = 1; i < callLines.length; i += 1) {
+        const line = callLines[i];
+        const trimmed = line.trim();
+        if (trimmed.length === 0) {
+            continue;
+        }
+        if (trimmed.startsWith(")")) {
+            // No parameters detected, give up safely.
+            return result;
+        }
+        const indentMatch = line.match(/^(\s*)/);
+        paramIndent = indentMatch ? indentMatch[1] : "";
+        break;
+    }
+    if (!paramIndent) {
+        return result;
+    }
+    const closingLineStartIndex = result.lastIndexOf("\n", closeParenIndex);
+    const insertionIndex = closingLineStartIndex === -1 ? 0 : closingLineStartIndex + 1;
+    let prefix = result.slice(0, insertionIndex);
+    const suffix = result.slice(insertionIndex);
+    let prevNonWhitespaceIndex = prefix.length - 1;
+    while (prevNonWhitespaceIndex >= 0 &&
+        /\s/.test(prefix[prevNonWhitespaceIndex])) {
+        prevNonWhitespaceIndex -= 1;
+    }
+    if (prevNonWhitespaceIndex >= 0 &&
+        prefix[prevNonWhitespaceIndex] !== "," &&
+        prefix[prevNonWhitespaceIndex] !== "(") {
+        prefix = `${prefix.slice(0, prevNonWhitespaceIndex + 1)},${prefix.slice(prevNonWhitespaceIndex + 1)}`;
+    }
+    const jsBundleLines = [
+        `${paramIndent}jsBundleFilePath = if (BuildConfig.DEBUG) {`,
+        `${paramIndent}  null`,
+        `${paramIndent}} else {`,
+        `${paramIndent}  HotUpdater.getJSBundleFile(applicationContext)`,
+        `${paramIndent}},`,
+    ];
+    return `${prefix}${jsBundleLines.join("\n")}\n${suffix}`;
+}
+/**
+ * Android: DefaultReactNativeHost pattern (RN 0.81 / Expo 54).
+ * Adds getJSBundleFile() override to the host.
+ */
+function transformAndroidDefaultHost(contents) {
+    const kotlinImport = "import com.hotupdater.HotUpdater";
+    const kotlinImportAnchor = "import com.facebook.react.ReactApplication";
+    const kotlinReactNativeHostAnchor = "object : DefaultReactNativeHost(this) {";
+    const kotlinMethodCheck = "HotUpdater.getJSBundleFile(applicationContext)";
+    const kotlinLegacyMethodRegex = /^([ \t]*)override fun getJSBundleFile\(\): String\? \{[ \t]*\r?\n([ \t]*)return HotUpdater\.getJSBundleFile\(applicationContext\)[ \t]*\r?\n\1\}[ \t]*$/m;
+    const kotlinExistingMethodRegex = /^\s*override fun getJSBundleFile\(\): String\?\s*\{[\s\S]*?^\s*\}/gm;
+    const kotlinHermesAnchor = "override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED";
+    const kotlinNewArchAnchor = "override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED";
+    // Check if this is the old pattern with DefaultReactNativeHost
+    if (!contents.includes(kotlinReactNativeHostAnchor)) {
+        return contents;
+    }
+    // 1. Add import if missing
+    let result = addLinesOnce(contents, kotlinImportAnchor, [kotlinImport]);
+    const legacyMethodMatch = result.match(kotlinLegacyMethodRegex);
+    if (legacyMethodMatch) {
+        const methodIndent = legacyMethodMatch[1];
+        const bodyIndent = legacyMethodMatch[2];
+        const methodLines = [
+            `${methodIndent}override fun getJSBundleFile(): String? {`,
+            `${bodyIndent}return if (BuildConfig.DEBUG) {`,
+            `${bodyIndent}  null`,
+            `${bodyIndent}} else {`,
+            `${bodyIndent}  HotUpdater.getJSBundleFile(applicationContext)`,
+            `${bodyIndent}}`,
+            `${methodIndent}}`,
+        ];
+        result = result.replace(kotlinLegacyMethodRegex, methodLines.join("\n"));
+    }
+    // 2. Add/Replace getJSBundleFile method if needed
+    if (!result.includes(kotlinMethodCheck)) {
+        // Remove potentially existing (different) override first
+        result = result.replace(kotlinExistingMethodRegex, "");
+        const lines = result.split("\n");
+        const findLineIndex = (needle) => {
+            for (let i = 0; i < lines.length; i += 1) {
+                if (lines[i].includes(needle)) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+        // Prefer inserting after Hermes line, then after new architecture line
+        let anchorIndex = findLineIndex(kotlinHermesAnchor);
+        if (anchorIndex === -1) {
+            anchorIndex = findLineIndex(kotlinNewArchAnchor);
+        }
+        if (anchorIndex !== -1) {
+            const indentMatch = lines[anchorIndex].match(/^\s*/);
+            const indent = indentMatch ? indentMatch[0] : "";
+            const objectLine = lines.find((line) => line.includes("object : DefaultReactNativeHost"));
+            let indentSize = 2;
+            if (objectLine) {
+                const objectIndent = (objectLine.match(/^\s*/)?.[0] || "").length;
+                const propertyIndent = indent.length;
+                const diff = propertyIndent - objectIndent;
+                if (diff > 0) {
+                    indentSize = diff;
+                }
+            }
+            const spaces = indentSize === 2 ? "  " : "    ";
+            const bodyIndent = indent + spaces;
+            const methodLines = [
+                "", // blank line
+                `${indent}override fun getJSBundleFile(): String? {`,
+                `${bodyIndent}return if (BuildConfig.DEBUG) {`,
+                `${bodyIndent}  null`,
+                `${bodyIndent}} else {`,
+                `${bodyIndent}  HotUpdater.getJSBundleFile(applicationContext)`,
+                `${bodyIndent}}`,
+                `${indent}}`,
+            ];
+            const insertIndex = anchorIndex + 1;
+            lines.splice(insertIndex, 0, ...methodLines);
+            result = lines.join("\n");
+        }
+        else {
+            // Fallback: insert before the closing brace of the object block
+            const hostStartIndex = lines.findIndex((line) => line.includes("object : DefaultReactNativeHost"));
+            if (hostStartIndex === -1) {
+                throw new Error("[transformAndroidDefaultHost] Could not find DefaultReactNativeHost block.");
+            }
+            let hostEndIndex = -1;
+            for (let i = lines.length - 1; i > hostStartIndex; i -= 1) {
+                if (lines[i].trim() === "}") {
+                    hostEndIndex = i;
+                    break;
+                }
+            }
+            if (hostEndIndex === -1) {
+                throw new Error("[transformAndroidDefaultHost] Could not find end of DefaultReactNativeHost block.");
+            }
+            const indentMatch = lines[hostEndIndex].match(/^\s*/);
+            const indent = indentMatch ? indentMatch[0] : "";
+            const bodyIndent = `${indent}  `;
+            const methodLines = [
+                `${indent}override fun getJSBundleFile(): String? {`,
+                `${bodyIndent}return if (BuildConfig.DEBUG) {`,
+                `${bodyIndent}  null`,
+                `${bodyIndent}} else {`,
+                `${bodyIndent}  HotUpdater.getJSBundleFile(applicationContext)`,
+                `${bodyIndent}}`,
+                `${indent}}`,
+            ];
+            lines.splice(hostEndIndex, 0, ...methodLines);
+            result = lines.join("\n");
+        }
+    }
+    return result;
+}
+/**
+ * Public Android transformer that applies all Android-specific transforms.
+ */
+function transformAndroid(contents) {
+    let result = contents;
+    result = transformAndroidReactHost(result);
+    result = transformAndroidDefaultHost(result);
+    return result;
+}
+/**
+ * iOS: Objective-C AppDelegate transformation.
+ * Replaces NSBundle-based bundleURL with HotUpdater bundleURL.
+ */
+function transformIOSObjC(contents) {
+    const iosImport = "#import <HotUpdater/HotUpdater.h>";
+    const iosBundleUrl = "[HotUpdater bundleURL]";
+    const iosOriginalBundleUrlRegex = /\[\[NSBundle mainBundle\] URLForResource:@"main" withExtension:@"jsbundle"\]/g;
+    const iosAppDelegateHeader = '#import "AppDelegate.h"';
+    // Check if it's likely Obj-C
+    if (!contents.includes(iosAppDelegateHeader)) {
+        return contents;
+    }
+    let result = contents;
+    // 1. Ensure HotUpdater import is present
+    if (!result.includes(iosImport)) {
+        result = addLinesOnce(result, iosAppDelegateHeader, [iosImport]);
+    }
+    // 2. Swap NSBundle-based URL with HotUpdater bundleURL, but only once
+    if (!result.includes(iosBundleUrl) &&
+        iosOriginalBundleUrlRegex.test(result)) {
+        result = result.replace(iosOriginalBundleUrlRegex, iosBundleUrl);
+    }
+    return result;
+}
+/**
+ * iOS: Swift / Expo AppDelegate transformation.
+ * Replaces Bundle.main.url-based bundleURL with HotUpdater.bundleURL().
+ */
+function transformIOSSwift(contents) {
+    const swiftImport = "import HotUpdater";
+    const swiftBundleUrl = "HotUpdater.bundleURL()";
+    const swiftOriginalBundleUrlRegex = /Bundle\.main\.url\(forResource: "?main"?, withExtension: "jsbundle"\)/g;
+    // Check if it's likely Swift AppDelegate code
+    if (!contents.includes("import ")) {
+        return contents;
+    }
+    // 1. Add import if missing - find the last import statement and add after it
+    let result = contents;
+    if (!result.includes(swiftImport)) {
+        // Find the last import statement
+        const lastImportMatch = result.match(/^import .*$/gm);
+        if (lastImportMatch) {
+            const lastImport = lastImportMatch[lastImportMatch.length - 1];
+            result = result.replace(lastImport, `${lastImport}\n${swiftImport}`);
+        }
+    }
+    // 2. Replace bundleURL provider if the original exists and hasn't been replaced
+    if (!result.includes(swiftBundleUrl) &&
+        swiftOriginalBundleUrlRegex.test(result)) {
+        result = result.replace(swiftOriginalBundleUrlRegex, swiftBundleUrl);
+    }
+    return result;
+}
+/**
+ * Public iOS transformer that applies both Objective-C and Swift transforms.
+ */
+function transformIOS(contents) {
+    let result = contents;
+    result = transformIOSObjC(result);
+    result = transformIOSSwift(result);
+    return result;
+}

package/plugin/build/withHotUpdater.js

@@ -0,0 +1,222 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPublicKeyFromConfig = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const path_1 = __importDefault(require("path"));
+const config_plugins_1 = require("expo/config-plugins");
+const package_json_1 = __importDefault(require("../../package.json"));
+const transformers_1 = require("./transformers");
+const loadCliTools = () => import("@hot-updater/cli-tools");
+const loadHotUpdater = () => import("hot-updater");
+const canonicalizeRsaSpkiPublicKey = (publicKeyPem) => {
+    const trimmed = publicKeyPem.trim();
+    if (!trimmed.startsWith("-----BEGIN PUBLIC KEY-----") ||
+        !trimmed.endsWith("-----END PUBLIC KEY-----") ||
+        trimmed.includes("PRIVATE KEY")) {
+        throw new Error("not spki");
+    }
+    const publicKey = (0, node_crypto_1.createPublicKey)(trimmed);
+    if (publicKey.asymmetricKeyType !== "rsa" ||
+        (publicKey.asymmetricKeyDetails?.modulusLength ?? 0) < 2048) {
+        throw new Error("not rsa");
+    }
+    return publicKey.export({ format: "pem", type: "spki" }).toString().trim();
+};
+const ANDROID_META_DATA_KEYS = {
+    channel: "com.hotupdater.CHANNEL",
+    fingerprintHash: "com.hotupdater.FINGERPRINT_HASH",
+    publicKey: "com.hotupdater.PUBLIC_KEY",
+};
+const removeAndroidMetaData = (application, name) => {
+    const metaData = application["meta-data"];
+    if (!metaData) {
+        return;
+    }
+    const filtered = (Array.isArray(metaData) ? metaData : [metaData]).filter((item) => item?.$?.["android:name"] !== name);
+    if (filtered.length === 0) {
+        delete application["meta-data"];
+    }
+    else {
+        application["meta-data"] = filtered;
+    }
+};
+const upsertAndroidMetaData = (application, name, value) => {
+    removeAndroidMetaData(application, name);
+    const metaData = Array.isArray(application["meta-data"])
+        ? application["meta-data"]
+        : application["meta-data"]
+            ? [application["meta-data"]]
+            : [];
+    metaData.push({
+        $: {
+            "android:name": name,
+            "android:value": value,
+        },
+    });
+    application["meta-data"] = metaData;
+};
+let fingerprintCache = null;
+const getFingerprint = async () => {
+    if (fingerprintCache) {
+        return fingerprintCache;
+    }
+    const { createFingerprintJSON, generateFingerprints } = await loadHotUpdater();
+    fingerprintCache = await generateFingerprints();
+    await createFingerprintJSON(fingerprintCache);
+    return fingerprintCache;
+};
+/** Uses public-key-only configuration, or the v0 local key sources when omitted. */
+const getPublicKeyFromConfig = async (signingConfig) => {
+    if (!signingConfig ||
+        ("enabled" in signingConfig && !signingConfig.enabled)) {
+        return null;
+    }
+    // Retain the v0 EAS key source only for local configs without an explicit pin.
+    if ("enabled" in signingConfig && signingConfig.publicKeyPath === undefined) {
+        const envPrivateKey = process.env.HOT_UPDATER_PRIVATE_KEY;
+        if (envPrivateKey) {
+            try {
+                const pem = envPrivateKey.includes("-----BEGIN")
+                    ? envPrivateKey
+                    : await (0, promises_1.readFile)(path_1.default.resolve(process.cwd(), envPrivateKey), "utf8");
+                return canonicalizeRsaSpkiPublicKey((0, node_crypto_1.createPublicKey)((0, node_crypto_1.createPrivateKey)(pem))
+                    .export({ format: "pem", type: "spki" })
+                    .toString());
+            }
+            catch {
+                // As in v0, try the configured local files if the environment source fails.
+            }
+        }
+    }
+    try {
+        const { getBundleSigningPublicKey } = await loadCliTools();
+        return ((await getBundleSigningPublicKey(signingConfig, { cwd: process.cwd() }))?.trim() ?? null);
+    }
+    catch {
+        throw new Error(signingConfig.publicKeyPath !== undefined
+            ? "[hot-updater] Failed to load publicKeyPath for bundle signing."
+            : "[hot-updater] Failed to load public key for bundle signing.");
+    }
+};
+exports.getPublicKeyFromConfig = getPublicKeyFromConfig;
+/**
+ * Native code modifications - should only run once
+ */
+const withHotUpdaterNativeCode = (config) => {
+    let modifiedConfig = config;
+    // === iOS: Objective-C & Swift in AppDelegate ===
+    modifiedConfig = (0, config_plugins_1.withAppDelegate)(modifiedConfig, (cfg) => {
+        let contents = cfg.modResults.contents;
+        contents = (0, transformers_1.transformIOS)(contents);
+        cfg.modResults.contents = contents;
+        return cfg;
+    });
+    // === Android: Kotlin in MainApplication ===
+    modifiedConfig = (0, config_plugins_1.withMainApplication)(modifiedConfig, (cfg) => {
+        let contents = cfg.modResults.contents;
+        contents = (0, transformers_1.transformAndroid)(contents);
+        cfg.modResults.contents = contents;
+        return cfg;
+    });
+    return modifiedConfig;
+};
+/**
+ * Configuration updates - should run every time
+ */
+const withHotUpdaterConfigAsync = (props) => (config) => {
+    const channel = props.channel || "production";
+    let hotUpdaterConfigPromise;
+    const getHotUpdaterConfig = async () => {
+        if (!hotUpdaterConfigPromise) {
+            const { loadConfig } = await loadCliTools();
+            hotUpdaterConfigPromise = loadConfig(null);
+        }
+        return hotUpdaterConfigPromise;
+    };
+    let publicKeyPromise;
+    const getPublicKey = async () => {
+        if (!publicKeyPromise) {
+            publicKeyPromise = getHotUpdaterConfig().then(($config) => (0, exports.getPublicKeyFromConfig)($config.signing));
+        }
+        return publicKeyPromise;
+    };
+    let modifiedConfig = config;
+    // === iOS: Add channel and fingerprint to Info.plist ===
+    modifiedConfig = (0, config_plugins_1.withInfoPlist)(modifiedConfig, async (cfg) => {
+        let fingerprintHash = null;
+        const hotUpdaterConfig = await getHotUpdaterConfig();
+        if (hotUpdaterConfig.updateStrategy !== "appVersion") {
+            const fingerprint = await getFingerprint();
+            fingerprintHash = fingerprint.ios.hash;
+        }
+        // Load public key if signing is enabled
+        const publicKey = await getPublicKey();
+        cfg.modResults.HOT_UPDATER_CHANNEL = channel;
+        if (fingerprintHash) {
+            cfg.modResults.HOT_UPDATER_FINGERPRINT_HASH = fingerprintHash;
+        }
+        if (publicKey) {
+            cfg.modResults.HOT_UPDATER_PUBLIC_KEY = publicKey;
+        }
+        else {
+            delete cfg.modResults.HOT_UPDATER_PUBLIC_KEY;
+        }
+        return cfg;
+    });
+    // === Android: Add channel and fingerprint to AndroidManifest.xml ===
+    modifiedConfig = (0, config_plugins_1.withAndroidManifest)(modifiedConfig, async (cfg) => {
+        let fingerprintHash = null;
+        const hotUpdaterConfig = await getHotUpdaterConfig();
+        if (hotUpdaterConfig.updateStrategy !== "appVersion") {
+            const fingerprint = await getFingerprint();
+            fingerprintHash = fingerprint.android.hash;
+        }
+        // Load public key if signing is enabled
+        const publicKey = await getPublicKey();
+        const application = cfg.modResults.manifest.application?.[0];
+        if (!application) {
+            return cfg;
+        }
+        upsertAndroidMetaData(application, ANDROID_META_DATA_KEYS.channel, channel);
+        if (fingerprintHash) {
+            upsertAndroidMetaData(application, ANDROID_META_DATA_KEYS.fingerprintHash, fingerprintHash);
+        }
+        if (publicKey) {
+            upsertAndroidMetaData(application, ANDROID_META_DATA_KEYS.publicKey, publicKey);
+        }
+        else {
+            removeAndroidMetaData(application, ANDROID_META_DATA_KEYS.publicKey);
+        }
+        return cfg;
+    });
+    // Remove legacy Hot Updater string resources when prebuild reuses a tree.
+    modifiedConfig = (0, config_plugins_1.withStringsXml)(modifiedConfig, (cfg) => {
+        const strings = cfg.modResults.resources?.string;
+        if (!strings) {
+            return cfg;
+        }
+        cfg.modResults.resources.string = (Array.isArray(strings) ? strings : [strings]).filter((item) => item.$?.name !== "hot_updater_channel" &&
+            item.$?.name !== "hot_updater_fingerprint_hash" &&
+            item.$?.name !== "hot_updater_public_key");
+        return cfg;
+    });
+    return modifiedConfig;
+};
+/**
+ * Main plugin that combines both native code (run once) and config (run always)
+ */
+const withHotUpdater = (config, props = {}) => {
+    // Apply plugins in order
+    return (0, config_plugins_1.withPlugins)(config, [
+        // Native code modifications - wrapped with createRunOncePlugin
+        (0, config_plugins_1.createRunOncePlugin)(withHotUpdaterNativeCode, `${package_json_1.default.name}-native`, package_json_1.default.version),
+        // Configuration updates - runs every time
+        withHotUpdaterConfigAsync(props),
+    ]);
+};
+// Export the main plugin
+exports.default = withHotUpdater;