@onekeyfe/hd-core 1.2.0-alpha.40 → 1.2.0-alpha.42

package/dist/index.js

@@ -10,8 +10,8 @@ var lodash = require('lodash');
 var ByteBuffer = require('bytebuffer');
 var blake2s = require('@noble/hashes/blake2s');
 var utils = require('@noble/hashes/utils');
-var BigNumber = require('bignumber.js');
 var sha256 = require('@noble/hashes/sha256');
+var BigNumber = require('bignumber.js');
 var JSZip = require('jszip');
 var sha3 = require('@noble/hashes/sha3');
 var blake2b = require('@noble/hashes/blake2b');
@@ -26252,6 +26252,8 @@ var nested = {
 			MessageType_DeviceInfo: 60601,
 			MessageType_DeviceStatusGet: 60602,
 			MessageType_DeviceStatus: 60603,
+			MessageType_ResourceInventoryGet: 60604,
+			MessageType_ResourceInventory: 60605,
 			MessageType_FilesystemPermissionFix: 60800,
 			MessageType_FilesystemPathInfo: 60801,
 			MessageType_FilesystemPathInfoQuery: 60802,
@@ -37844,6 +37846,16 @@ var nested = {
 			APP: 85
 		}
 	},
+	ResourceBundleType: {
+		values: {
+			IMAGES: 0,
+			ANIMATION: 1,
+			WALLPAPER: 2,
+			TRANSLATIONS: 3,
+			ROOBERT: 4,
+			NOTO: 5
+		}
+	},
 	DeviceFirmwareImageInfo: {
 		fields: {
 			version: {
@@ -38041,6 +38053,38 @@ var nested = {
 			}
 		}
 	},
+	ResourceInventoryGet: {
+		fields: {
+		}
+	},
+	ResourceInventoryItem: {
+		fields: {
+			type: {
+				rule: "required",
+				type: "ResourceBundleType",
+				id: 1
+			},
+			size: {
+				rule: "required",
+				type: "uint32",
+				id: 2
+			},
+			header_hash: {
+				rule: "required",
+				type: "bytes",
+				id: 3
+			}
+		}
+	},
+	ResourceInventory: {
+		fields: {
+			items: {
+				rule: "repeated",
+				type: "ResourceInventoryItem",
+				id: 1
+			}
+		}
+	},
 	DeviceSessionErrorCode: {
 		values: {
 			DeviceSessionError_None: 0,
@@ -39407,6 +39451,168 @@ const findLatestRelease = (releases) => {
     return leastRelease;
 };
 
+const PROTOCOL_V2_RESOURCE_TYPES = [
+    'images',
+    'animation',
+    'wallpaper',
+    'translations',
+    'roobert',
+    'noto',
+];
+const PROTOCOL_V2_RESOURCE_DEVICE_PATHS = {
+    images: 'vol0:/bundles/images/images.okpkg',
+    animation: 'vol0:/bundles/images/animation.okpkg',
+    wallpaper: 'vol0:/bundles/images/wallpaper.okpkg',
+    translations: 'vol0:/bundles/translations/translations.okpkg',
+    roobert: 'vol0:/bundles/font/roobert.okpkg',
+    noto: 'vol0:/bundles/font/noto.okpkg',
+};
+const RESOURCE_TYPE_SET = new Set(PROTOCOL_V2_RESOURCE_TYPES);
+const SHA256_HEX_LENGTH = 64;
+const SHA3_512_HEX_LENGTH = 128;
+const PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS = 5 * 1000;
+const RESOURCE_TYPE_BY_DEVICE_VALUE = {
+    '0': 'images',
+    IMAGES: 'images',
+    '1': 'animation',
+    ANIMATION: 'animation',
+    '2': 'wallpaper',
+    WALLPAPER: 'wallpaper',
+    '3': 'translations',
+    TRANSLATIONS: 'translations',
+    '4': 'roobert',
+    ROOBERT: 'roobert',
+    '5': 'noto',
+    NOTO: 'noto',
+};
+function parseProtocolV2ResourceInventory(value) {
+    const items = value === null || value === void 0 ? void 0 : value.items;
+    if (!Array.isArray(items)) {
+        throw new Error('Invalid Pro2 resource inventory: items must be an array');
+    }
+    const inventory = items.map((item, index) => {
+        if (!item || typeof item !== 'object') {
+            throw new Error(`Invalid Pro2 resource inventory item at ${index}`);
+        }
+        const raw = item;
+        const type = RESOURCE_TYPE_BY_DEVICE_VALUE[String(raw.type).toUpperCase()];
+        if (!type) {
+            throw new Error(`Invalid Pro2 resource inventory type at ${index}`);
+        }
+        if (!Number.isSafeInteger(raw.size) || Number(raw.size) <= 0) {
+            throw new Error(`Invalid Pro2 resource inventory size at ${index}`);
+        }
+        return {
+            type,
+            size: Number(raw.size),
+            headerHash: normalizeHex$1(raw.header_hash, SHA3_512_HEX_LENGTH, 'inventory headerHash'),
+        };
+    });
+    if (new Set(inventory.map(item => item.type)).size !== inventory.length) {
+        throw new Error('Invalid Pro2 resource inventory: duplicate resource type');
+    }
+    return PROTOCOL_V2_RESOURCE_TYPES.flatMap(type => {
+        const item = inventory.find(candidate => candidate.type === type);
+        return item ? [item] : [];
+    });
+}
+function requestProtocolV2ResourceInventory({ commands, timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { message } = yield commands.typedCall('ResourceInventoryGet', 'ResourceInventory', {}, { timeoutMs });
+        return parseProtocolV2ResourceInventory(message);
+    });
+}
+function normalizeHex$1(value, expectedLength, field) {
+    if (typeof value !== 'string') {
+        throw new Error(`Invalid Pro2 resource ${field}: expected a hexadecimal string`);
+    }
+    const normalized = value.replace(/^0x/i, '').toLowerCase();
+    if (normalized.length !== expectedLength || !/^[0-9a-f]+$/.test(normalized)) {
+        throw new Error(`Invalid Pro2 resource ${field}: expected ${expectedLength} hexadecimal characters`);
+    }
+    return normalized;
+}
+function validateResource(value, index) {
+    if (!value || typeof value !== 'object') {
+        throw new Error(`Invalid Pro2 resource at stable[${index}]`);
+    }
+    const resource = value;
+    if (typeof resource.type !== 'string' || !RESOURCE_TYPE_SET.has(resource.type)) {
+        throw new Error(`Invalid Pro2 resource type at stable[${index}]`);
+    }
+    if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
+        throw new Error(`Invalid Pro2 resource url at stable[${index}]`);
+    }
+    if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
+        throw new Error(`Invalid Pro2 resource size at stable[${index}]`);
+    }
+    return {
+        type: resource.type,
+        url: resource.url,
+        size: Number(resource.size),
+        fileHash: normalizeHex$1(resource.fileHash, SHA256_HEX_LENGTH, 'fileHash'),
+        headerHash: normalizeHex$1(resource.headerHash, SHA3_512_HEX_LENGTH, 'headerHash'),
+    };
+}
+function parseProtocolV2Resources(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value ||
+        typeof value !== 'object' ||
+        !Array.isArray(value.stable)) {
+        throw new Error('Invalid Pro2 resources config: stable must be an array');
+    }
+    const stable = value.stable.map(validateResource);
+    const types = new Set(stable.map(resource => resource.type));
+    if (stable.length !== PROTOCOL_V2_RESOURCE_TYPES.length || types.size !== stable.length) {
+        throw new Error('Invalid Pro2 resources config: stable must contain six unique resource types');
+    }
+    for (const type of PROTOCOL_V2_RESOURCE_TYPES) {
+        if (!types.has(type)) {
+            throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
+        }
+    }
+    return {
+        stable: PROTOCOL_V2_RESOURCE_TYPES.map(type => {
+            const resource = stable.find(item => item.type === type);
+            if (!resource) {
+                throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
+            }
+            return resource;
+        }),
+    };
+}
+function buildProtocolV2ResourceUpdatePlan({ resources, inventory, mode, forced = false, }) {
+    if (mode === 'bootloader-recovery' || forced) {
+        return {
+            status: resources.length > 0 ? 'outdated' : 'valid',
+            resources: [...resources],
+        };
+    }
+    if (!inventory) {
+        return { status: 'unknown', resources: [] };
+    }
+    const inventoryByType = new Map(inventory.map(item => [item.type, item]));
+    const changedResources = resources.filter(resource => {
+        const current = inventoryByType.get(resource.type);
+        return (!current ||
+            current.size !== resource.size ||
+            current.headerHash.toLowerCase() !== resource.headerHash.toLowerCase());
+    });
+    return {
+        status: changedResources.length === 0 ? 'valid' : 'outdated',
+        resources: changedResources,
+    };
+}
+function bytesToHex$3(bytes) {
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+}
+function isProtocolV2ResourceFileValid(binary, resource) {
+    if (binary.byteLength !== resource.size)
+        return false;
+    return bytesToHex$3(sha256.sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();
+}
+
 var _a$1;
 const Log$i = getLogger(exports.LoggerNames.Core);
 const FIRMWARE_FIELDS = [
@@ -39460,10 +39666,11 @@ class DataManager {
         return enrichedData;
     }
     static load(settings) {
+        var _b;
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
             if (!settings.fetchConfig) {
-                return;
+                return false;
             }
             const url = settings.preRelease
                 ? 'https://data.onekey.so/pre-config.json'
@@ -39502,6 +39709,7 @@ class DataManager {
                 }
             }
             if (data) {
+                const pro2Resources = parseProtocolV2Resources((_b = data.pro2) === null || _b === void 0 ? void 0 : _b.resources);
                 Log$i.log(`[DataConfig] Config loaded successfully via [${fetchMethod}]`);
                 this.deviceMap = {
                     [hdShared.EDeviceType.Classic]: this.enrichFirmwareReleaseInfo(data.classic),
@@ -39510,15 +39718,15 @@ class DataManager {
                     [hdShared.EDeviceType.Mini]: this.enrichFirmwareReleaseInfo(data.mini),
                     [hdShared.EDeviceType.Touch]: this.enrichFirmwareReleaseInfo(data.touch),
                     [hdShared.EDeviceType.Pro]: this.enrichFirmwareReleaseInfo(data.pro),
-                    [hdShared.EDeviceType.Pro2]: this.enrichFirmwareReleaseInfo(data.pro2),
+                    [hdShared.EDeviceType.Pro2]: Object.assign(Object.assign({}, this.enrichFirmwareReleaseInfo(data.pro2)), (pro2Resources ? { resources: pro2Resources } : undefined)),
                 };
                 this.assets = {
                     bridge: data.bridge,
                 };
+                return true;
             }
-            else {
-                Log$i.warn('[DataConfig] All fetch methods failed, using built-in default config');
-            }
+            Log$i.warn('[DataConfig] All fetch methods failed, using built-in default config');
+            return false;
         });
     }
     static updateEnv(newEnv) {
@@ -39531,12 +39739,29 @@ class DataManager {
     static checkAndReloadData() {
         return __awaiter(this, void 0, void 0, function* () {
             if (getTimeStamp() - this.lastCheckTimestamp > 1000 * 60 * 60 * 3) {
-                yield this.load(this.settings).then(() => {
+                const loaded = yield this.load(this.settings);
+                if (loaded) {
                     this.lastCheckTimestamp = getTimeStamp();
-                });
+                }
             }
         });
     }
+    static forceReloadData() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.settings) {
+                throw new Error('Remote config settings are not initialized');
+            }
+            const loaded = yield this.load(this.settings);
+            if (!loaded) {
+                throw new Error('Unable to refresh the latest remote config');
+            }
+            this.lastCheckTimestamp = getTimeStamp();
+        });
+    }
+    static getProtocolV2Resources() {
+        var _b, _c;
+        return (_c = (_b = this.deviceMap[hdShared.EDeviceType.Pro2]) === null || _b === void 0 ? void 0 : _b.resources) === null || _c === void 0 ? void 0 : _c.stable;
+    }
     static getProtobufMessages(schema = 'v1CurrentSchema') {
         return this.messages[schema];
     }
@@ -45840,7 +46065,6 @@ function buildComponentRelease({ configKey, component, currentVersions, currentV
     };
 }
 function buildProtocolV2FirmwareRelease({ currentVersions, currentVerification = {}, remotePayloadHashes = {}, firmwareType, release, }) {
-    var _a;
     if (!release) {
         return {
             firmwareType,
@@ -45874,9 +46098,6 @@ function buildProtocolV2FirmwareRelease({ currentVersions, currentVerification =
         }
     }
     const targetsToUpdate = components.flatMap(component => component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : []);
-    if (targetsToUpdate.length > 0 && ((_a = release.resourceBundles) === null || _a === void 0 ? void 0 : _a.length)) {
-        targetsToUpdate.push('resource');
-    }
     const uniqueTargetsToUpdate = Array.from(new Set(targetsToUpdate));
     const hasUpgrade = uniqueTargetsToUpdate.length > 0;
     const required = release.required && hasUpgrade;
@@ -45981,9 +46202,39 @@ class CheckAllFirmwareRelease extends BaseMethod {
                 firmwareType,
                 release,
             });
+            const resources = DataManager.getProtocolV2Resources();
+            let resourceStatus = 'unknown';
+            if (resources === null || resources === void 0 ? void 0 : resources.length) {
+                const loaderMode = state.status.mode === 'bootloader' || state.status.mode === 'romloader';
+                if (loaderMode) {
+                    resourceStatus = buildProtocolV2ResourceUpdatePlan({
+                        resources,
+                        mode: 'bootloader-recovery',
+                    }).status;
+                }
+                else if (state.status.mode === 'normal') {
+                    try {
+                        const inventory = yield requestProtocolV2ResourceInventory({
+                            commands: this.device.getCommands(),
+                        });
+                        resourceStatus = buildProtocolV2ResourceUpdatePlan({
+                            resources,
+                            inventory,
+                            mode: 'application',
+                        }).status;
+                    }
+                    catch (_b) {
+                        resourceStatus = 'unknown';
+                    }
+                }
+            }
+            const targetsToUpdate = [
+                ...plan.targetsToUpdate,
+                ...(resourceStatus === 'outdated' ? ['resource'] : []),
+            ];
             const firmwareStatus = plan.status === 'unavailable' ? 'unknown' : plan.status;
             const emptyRelease = 'none';
-            return Object.assign({ firmware: {
+            return Object.assign(Object.assign({ firmware: {
                     status: firmwareStatus,
                     changelog: release ? [release.changelog] : [],
                     release: release !== null && release !== void 0 ? release : emptyRelease,
@@ -45994,7 +46245,7 @@ class CheckAllFirmwareRelease extends BaseMethod {
                 }, bootloader: {
                     status: 'valid',
                     release: emptyRelease,
-                }, features, protocol: 'V2', deviceType: 'pro2' }, plan);
+                }, features, protocol: 'V2', deviceType: 'pro2' }, plan), { resourceStatus, hasUpgrade: plan.hasUpgrade || resourceStatus === 'outdated', targetsToUpdate });
         });
     }
 }
@@ -48855,18 +49106,6 @@ const normalizeProtocolV2TargetStatus = (status) => {
     return undefined;
 };
 const normalizeProtocolV2Hex = (value) => value === null || value === void 0 ? void 0 : value.replace(/^0x/i, '').toLowerCase();
-const versionArrayToNumber = (version) => {
-    if (!version)
-        return undefined;
-    return version[0] * 0x10000 + version[1] * 0x100 + version[2];
-};
-const compareProtocolV2Versions = (current, target) => {
-    const currentNumber = versionArrayToNumber(current);
-    const targetNumber = versionArrayToNumber(target);
-    if (currentNumber === undefined || targetNumber === undefined)
-        return undefined;
-    return currentNumber - targetNumber;
-};
 const bytesToHex = (bytes) => Array.from(bytes)
     .map(byte => byte.toString(16).padStart(2, '0'))
     .join('');
@@ -49005,17 +49244,14 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             platform: payload.platform,
         };
     }
-    getProtocolV2FirmwareChunkSize(direction = 'write') {
+    getProtocolV2FirmwareChunkSize() {
         var _a, _b;
         const payloadChunkSize = Number((_a = this.params) === null || _a === void 0 ? void 0 : _a.chunkSize);
         const env = DataManager.getSettings('env');
         const isBle = ((_b = this.params) === null || _b === void 0 ? void 0 : _b.platform) === 'native' || (env && DataManager.isBleConnect(env));
         let maxChunkSize = hdTransport.PROTOCOL_V2_WEBUSB_FILE_CHUNK_SIZE;
         if (isBle) {
-            maxChunkSize =
-                direction === 'read'
-                    ? hdTransport.PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE
-                    : hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
+            maxChunkSize = hdTransport.PROTOCOL_V2_BLE_FILE_CHUNK_SIZE;
         }
         if (!Number.isFinite(payloadChunkSize) || payloadChunkSize <= 0) {
             return maxChunkSize;
@@ -49029,12 +49265,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     runProtocolV2() {
-        var _a, _b;
+        var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.captureProtocolV2PhysicalIdentity();
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
             const deviceFirmwareType = getFirmwareType(deviceFeatures);
             const firmwareType = (_a = this.params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+            const resourceRecoveryMode = Boolean(this.isProtocolV2BootloaderMode() || this.isProtocolV2RomloaderMode());
             let fwBinaryMap = [];
             let bootloaderBinary = null;
             let installItems;
@@ -49043,22 +49280,29 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
                 fwBinaryMap = this.collectExplicitTargetBinaries();
                 bootloaderBinary = this.prepareBootloaderBinary();
-                if (!this.hasExplicitProtocolV2Payload(fwBinaryMap)) {
+                const needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
+                const needsRemoteResources = !((_b = this.params.resourceBundleFiles) === null || _b === void 0 ? void 0 : _b.length) &&
+                    !!((_c = this.params.targetsToUpdate) === null || _c === void 0 ? void 0 : _c.includes('resource'));
+                if (needsRemoteFirmware || needsRemoteResources) {
+                    yield DataManager.forceReloadData();
+                }
+                if (needsRemoteFirmware) {
                     const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures);
                     bootloaderBinary = remoteBinaries.bootloaderBinary;
                     fwBinaryMap = remoteBinaries.fwBinaryMap;
                     installItems = remoteBinaries.installItems;
                 }
-                resourceBundles = this.prepareProtocolV2ResourceBundles(firmwareType, deviceFeatures);
-                if (resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) {
-                    resourceBundles = yield this.prefetchProtocolV2ResourceBundles(resourceBundles);
-                }
+                resourceBundles = yield this.prepareProtocolV2ResourceBundles(resourceRecoveryMode);
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
             }
             catch (err) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_b = err.message) !== null && _b !== void 0 ? _b : err);
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, (_d = err.message) !== null && _d !== void 0 ? _d : err);
             }
             if (!bootloaderBinary && fwBinaryMap.length === 0 && !(resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length)) {
+                if (resourceBundles !== undefined) {
+                    this.postTipMessage(exports.FirmwareUpdateTipMessage.FirmwareUpdateCompleted);
+                    return this.getProtocolV2VersionResult(deviceFeatures);
+                }
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
             }
             yield this.enterProtocolV2BootloaderMode();
@@ -49166,57 +49410,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
         return target;
     }
-    getProtocolV2ResourceFilePath(path) {
-        if (path.startsWith('vol'))
-            return path;
-        if (path.startsWith('/'))
-            return `vol0:${path}`;
-        return `vol0:/${path}`;
-    }
-    readProtocolV2DeviceFileHeader(path) {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
-            const filePath = this.getProtocolV2ResourceFilePath(path);
-            const pathInfoRes = yield typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
-                path: filePath,
-            });
-            const fileSize = toProtocolV2FiniteNumber((_a = pathInfoRes.message) === null || _a === void 0 ? void 0 : _a.size);
-            if (!((_b = pathInfoRes.message) === null || _b === void 0 ? void 0 : _b.exist) ||
-                ((_c = pathInfoRes.message) === null || _c === void 0 ? void 0 : _c.directory) ||
-                fileSize === undefined ||
-                fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-                return null;
-            }
-            const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
-            const chunks = [];
-            let offset = 0;
-            while (offset < PROTOCOL_V2_OKPP_HEADER_SIZE) {
-                const readLen = Math.min(chunkSize, PROTOCOL_V2_OKPP_HEADER_SIZE - offset);
-                const res = yield typedCall('FilesystemFileRead', 'FilesystemFile', {
-                    file: {
-                        path: filePath,
-                        offset,
-                        total_size: 0,
-                    },
-                    chunk_len: readLen,
-                    ui_percentage: undefined,
-                });
-                const data = toProtocolV2Bytes((_d = res.message) === null || _d === void 0 ? void 0 : _d.data);
-                if (data.byteLength === 0)
-                    return null;
-                chunks.push(data);
-                offset += data.byteLength;
-            }
-            const headerBytes = new Uint8Array(offset);
-            let cursor = 0;
-            chunks.forEach(chunk => {
-                headerBytes.set(chunk, cursor);
-                cursor += chunk.byteLength;
-            });
-            return parseProtocolV2OkppHeader(headerBytes);
-        });
-    }
     downloadRemoteProtocolV2Component(key, component) {
         return __awaiter(this, void 0, void 0, function* () {
             const target = this.getRemoteComponentTarget(key, component);
@@ -49288,103 +49481,71 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             };
         });
     }
-    prepareProtocolV2ResourceBundles(firmwareType, features) {
-        var _a, _b, _c;
-        if ((_a = this.params.resourceBundleFiles) === null || _a === void 0 ? void 0 : _a.length) {
-            return this.params.resourceBundleFiles.map((file, index) => {
-                var _a;
-                const devicePath = validateProtocolV2FilesystemPath(file.devicePath, `resourceBundleFiles[${index}].devicePath`);
-                return {
-                    name: (_a = devicePath.split('/').pop()) !== null && _a !== void 0 ? _a : devicePath,
-                    binary: file.binary,
-                    devicePath,
-                };
+    prepareProtocolV2ResourceBundles(recoveryMode) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if ((_a = this.params.resourceBundleFiles) === null || _a === void 0 ? void 0 : _a.length) {
+                return this.params.resourceBundleFiles.map((file, index) => {
+                    var _a;
+                    const devicePath = validateProtocolV2FilesystemPath(file.devicePath, `resourceBundleFiles[${index}].devicePath`);
+                    return {
+                        name: (_a = devicePath.split('/').pop()) !== null && _a !== void 0 ? _a : devicePath,
+                        binary: file.binary,
+                        devicePath,
+                    };
+                });
+            }
+            if (!((_b = this.params.targetsToUpdate) === null || _b === void 0 ? void 0 : _b.includes('resource'))) {
+                return undefined;
+            }
+            const resources = DataManager.getProtocolV2Resources();
+            if (!(resources === null || resources === void 0 ? void 0 : resources.length)) {
+                throw new Error('Missing Pro2 stable resource configuration');
+            }
+            const inventory = recoveryMode
+                ? undefined
+                : yield requestProtocolV2ResourceInventory({
+                    commands: this.device.getCommands(),
+                    timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+                });
+            const plan = buildProtocolV2ResourceUpdatePlan({
+                resources,
+                inventory,
+                mode: recoveryMode ? 'bootloader-recovery' : 'application',
+                forced: this.params.forcedUpdateRes,
             });
-        }
-        if (!((_b = this.params.targetsToUpdate) === null || _b === void 0 ? void 0 : _b.includes('resource'))) {
-            return undefined;
-        }
-        const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
-        if (!((_c = release === null || release === void 0 ? void 0 : release.resourceBundles) === null || _c === void 0 ? void 0 : _c.length))
-            return undefined;
-        return release.resourceBundles.map((bundle, index) => ({
-            name: bundle.name,
-            binary: new ArrayBuffer(0),
-            devicePath: validateProtocolV2FilesystemPath(bundle.devicePath, `resourceBundles[${index}].devicePath`),
-            url: bundle.url,
-            version: bundle.version,
-            payloadHash: bundle.payloadHash,
-            headerHash: bundle.headerHash,
-        }));
+            Log$5.log(`[FirmwareUpdateV4] Pro2 resource plan mode=${recoveryMode ? 'bootloader-recovery' : 'application'} status=${plan.status} count=${plan.resources.length}`);
+            const bundles = [];
+            for (const resource of plan.resources) {
+                bundles.push(yield this.downloadProtocolV2Resource(resource));
+            }
+            return bundles;
+        });
     }
-    prefetchProtocolV2ResourceBundles(bundles) {
+    downloadProtocolV2Resource(resource) {
         return __awaiter(this, void 0, void 0, function* () {
-            const prefetched = [];
-            for (const bundle of bundles) {
-                let { binary } = bundle;
-                let downloadedFromRemote = false;
-                if (binary.byteLength === 0) {
-                    if (!bundle.url) {
-                        throw new Error(`Missing Protocol V2 RESC bundle binary: ${bundle.name}`);
-                    }
-                    Log$5.log(`[FirmwareUpdateV4] downloading remote RESC bundle ${bundle.name}`);
-                    ({ binary } = yield getSysResourceBinary(bundle.url));
-                    downloadedFromRemote = true;
-                }
-                if (binary.byteLength === 0) {
-                    throw new Error(`Protocol V2 RESC bundle is empty: ${bundle.name}`);
-                }
-                if (downloadedFromRemote) {
-                    const header = parseProtocolV2OkppHeader(toProtocolV2Bytes(binary));
-                    if (!header || header.type !== 'RESC') {
-                        throw new Error(`Invalid Protocol V2 RESC bundle header: ${bundle.name}`);
-                    }
-                    if (bundle.version && compareProtocolV2Versions(header.version, bundle.version) !== 0) {
-                        throw new Error(`Protocol V2 RESC bundle version mismatch: ${bundle.name}`);
-                    }
-                    const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
-                    if (expectedPayloadHash && header.payloadHash !== expectedPayloadHash) {
-                        throw new Error(`Protocol V2 RESC bundle payload hash mismatch: ${bundle.name}`);
-                    }
-                    const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
-                    if (expectedHeaderHash && header.headerHash !== expectedHeaderHash) {
-                        throw new Error(`Protocol V2 RESC bundle header hash mismatch: ${bundle.name}`);
-                    }
-                }
-                prefetched.push(Object.assign(Object.assign({}, bundle), { binary }));
+            Log$5.log(`[FirmwareUpdateV4] downloading Pro2 resource ${resource.type}`);
+            const { binary } = yield getSysResourceBinary(resource.url);
+            if (!isProtocolV2ResourceFileValid(binary, resource)) {
+                throw new Error(`Pro2 resource file verification failed: ${resource.type}`);
             }
-            return prefetched;
+            return {
+                name: `${resource.type}.okpkg`,
+                binary,
+                devicePath: PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
+            };
         });
     }
     syncProtocolV2ResourceBundles(bundles, firmwareSize) {
         return __awaiter(this, void 0, void 0, function* () {
             const transferStartTime = Date.now();
             const transferTransport = this.getProtocolV2FirmwareTransferTransport();
-            const isRemoteMode = bundles.some(bundle => !!bundle.url);
-            let bundlesToSync = bundles;
-            if (isRemoteMode) {
-                const filtered = [];
-                for (const bundle of bundles) {
-                    const upToDate = yield this.isProtocolV2ResourceBundleUpToDate(bundle);
-                    if (upToDate) {
-                        Log$5.log(`[FirmwareUpdateV4] skip RESC bundle ${bundle.name}; already up to date`);
-                    }
-                    else {
-                        filtered.push(bundle);
-                    }
-                }
-                bundlesToSync = filtered;
-            }
-            if (bundlesToSync.length === 0) {
-                Log$5.log('[FirmwareUpdateV4] all RESC bundles up to date, nothing to sync');
-                return { processedSize: 0, totalSize: firmwareSize };
-            }
             let totalSize = 0;
-            for (const b of bundlesToSync)
+            for (const b of bundles)
                 totalSize += b.binary.byteLength;
             const transferTotalSize = totalSize + firmwareSize;
             let processedSize = 0;
-            for (const bundle of bundlesToSync) {
+            for (const bundle of bundles) {
                 Log$5.log(`[FirmwareUpdateV4] syncing RESC bundle ${bundle.name} -> ${bundle.devicePath} bytes=${bundle.binary.byteLength}`);
                 processedSize = yield this.protocolV2CommonUpdateProcess({
                     payload: bundle.binary,
@@ -49398,43 +49559,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return { processedSize, totalSize: transferTotalSize };
         });
     }
-    isProtocolV2ResourceBundleUpToDate(bundle) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.params.forcedUpdateRes)
-                return false;
-            if (!bundle.version && !bundle.payloadHash)
-                return false;
-            try {
-                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath);
-                if (!header)
-                    return false;
-                if (bundle.version) {
-                    const cmp = compareProtocolV2Versions(header.version, bundle.version);
-                    if (cmp === undefined || cmp !== 0)
-                        return false;
-                }
-                if (bundle.payloadHash) {
-                    const expected = normalizeProtocolV2Hex(bundle.payloadHash);
-                    if (expected && header.payloadHash !== expected)
-                        return false;
-                }
-                if (bundle.headerHash) {
-                    const expected = normalizeProtocolV2Hex(bundle.headerHash);
-                    if (expected && header.headerHash !== expected)
-                        return false;
-                }
-                return true;
-            }
-            catch (error) {
-                Log$5.log(`[FirmwareUpdateV4] RESC bundle ${bundle.name} header check failed: `, error);
-                return false;
-            }
-        });
-    }
     isProtocolV2BootloaderMode() {
         var _a, _b, _c;
         if (typeof this.device.isBootloader === 'function') {
-            return this.device.isBootloader();
+            return !!this.device.isBootloader();
         }
         return (((_a = this.device.features) === null || _a === void 0 ? void 0 : _a.mode) === 'bootloader' ||
             (((_b = this.device.features) === null || _b === void 0 ? void 0 : _b.mode) == null && !!((_c = this.device.features) === null || _c === void 0 ? void 0 : _c.bootloaderMode)));
@@ -49719,19 +49847,22 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     waitForProtocolV2FinalFeatures() {
         return __awaiter(this, void 0, void 0, function* () {
             const features = yield this.waitForProtocolV2ReconnectAndFeatures(PROTOCOL_V2_FINAL_RECONNECT_TIMEOUT);
-            const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
-            const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
-            const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
-            if (firmwareVersion === '0.0.0') {
-                Log$5.warn('Protocol V2 firmware update finished but app firmware version is still 0.0.0. This is allowed for Pro2 debug BLE-only update flows.');
-            }
-            return {
-                bootloaderVersion,
-                bleVersion,
-                firmwareVersion,
-            };
+            return this.getProtocolV2VersionResult(features);
         });
     }
+    getProtocolV2VersionResult(features) {
+        const bootloaderVersion = getDeviceBootloaderVersion(features).join('.');
+        const bleVersion = getDeviceBLEFirmwareVersion(features).join('.');
+        const firmwareVersion = getDeviceFirmwareVersion(features).join('.');
+        if (firmwareVersion === '0.0.0') {
+            Log$5.warn('Protocol V2 firmware update finished but app firmware version is still 0.0.0. This is allowed for Pro2 debug BLE-only update flows.');
+        }
+        return {
+            bootloaderVersion,
+            bleVersion,
+            firmwareVersion,
+        };
+    }
     waitForProtocolV2ReconnectAndFeatures(timeout) {
         return __awaiter(this, void 0, void 0, function* () {
             const startTime = Date.now();