@onekeyfe/hd-core 1.2.0-alpha.96 → 1.2.0-alpha.97

package/dist/index.js

@@ -522,10 +522,6 @@ const PROTOCOL_V2_TARGETS = {
     SE03: 'se03',
     SE04: 'se04',
 };
-const PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS = new Set([
-    ...Object.values(PROTOCOL_V2_TARGETS),
-    'resource',
-]);
 const asRecord = (value) => value && typeof value === 'object' && !Array.isArray(value)
     ? value
     : undefined;
@@ -613,18 +609,6 @@ const validateFirmwareUpdatePlanForceTargets = (value) => {
     }
     return [...value];
 };
-const validateProtocolV2FirmwareUpdateTargets = (value) => {
-    if (value === undefined) {
-        return [];
-    }
-    if (!Array.isArray(value) ||
-        value.length > PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.size ||
-        value.some(target => !PROTOCOL_V2_FIRMWARE_UPDATE_TARGETS.has(target)) ||
-        new Set(value).size !== value.length) {
-        return planError('Protocol V2 firmware update targets are invalid');
-    }
-    return [...value];
-};
 const assertExactKeys = (value, required, optional = []) => {
     const allowed = new Set([...required, ...optional]);
     if (required.some(key => !Object.prototype.hasOwnProperty.call(value, key)) ||
@@ -754,7 +738,7 @@ const assertFirmwareUpdatePlan = (value) => {
             plan.targetsToUpdate.some(target => legacyOnlyTargets.has(target))) ||
         (plan.artifacts.length > 0 &&
             (plan.platform === 'native' || plan.platform === 'desktop') &&
-            plan.executor === 'v3' &&
+            plan.executor !== 'v2' &&
             plan.deviceIdentity === 'unavailable')) {
         return planError('Firmware update plan executor contract is invalid');
     }
@@ -789,7 +773,7 @@ const selectResourceUrl = ({ release, features, platform, }) => {
 };
 const getExecutor = (features) => {
     const deviceType = getDeviceType(features);
-    if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) {
+    if (deviceType === hdShared.EDeviceType.Pro2) {
         return 'v4';
     }
     if (deviceType === hdShared.EDeviceType.Pro &&
@@ -798,7 +782,7 @@ const getExecutor = (features) => {
     }
     return 'v2';
 };
-const buildProtocolV2Artifacts = (release, { includeComponents = true, componentTargets: selectedComponentTargets, } = {}) => {
+const buildProtocolV2Artifacts = (release, { includeComponents = true, includeResources = true, } = {}) => {
     var _a;
     const components = asRecord(release.components);
     if (includeComponents && !components) {
@@ -810,42 +794,49 @@ const buildProtocolV2Artifacts = (release, { includeComponents = true, component
     const componentKeys = includeComponents && components
         ? [...installOrder, ...Object.keys(components).filter(key => !installOrder.includes(key))]
         : [];
-    const selectedComponentKeys = selectedComponentTargets
-        ? componentKeys.filter(key => {
-            var _a;
-            const component = asRecord(components === null || components === void 0 ? void 0 : components[key]);
-            const targetName = (_a = asString(component === null || component === void 0 ? void 0 : component.target)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-            const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
-            return !!target && selectedComponentTargets.has(target);
-        })
-        : componentKeys;
     const artifacts = [];
     const targets = [];
-    const componentTargetSet = new Set();
-    for (const key of selectedComponentKeys) {
+    const componentTargets = new Set();
+    for (const key of componentKeys) {
         const component = asRecord(components === null || components === void 0 ? void 0 : components[key]);
         const targetName = (_a = asString(component === null || component === void 0 ? void 0 : component.target)) === null || _a === void 0 ? void 0 : _a.toUpperCase();
-        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
         if (targetName === 'ROMLOADER') {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 ROMLOADER requires its dedicated loader flow', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
+        const target = targetName ? PROTOCOL_V2_TARGETS[targetName] : undefined;
         if (!component || !target) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} has an unsupported target`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
-        if (componentTargetSet.has(target)) {
+        if (componentTargets.has(target)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} duplicates target ${target}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
-        componentTargetSet.add(target);
-        const integrity = asIntegrity({
+        componentTargets.add(target);
+        artifacts.push(Object.assign(Object.assign({ artifactId: `component:${target}`, role: 'component', target, url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`), container: 'raw', logicalName: key }, asIntegrity({
             size: component.expectedSize,
             sha256: component.fingerprint,
-        });
-        if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
-            planError(`Protocol V2 component ${key} integrity metadata is invalid`);
-        }
-        artifacts.push(Object.assign(Object.assign({ artifactId: `component:${target}`, role: 'component', target, url: assertArtifactUrl(component.url, `Protocol V2 component ${key}`), container: 'raw', logicalName: key }, integrity), (asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {})));
+        })), (asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {})));
         targets.push(target);
     }
+    const bundles = includeResources && Array.isArray(release.resourceBundles) ? release.resourceBundles : [];
+    const resourceBundleNames = new Set();
+    for (const value of bundles) {
+        const bundle = asRecord(value);
+        const name = asString(bundle === null || bundle === void 0 ? void 0 : bundle.name);
+        if (!bundle || !name) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource bundle is invalid', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
+        }
+        if (resourceBundleNames.has(name)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource bundle duplicates name ${name}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
+        }
+        resourceBundleNames.add(name);
+        artifacts.push(Object.assign({ artifactId: `resourceBundle:${name}`, role: 'resourceBundle', target: 'resource', url: assertArtifactUrl(bundle.url, `Protocol V2 resource bundle ${name}`), container: 'raw', logicalName: name }, asIntegrity({
+            size: bundle.expectedSize,
+            sha256: bundle.fingerprint,
+        })));
+    }
+    if (bundles.length > 0) {
+        targets.push('resource');
+    }
     return { artifacts, targets: [...new Set(targets)] };
 };
 const isForcedTargetRepresented = ({ executor, forcedTarget, artifacts, targetsToUpdate, }) => {
@@ -874,95 +865,6 @@ const assertForcedTargetsRepresented = ({ executor, forcedTargets, artifacts, ta
         }
     }
 };
-const finalizeFirmwareUpdatePlan = ({ features, firmwareType, platform, artifacts, targetsToUpdate, }) => {
-    const executor = getExecutor(features);
-    const bootloaderMode = resolveDeviceBootloaderMode(features);
-    const reportedIdentity = getDeviceUUID(features);
-    const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
-    const allowsUnavailableIdentity = (bootloaderMode && executor === 'v2') || executor === 'v4';
-    if (artifacts.length > 0 &&
-        (platform === 'native' || platform === 'desktop') &&
-        !deviceIdentity &&
-        !allowsUnavailableIdentity) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware update requires a stable device identity', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-    }
-    const planWithoutDigest = {
-        schemaVersion: 2,
-        executor,
-        deviceIdentity: deviceIdentity || 'unavailable',
-        deviceModel: String(getDeviceType(features)),
-        firmwareType,
-        platform,
-        artifacts,
-        targetsToUpdate,
-    };
-    return assertFirmwareUpdatePlan(Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) }));
-};
-const buildProtocolV2LocalFirmwareUpdatePlan = ({ features, firmwareType, platform, artifacts, }) => {
-    if (artifacts.length === 0) {
-        return planError('Protocol V2 local firmware plan has no artifacts');
-    }
-    const plan = finalizeFirmwareUpdatePlan({
-        features,
-        firmwareType,
-        platform,
-        artifacts: artifacts.map(artifact => (Object.assign(Object.assign({}, artifact), { role: artifact.target === 'resource' ? 'resourceBundle' : 'component', url: `https://local-firmware.invalid/${encodeURIComponent(artifact.artifactId)}` }))),
-        targetsToUpdate: artifacts.map(artifact => artifact.target),
-    });
-    if (plan.executor !== 'v4') {
-        return planError('Protocol V2 local firmware plan requires executor v4');
-    }
-    return plan;
-};
-const buildProtocolV2FirmwareUpdatePlan = ({ features, firmwareType, platform, release, targetsToUpdate, forceUpdateTargets, resourceArchive, }) => {
-    const validatedForceTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
-    if (validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
-        planError('Protocol V2 does not support forced BLE or legacy bootloader targets');
-    }
-    const requestedComponentTargets = new Set(targetsToUpdate.filter(target => target !== 'resource'));
-    if (getDeviceType(features) === hdShared.EDeviceType.Neo &&
-        (requestedComponentTargets.has('se03') || requestedComponentTargets.has('se04'))) {
-        planError('Neo does not support Protocol V2 targets se03 or se04');
-    }
-    const protocolV2 = buildProtocolV2Artifacts(release !== null && release !== void 0 ? release : {}, {
-        includeComponents: requestedComponentTargets.size > 0,
-        componentTargets: requestedComponentTargets,
-    });
-    const resourceRequested = targetsToUpdate.includes('resource');
-    if (resourceRequested) {
-        const archive = resourceArchive;
-        if (!archive) {
-            return planError('Protocol V2 resource target has no resource archive');
-        }
-        const integrity = asIntegrity({
-            size: archive.archiveSize,
-            sha256: archive.archiveSha256,
-        });
-        if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
-            planError('Protocol V2 resource archive integrity metadata is invalid');
-        }
-        protocolV2.artifacts.push(Object.assign({ artifactId: 'resource:archive', role: 'resourceBundle', target: 'resource', url: assertArtifactUrl(archive.archiveUrl, 'Protocol V2 resource archive'), container: 'zip', logicalName: 'protocol-v2-resource-archive' }, integrity));
-        protocolV2.targets.push('resource');
-    }
-    const representedTargets = new Set(protocolV2.targets);
-    const missingTarget = Array.from(requestedComponentTargets).find(target => !representedTargets.has(target));
-    if (missingTarget) {
-        planError(`Protocol V2 release does not contain requested target ${missingTarget}`);
-    }
-    if (validatedForceTargets.includes('firmware') && protocolV2.targets.length === 0) {
-        planError('Forced firmware update target firmware is not represented by the plan');
-    }
-    if (validatedForceTargets.includes('resource') && !resourceArchive) {
-        planError('Forced firmware update target resource has no Protocol V2 resource archive');
-    }
-    return finalizeFirmwareUpdatePlan({
-        features,
-        firmwareType,
-        platform,
-        artifacts: protocolV2.artifacts,
-        targetsToUpdate: protocolV2.targets,
-    });
-};
 const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, ble, bootloader, forceUpdateTargets, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const executor = getExecutor(features);
@@ -984,6 +886,7 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
     if (executor === 'v4' && (shouldUpdateFirmware || shouldUpdateResource)) {
         const protocolV2 = buildProtocolV2Artifacts(firmwareRelease !== null && firmwareRelease !== void 0 ? firmwareRelease : {}, {
             includeComponents: shouldUpdateFirmware,
+            includeResources: shouldUpdateResource,
         });
         artifacts = protocolV2.artifacts;
         targetsToUpdate = protocolV2.targets;
@@ -1048,13 +951,25 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
         artifacts,
         targetsToUpdate,
     });
-    return finalizeFirmwareUpdatePlan({
-        features,
+    const reportedIdentity = getDeviceUUID(features);
+    const deviceIdentity = reportedIdentity === 'unavailable' ? '' : reportedIdentity;
+    if (artifacts.length > 0 &&
+        (platform === 'native' || platform === 'desktop') &&
+        !deviceIdentity &&
+        !(bootloaderMode && executor === 'v2')) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware update requires a stable device identity', { firmwareUpdateCode: 'FirmwarePlanInvalid' });
+    }
+    const planWithoutDigest = {
+        schemaVersion: 2,
+        executor,
+        deviceIdentity: deviceIdentity || 'unavailable',
+        deviceModel: String(getDeviceType(features)),
         firmwareType,
         platform,
         artifacts,
         targetsToUpdate,
-    });
+    };
+    return assertFirmwareUpdatePlan(Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) }));
 };
 
 const preparedPlanError = (message) => {
@@ -1175,7 +1090,7 @@ const prepareFirmwareUpdatePlan = ({ plan: value, leaseRef, artifacts, }) => {
     return Object.assign(Object.assign({}, planWithoutDigest), { preparedPlanDigest: digestPreparedPlan(planWithoutDigest) });
 };
 const validateFirmwareUpdatePreparedPlan = (value) => {
-    var _a, _b, _c, _d;
+    var _a, _b, _c;
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return preparedPlanError('Firmware prepared plan must be an object');
     }
@@ -1255,13 +1170,7 @@ const validateFirmwareUpdatePreparedPlan = (value) => {
         artifactIds.add(artifact.artifactId);
         artifactTargets.add(artifact.target);
         assertFirmwareArtifactReference(artifact.artifact);
-        const materializedEntryNames = (_d = (_c = artifact.materializedEntries) === null || _c === void 0 ? void 0 : _c.map(entry => {
-            assertPreparedEntry(entry);
-            return getFirmwareUpdateResourceName(entry.entryName).toLowerCase();
-        })) !== null && _d !== void 0 ? _d : [];
-        if (new Set(materializedEntryNames).size !== materializedEntryNames.length) {
-            return preparedPlanError('Firmware prepared plan contains duplicate entry names');
-        }
+        (_c = artifact.materializedEntries) === null || _c === void 0 ? void 0 : _c.forEach(assertPreparedEntry);
     }
     if (preparedPlan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||
         new Set(preparedPlan.targetsToUpdate).size !== preparedPlan.targetsToUpdate.length ||
@@ -1295,7 +1204,7 @@ const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({ preparedPlan: value, d
         }
         const pinnedIdentity = degradedPlanIdentityPins.get(preparedPlan.leaseRef);
         if (!deviceIdentity) {
-            if (preparedPlan.executor !== 'v4' && bootloaderMode !== true) {
+            if (bootloaderMode !== true) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
             }
             return preparedPlan;
@@ -1368,8 +1277,6 @@ class FirmwareHostBindingRegistry {
     register(binding) {
         var _a;
         if (!binding ||
-            typeof binding.preparedPlanDigest !== 'string' ||
-            !/^[0-9a-f]{64}$/i.test(binding.preparedPlanDigest) ||
             typeof ((_a = binding.artifactReader) === null || _a === void 0 ? void 0 : _a.open) !== 'function' ||
             typeof binding.artifactReader.read !== 'function' ||
             typeof binding.artifactReader.close !== 'function') {
@@ -1390,7 +1297,7 @@ class FirmwareHostBindingRegistry {
     getGeneration() {
         return this.generation;
     }
-    resolve(generation, preparedPlanDigest) {
+    resolve(generation) {
         if (!Number.isSafeInteger(generation) ||
             generation <= 0 ||
             generation !== this.generation ||
@@ -1398,17 +1305,12 @@ class FirmwareHostBindingRegistry {
             return bindingError(`Firmware host binding generation ${generation} is stale`);
         }
         const { binding } = this;
-        if (preparedPlanDigest !== undefined &&
-            binding.preparedPlanDigest.toLowerCase() !== preparedPlanDigest.toLowerCase()) {
-            return bindingError(`Firmware host binding generation ${generation} does not match the prepared plan`);
-        }
         const assertCurrent = () => {
             if (generation !== this.generation || binding !== this.binding) {
                 bindingError(`Firmware host binding generation ${generation} is stale`);
             }
         };
         return {
-            preparedPlanDigest: binding.preparedPlanDigest,
             artifactReader: {
                 open: (input) => __awaiter(this, void 0, void 0, function* () {
                     assertCurrent();
@@ -1441,7 +1343,7 @@ const firmwareHostBindingRegistry = new FirmwareHostBindingRegistry();
 const registerFirmwareUpdateHostBinding = (binding) => firmwareHostBindingRegistry.register(binding);
 const unregisterFirmwareUpdateHostBinding = (generation) => firmwareHostBindingRegistry.unregister(generation);
 const getFirmwareUpdateHostBindingGeneration = () => firmwareHostBindingRegistry.getGeneration();
-const resolveFirmwareUpdateHostBinding = (generation, preparedPlanDigest) => firmwareHostBindingRegistry.resolve(generation !== null && generation !== void 0 ? generation : Number.NaN, preparedPlanDigest);
+const resolveFirmwareUpdateHostBinding = (generation) => firmwareHostBindingRegistry.resolve(generation !== null && generation !== void 0 ? generation : Number.NaN);
 
 const callbackManager = new Map();
 const generateCallbackId = () => `callback_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
@@ -40602,8 +40504,143 @@ const findLatestRelease = (releases) => {
     return leastRelease;
 };
 
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1 = 'vol0:/loaders/bootloader/boot_resource.okpkg';
+const PROTOCOL_V2_RESOURCE_TYPES = [
+    'images',
+    'animation',
+    'wallpaper',
+    'translations',
+    'roobert',
+    'noto',
+    'firmware_logo',
+];
+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',
+    firmware_logo: 'vol0:/bundles/firmware_logo.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_OKPP_HEADER_SIZE$1 = 0x52a0;
+const PROTOCOL_V2_OKPP_TYPE_OFFSET = 0x08;
+const PROTOCOL_V2_OKPP_HEADER_LENGTH_OFFSET = 0x0c;
+const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET$1 = 0x240;
+const PROTOCOL_V2_OKPP_HASH_SIZE$1 = 64;
+const PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE = PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET$1 + PROTOCOL_V2_OKPP_HASH_SIZE$1;
+const PROTOCOL_V2_MIN_FILE_READ_CHUNK_SIZE = 64;
+const PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS = 5 * 1000;
+function toFiniteNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string') {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : undefined;
+    }
+    if (value && typeof value === 'object') {
+        const longLike = value;
+        if (typeof longLike.toNumber === 'function') {
+            const numeric = longLike.toNumber();
+            return Number.isFinite(numeric) ? numeric : undefined;
+        }
+    }
+    return undefined;
+}
+function toUint8Array(value) {
+    if (value instanceof Uint8Array)
+        return value;
+    if (value instanceof ArrayBuffer)
+        return new Uint8Array(value);
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    if (typeof value === 'string') {
+        const hex = value.replace(/^0x/i, '');
+        if (!hex || hex.length % 2 !== 0 || /[^0-9a-f]/i.test(hex)) {
+            return new Uint8Array(0);
+        }
+        const bytes = new Uint8Array(hex.length / 2);
+        for (let index = 0; index < bytes.length; index += 1) {
+            bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
+        }
+        return bytes;
+    }
+    return new Uint8Array(0);
+}
+function readAscii(bytes, offset, length) {
+    return Array.from(bytes.slice(offset, offset + length), byte => String.fromCharCode(byte)).join('');
+}
+function parseProtocolV2ResourceHeaderHash(bytes) {
+    if (bytes.byteLength < PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE)
+        return undefined;
+    if (readAscii(bytes, 0, 4) !== 'OKPP')
+        return undefined;
+    if (readAscii(bytes, PROTOCOL_V2_OKPP_TYPE_OFFSET, 4) !== 'RESC')
+        return undefined;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    if (view.getUint32(PROTOCOL_V2_OKPP_HEADER_LENGTH_OFFSET, true) !== PROTOCOL_V2_OKPP_HEADER_SIZE$1) {
+        return undefined;
+    }
+    return bytesToHex$3(bytes.slice(PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET$1, PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET$1 + PROTOCOL_V2_OKPP_HASH_SIZE$1));
+}
+function readProtocolV2ResourceIdentity({ commands, resource, chunkSize, timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS, }) {
+    var _a, _b, _c, _d;
+    return __awaiter(this, void 0, void 0, function* () {
+        const path = PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type];
+        const pathInfo = yield commands.typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', { path }, { timeoutMs });
+        const size = toFiniteNumber((_a = pathInfo.message) === null || _a === void 0 ? void 0 : _a.size);
+        if (!((_b = pathInfo.message) === null || _b === void 0 ? void 0 : _b.exist) ||
+            ((_c = pathInfo.message) === null || _c === void 0 ? void 0 : _c.directory) ||
+            !Number.isSafeInteger(size) ||
+            size !== resource.size ||
+            size < PROTOCOL_V2_OKPP_HEADER_SIZE$1) {
+            return undefined;
+        }
+        const header = new Uint8Array(PROTOCOL_V2_RESOURCE_IDENTITY_READ_SIZE);
+        let offset = 0;
+        while (offset < header.byteLength) {
+            const readLength = Math.min(chunkSize, header.byteLength - offset);
+            const response = yield commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
+                file: { path, offset, total_size: 0 },
+                chunk_len: readLength,
+            }, { timeoutMs });
+            const data = toUint8Array((_d = response.message) === null || _d === void 0 ? void 0 : _d.data);
+            if (data.byteLength === 0)
+                return undefined;
+            const copied = Math.min(data.byteLength, header.byteLength - offset);
+            header.set(data.subarray(0, copied), offset);
+            offset += copied;
+        }
+        const headerHash = parseProtocolV2ResourceHeaderHash(header);
+        return headerHash ? { type: resource.type, size, headerHash } : undefined;
+    });
+}
+function readProtocolV2ResourceInventory({ commands, resources, chunkSize = hdTransport.PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE, timeoutMs = PROTOCOL_V2_RESOURCE_INVENTORY_TIMEOUT_MS, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const normalizedChunkSize = Number.isFinite(chunkSize)
+            ? Math.max(Math.floor(chunkSize), PROTOCOL_V2_MIN_FILE_READ_CHUNK_SIZE)
+            : hdTransport.PROTOCOL_V2_BLE_FILE_READ_CHUNK_SIZE;
+        const inventory = [];
+        for (const resource of resources) {
+            try {
+                const item = yield readProtocolV2ResourceIdentity({
+                    commands,
+                    resource,
+                    chunkSize: normalizedChunkSize,
+                    timeoutMs,
+                });
+                if (item)
+                    inventory.push(item);
+            }
+            catch (_a) {
+            }
+        }
+        return inventory;
+    });
+}
 function normalizeHex$1(value, expectedLength, field) {
     if (typeof value !== 'string') {
         throw new Error(`Invalid Pro2 resource ${field}: expected a hexadecimal string`);
@@ -40614,158 +40651,132 @@ function normalizeHex$1(value, expectedLength, field) {
     }
     return normalized;
 }
-function parseProtocolV2Resources(value) {
-    if (value === undefined)
-        return undefined;
+function validateResource(value, index) {
     if (!value || typeof value !== 'object') {
-        throw new Error('Invalid Pro2 resources config');
-    }
-    const { source } = value;
-    if (!source || typeof source !== 'object') {
-        throw new Error('Invalid Pro2 resources config: source is required');
+        throw new Error(`Invalid Pro2 resource at stable[${index}]`);
     }
-    const { archiveUrl, archiveSha256, archiveSize } = source;
-    if (typeof archiveUrl !== 'string' || !archiveUrl.startsWith('https://')) {
-        throw new Error('Invalid Pro2 resources config: source.archiveUrl must use HTTPS');
+    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 archiveSha256 !== 'string' || !/^[0-9a-fA-F]{64}$/.test(archiveSha256)) {
-        throw new Error('Invalid Pro2 resources config: source.archiveSha256 must be a SHA-256 digest');
+    if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
+        throw new Error(`Invalid Pro2 resource url at stable[${index}]`);
     }
-    if (!Number.isSafeInteger(archiveSize) || archiveSize <= 0) {
-        throw new Error('Invalid Pro2 resources config: source.archiveSize must be a positive integer');
+    if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
+        throw new Error(`Invalid Pro2 resource size at stable[${index}]`);
     }
     return {
-        source: {
-            archiveUrl,
-            archiveSha256: archiveSha256.toLowerCase(),
-            archiveSize: archiveSize,
-        },
+        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'),
     };
 }
-const PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS = [
-    'vol0:/bundles/',
-    'vol0:/loaders/rom/',
-];
-function isAllowedManifestDevicePath(path) {
-    if (!path.endsWith('.okpkg') ||
-        path.includes('\\') ||
-        path.includes('//') ||
-        path.split('/').some(part => part === '.' || part === '..')) {
-        return false;
+function validateBootResources(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error('Invalid Pro2 boot resources config');
     }
-    if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1) {
-        return true;
+    const resource = value;
+    if (resource.required !== false) {
+        throw new Error('Invalid Pro2 boot resources required flag: expected false');
     }
-    return PROTOCOL_V2_RESOURCE_MANIFEST_DEVICE_ROOTS.some(root => path.startsWith(root));
-}
-function assertManifestString(value, field) {
-    if (typeof value !== 'string' || value.length === 0) {
-        throw new Error(`Invalid Pro2 resource manifest ${field}`);
+    if (resource.target !== 'RES') {
+        throw new Error('Invalid Pro2 boot resources target: expected RES');
     }
-    return value;
-}
-function assertManifestRelativePath(value, field) {
-    const path = assertManifestString(value, field);
-    if (path.startsWith('/') ||
-        path.includes('\\') ||
-        path.includes(':') ||
-        path.split('/').some(part => !part || part === '.' || part === '..')) {
-        throw new Error(`Invalid Pro2 resource manifest ${field}`);
-    }
-    return path;
-}
-function parseProtocolV2ResourceManifestFile(value, index) {
-    var _a;
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}]`);
+    if (resource.manifestUrl !== undefined &&
+        (typeof resource.manifestUrl !== 'string' || !resource.manifestUrl.startsWith('https://'))) {
+        throw new Error('Invalid Pro2 boot resources manifestUrl');
     }
-    const file = value;
-    const archivePath = assertManifestRelativePath(file.archive_path, `files[${index}].archive_path`);
-    const originalName = assertManifestRelativePath(file.original_name, `files[${index}].original_name`);
-    if (originalName.includes('/')) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].original_name`);
+    if (!Array.isArray(resource.files) || resource.files.length === 0) {
+        throw new Error('Invalid Pro2 boot resources files');
     }
-    const devicePath = assertManifestString(file.device_path, `files[${index}].device_path`);
-    if (!isAllowedManifestDevicePath(devicePath)) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].device_path`);
+    const files = resource.files.map((value, index) => {
+        if (!value || typeof value !== 'object') {
+            throw new Error(`Invalid Pro2 boot resource file at files[${index}]`);
+        }
+        const file = value;
+        if (typeof file.url !== 'string' || !file.url.startsWith('https://')) {
+            throw new Error(`Invalid Pro2 boot resource url at files[${index}]`);
+        }
+        if (typeof file.devicePath !== 'string' ||
+            !file.devicePath.startsWith('vol0:/') ||
+            file.devicePath.includes('..') ||
+            file.devicePath.includes('\\')) {
+            throw new Error(`Invalid Pro2 boot resource devicePath at files[${index}]`);
+        }
+        if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
+            throw new Error(`Invalid Pro2 boot resource size at files[${index}]`);
+        }
+        return Object.assign(Object.assign({}, (typeof file.name === 'string' && file.name ? { name: file.name } : undefined)), { url: file.url, devicePath: file.devicePath, size: Number(file.size), fileHash: normalizeHex$1(file.fileHash, SHA256_HEX_LENGTH, `boot files[${index}].fileHash`) });
+    });
+    if (new Set(files.map(file => file.devicePath)).size !== files.length) {
+        throw new Error('Invalid Pro2 boot resources files: duplicate devicePath');
     }
-    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].size`);
+    return Object.assign(Object.assign({ required: false, target: 'RES' }, (resource.manifestUrl ? { manifestUrl: resource.manifestUrl } : undefined)), { files });
+}
+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 digest = normalizeHex$1(file.sha256, SHA256_HEX_LENGTH, `files[${index}].sha256`);
-    if (file.signed !== true) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].signed`);
+    const config = value;
+    const stable = config.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 ${PROTOCOL_V2_RESOURCE_TYPES.length} unique resource types`);
     }
-    if (file.sig_algo !== 'ed25519' && file.sig_algo !== 'mldsa65') {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].sig_algo`);
+    for (const type of PROTOCOL_V2_RESOURCE_TYPES) {
+        if (!types.has(type)) {
+            throw new Error(`Invalid Pro2 resources config: stable is missing ${type}`);
+        }
     }
-    if (file.payload_version !== null && typeof file.payload_version !== 'string') {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}].payload_version`);
+    const boot = config.boot === undefined ? undefined : validateBootResources(config.boot);
+    return Object.assign({ 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;
+        }) }, (boot ? { boot } : undefined));
+}
+function buildProtocolV2ResourceUpdatePlan({ resources, inventory, mode, forced = false, }) {
+    if (forced) {
+        return {
+            status: resources.length > 0 ? 'outdated' : 'valid',
+            resources: [...resources],
+        };
     }
-    if (!archivePath.endsWith('.okpkg') || !originalName.endsWith('.okpkg')) {
-        throw new Error(`Invalid Pro2 resource manifest files[${index}] package extension`);
+    if (!inventory) {
+        return mode === 'bootloader-recovery'
+            ? {
+                status: resources.length > 0 ? 'outdated' : 'valid',
+                resources: [...resources],
+            }
+            : { 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 {
-        archive_path: archivePath,
-        original_name: originalName,
-        device_path: devicePath,
-        size: Number(file.size),
-        sha256: digest,
-        signed: true,
-        sig_algo: file.sig_algo,
-        payload_version: (_a = file.payload_version) !== null && _a !== void 0 ? _a : null,
+        status: changedResources.length === 0 ? 'valid' : 'outdated',
+        resources: changedResources,
     };
 }
-function parseProtocolV2ResourceManifest(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new Error('Invalid Pro2 resource manifest');
-    }
-    const manifest = value;
-    if (manifest.schema !== 1 ||
-        manifest.variant !== 'resource' ||
-        manifest.device_root !== 'vol0:' ||
-        manifest.restore_mode !== 'bootloader_update' ||
-        !Array.isArray(manifest.trees) ||
-        !Array.isArray(manifest.files)) {
-        throw new Error('Invalid Pro2 resource manifest contract');
-    }
-    const files = manifest.files.map(parseProtocolV2ResourceManifestFile);
-    const devicePaths = new Set(files.map(file => file.device_path));
-    const archivePaths = new Set(files.map(file => file.archive_path));
-    if (files.length === 0 ||
-        devicePaths.size !== files.length ||
-        archivePaths.size !== files.length ||
-        !devicePaths.has(PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1) ||
-        !files.some(file => file.device_path.startsWith('vol0:/bundles/'))) {
-        throw new Error('Invalid Pro2 resource manifest file set');
-    }
-    return {
-        schema: 1,
-        artifact_name: assertManifestString(manifest.artifact_name, 'artifact_name'),
-        release_name: assertManifestString(manifest.release_name, 'release_name'),
-        variant: 'resource',
-        commit: assertManifestString(manifest.commit, 'commit'),
-        short_sha: assertManifestString(manifest.short_sha, 'short_sha'),
-        timestamp_utc: assertManifestString(manifest.timestamp_utc, 'timestamp_utc'),
-        core_version: assertManifestString(manifest.core_version, 'core_version'),
-        key_set: assertManifestString(manifest.key_set, 'key_set'),
-        device_root: 'vol0:',
-        restore_mode: 'bootloader_update',
-        trees: manifest.trees.map((tree, index) => {
-            if (!tree || typeof tree !== 'object') {
-                throw new Error(`Invalid Pro2 resource manifest trees[${index}]`);
-            }
-            const item = tree;
-            return {
-                path: assertManifestRelativePath(item.path, `trees[${index}].path`),
-                device: assertManifestString(item.device, `trees[${index}].device`),
-            };
-        }),
-        files,
-    };
+function bytesToHex$3(bytes) {
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
 }
-function selectProtocolV2ResourceManifestFiles({ manifest, targetsToUpdate, }) {
-    return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
+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;
@@ -40826,7 +40837,6 @@ class DataManager {
         return __awaiter(this, void 0, void 0, function* () {
             this.settings = settings;
             this.protocolV2ResourcesConfigError = undefined;
-            this.protocolV2NeoResourcesConfigError = undefined;
             const manifestMode = (_b = settings.firmwareManifestMode) !== null && _b !== void 0 ? _b : (settings.fetchConfig ? 'sdk-managed' : undefined);
             if (settings.preloadedConfig) {
                 this.applyRemoteConfig(settings.preloadedConfig);
@@ -40887,19 +40897,12 @@ class DataManager {
         let neoResources;
         try {
             pro2Resources = parseProtocolV2Resources((_b = data.pro2) === null || _b === void 0 ? void 0 : _b.resources);
-        }
-        catch (error) {
-            this.protocolV2ResourcesConfigError =
-                error instanceof Error ? error : new Error(String(error));
-            Log$k.warn('[DataConfig] Ignoring invalid Pro2 resources config:', error);
-        }
-        try {
             neoResources = parseProtocolV2Resources((_c = data.neo) === null || _c === void 0 ? void 0 : _c.resources);
         }
         catch (error) {
-            this.protocolV2NeoResourcesConfigError =
+            this.protocolV2ResourcesConfigError =
                 error instanceof Error ? error : new Error(String(error));
-            Log$k.warn('[DataConfig] Ignoring invalid Neo resources config:', error);
+            Log$k.warn('[DataConfig] Ignoring invalid Protocol V2 resources config:', error);
         }
         const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
         const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
@@ -40937,20 +40940,16 @@ class DataManager {
             }
         });
     }
-    static forceReloadData({ requireResources = false, resourceDeviceType = hdShared.EDeviceType.Pro2, } = {}) {
+    static forceReloadData({ requireResources = false, } = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const resourceDeviceName = resourceDeviceType === hdShared.EDeviceType.Pro2 ? 'Pro2' : 'Neo';
             if (!this.settings) {
                 throw new Error('Remote config settings are not initialized');
             }
             const hasFreshConfig = this.lastCheckTimestamp > 0 &&
                 getTimeStamp() - this.lastCheckTimestamp <= FIRMWARE_UPDATE_CONFIG_FRESHNESS_MS;
             if (hasFreshConfig) {
-                const resourcesConfigError = resourceDeviceType === hdShared.EDeviceType.Pro2
-                    ? this.protocolV2ResourcesConfigError
-                    : this.protocolV2NeoResourcesConfigError;
-                if (requireResources && resourcesConfigError) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`);
+                if (requireResources && this.protocolV2ResourcesConfigError) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`);
                 }
                 return;
             }
@@ -40958,18 +40957,19 @@ class DataManager {
             if (!loaded) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Unable to refresh the latest remote config');
             }
-            const resourcesConfigError = resourceDeviceType === hdShared.EDeviceType.Pro2
-                ? this.protocolV2ResourcesConfigError
-                : this.protocolV2NeoResourcesConfigError;
-            if (requireResources && resourcesConfigError) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Invalid ${resourceDeviceName} resources config: ${resourcesConfigError.message}`);
+            if (requireResources && this.protocolV2ResourcesConfigError) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`);
             }
             this.lastCheckTimestamp = getTimeStamp();
         });
     }
-    static getProtocolV2ResourceSource(deviceType = hdShared.EDeviceType.Pro2) {
+    static getProtocolV2Resources(deviceType = hdShared.EDeviceType.Pro2) {
+        var _b, _c;
+        return (_c = (_b = this.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.resources) === null || _c === void 0 ? void 0 : _c.stable;
+    }
+    static getProtocolV2BootResources(deviceType = hdShared.EDeviceType.Pro2) {
         var _b, _c;
-        return (_c = (_b = this.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.resources) === null || _c === void 0 ? void 0 : _c.source;
+        return (_c = (_b = this.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.resources) === null || _c === void 0 ? void 0 : _c.boot;
     }
     static getProtobufMessages(schema = 'v1CurrentSchema') {
         return this.messages[schema];
@@ -41006,10 +41006,12 @@ DataManager.deviceMap = {
         ble: [],
     },
     [hdShared.EDeviceType.Pro2]: {
-        'firmware-v1': [],
+        firmware: [],
+        ble: [],
     },
     [hdShared.EDeviceType.Neo]: {
-        'firmware-v1': [],
+        firmware: [],
+        ble: [],
     },
     [hdShared.EDeviceType.ClassicPure]: {
         firmware: [],
@@ -42006,7 +42008,7 @@ const getFirmwareUpdateField = ({ features, updateType, targetVersion, firmwareT
     if (deviceType === hdShared.EDeviceType.Pro) {
         return latestFirmwareField;
     }
-    if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) {
+    if (deviceType === hdShared.EDeviceType.Pro2) {
         return 'firmware-v1';
     }
     return 'firmware';
@@ -42038,7 +42040,7 @@ const getFirmwareUpdateFieldArray = (features, updateType) => {
     if (deviceType === 'pro') {
         return ['firmware-v8'];
     }
-    if (deviceType === 'pro2' || deviceType === 'neo') {
+    if (deviceType === 'pro2') {
         return ['firmware-v1'];
     }
     return ['firmware'];
@@ -47381,93 +47383,76 @@ class ClearSessionCache extends BaseMethod {
     }
 }
 
-const PROTOCOL_V2_MAIN_FIRMWARE_TARGETS = [
-    'APPLICATION_P1',
-    'APPLICATION_P2',
-    'SE01',
-    'SE02',
-    'SE03',
-    'SE04',
-];
-const PROTOCOL_V2_BLE_TARGETS = [
-    'COPROCESSOR',
-];
-const PROTOCOL_V2_BOOTLOADER_TARGETS = [
-    'BOOTLOADER',
-];
-function loadProtocolV2FirmwareReleaseContext({ device, firmwareType: firmwareTypeParam, checkFirmwareHash = false, methodName, }) {
-    var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        const state = yield device.getDeviceState({
-            refreshSections: checkFirmwareHash
-                ? ['identity', 'versions', 'verification']
-                : ['identity', 'versions'],
-        });
-        if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportMethod, `${methodName} requires a Pro2 or Neo device for Protocol V2`);
-        }
-        const { features } = device;
-        if (!features) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `${methodName} requires initialized device features`);
-        }
-        const firmwareType = (_a = firmwareTypeParam !== null && firmwareTypeParam !== void 0 ? firmwareTypeParam : state.identity.firmwareType) !== null && _a !== void 0 ? _a : hdShared.EFirmwareType.Universal;
-        return {
-            state: state,
-            features,
-            firmwareType,
-            release: DataManager.getFirmwareLatestRelease(features, firmwareType),
-        };
-    });
-}
-function summarizeProtocolV2FirmwareRelease(plan, componentTargets) {
-    var _a;
-    const targetSet = new Set(componentTargets);
-    const components = plan.components.filter(component => targetSet.has(component.componentTarget));
-    const targetsToUpdate = Array.from(new Set(components.flatMap(component => component.status === 'outdated' && component.updateTarget ? [component.updateTarget] : [])));
-    const hasUpgrade = targetsToUpdate.length > 0;
-    const required = !!((_a = plan.release) === null || _a === void 0 ? void 0 : _a.required) && hasUpgrade;
-    let status = 'valid';
-    if (!plan.release || components.length === 0) {
-        status = 'unavailable';
-    }
-    else if (required) {
-        status = 'required';
+class CheckFirmwareRelease extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [
+            ...this.allowDeviceMode,
+            UI_REQUEST.NOT_INITIALIZE,
+            UI_REQUEST.BOOTLOADER,
+        ];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
     }
-    else if (hasUpgrade) {
-        status = 'outdated';
+    run() {
+        var _a;
+        const payload = this.payload;
+        if (this.device.features) {
+            const deviceFirmwareType = this.device.getCurrentFirmwareType();
+            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+            const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
+            return Promise.resolve(releaseInfo);
+        }
+        return Promise.resolve(null);
     }
-    else if (components.some(component => component.status === 'unknown')) {
-        status = 'unknown';
+}
+
+class CheckBLEFirmwareRelease extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [
+            ...this.allowDeviceMode,
+            UI_REQUEST.NOT_INITIALIZE,
+            UI_REQUEST.BOOTLOADER,
+        ];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
     }
-    else if (components.every(component => component.status === 'unsupported')) {
-        status = 'unavailable';
+    run() {
+        if (this.device.features) {
+            const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
+            return Promise.resolve(releaseInfo);
+        }
+        return Promise.resolve(null);
     }
-    return Object.assign(Object.assign({}, plan), { status,
-        hasUpgrade,
-        required,
-        components,
-        targetsToUpdate });
 }
-function toProtocolV2FirmwareReleaseInfo({ plan, state, release, }) {
-    return {
-        shouldUpdate: plan.hasUpgrade,
-        status: plan.status === 'unavailable' ? 'unknown' : plan.status,
-        changelog: plan.release ? [plan.release.changelog] : [],
-        release,
-        bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
-    };
-}
-function getProtocolV2ComponentReleaseInfo(plan, componentTarget) {
-    var _a;
-    const componentRelease = plan.components.find(component => component.componentTarget === componentTarget);
-    if (!componentRelease || !plan.release) {
-        return undefined;
+
+class CheckBridgeStatus extends BaseMethod {
+    init() {
+        this.useDevice = false;
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
     }
-    const component = (_a = plan.release.components) === null || _a === void 0 ? void 0 : _a[componentRelease.configKey];
-    if (!component) {
-        return undefined;
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                axios__default["default"]
+                    .request({
+                    url: 'http://localhost:21320',
+                    method: 'POST',
+                    withCredentials: false,
+                    timeout: 3000,
+                })
+                    .then(() => resolve(true))
+                    .catch(e => {
+                    if (e.code === 'ECONNABORTED') {
+                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
+                    }
+                    else {
+                        resolve(false);
+                    }
+                });
+            });
+        });
     }
-    return Object.assign(Object.assign({}, component), { protocol: 'V2', configKey: componentRelease.configKey, componentTarget, required: plan.release.required, changelog: plan.release.changelog });
 }
 
 const REQUIRED_BRIDGE_VERSION = '2.2.0';
@@ -47524,6 +47509,56 @@ function getBridgeReleaseInfo({ deviceType, currentFirmwareVersion, willUpdateFi
     });
 }
 
+class CheckBridgeRelease extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device.features) {
+                return null;
+            }
+            const { willUpdateFirmwareVersion } = this.payload;
+            const { features } = this.device;
+            const deviceType = getDeviceType(features);
+            const currentFirmwareVersion = getDeviceFirmwareVersion(features).join('.');
+            return getBridgeReleaseInfo({
+                deviceType,
+                currentFirmwareVersion,
+                willUpdateFirmwareVersion,
+            });
+        });
+    }
+}
+
+class CheckBootloaderRelease extends BaseMethod {
+    init() {
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
+        this.useDevicePassphraseState = false;
+        this.skipForceUpdateCheck = true;
+    }
+    run() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.device.features) {
+                return null;
+            }
+            const { features } = this.device;
+            const payload = this.payload;
+            const deviceFirmwareType = this.device.getCurrentFirmwareType();
+            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+            const releaseInfo = getBootloaderReleaseInfo({
+                features,
+                willUpdateFirmwareVersion: payload.willUpdateFirmwareVersion,
+                firmwareType,
+            });
+            return Promise.resolve(releaseInfo);
+        });
+    }
+}
+
 const UPDATE_TARGET_BY_COMPONENT_TARGET = {
     BOOTLOADER: 'boot',
     APPLICATION_P1: 'app_v1',
@@ -47771,15 +47806,22 @@ class CheckAllFirmwareRelease extends BaseMethod {
     runProtocolV2() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { checkFirmwareHash = false, firmwareType: firmwareTypeParam, platform, forceUpdateTargets, protocolV2ForceUpdateTargets, } = this.payload;
-            const validatedForceUpdateTargets = validateFirmwareUpdatePlanForceTargets(forceUpdateTargets);
-            const validatedProtocolV2ForceUpdateTargets = validateProtocolV2FirmwareUpdateTargets(protocolV2ForceUpdateTargets);
-            const { state, features, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
-                device: this.device,
-                firmwareType: firmwareTypeParam,
-                checkFirmwareHash,
-                methodName: 'checkAllFirmwareRelease',
+            const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
+                .payload;
+            const state = yield this.device.getDeviceState({
+                refreshSections: checkFirmwareHash
+                    ? ['identity', 'versions', 'verification']
+                    : ['identity', 'versions'],
             });
+            if (state.identity.deviceType !== 'pro2' && state.identity.deviceType !== 'neo') {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceNotSupportMethod, 'checkAllFirmwareRelease requires a Pro2 or Neo device for Protocol V2');
+            }
+            const { features } = this.device;
+            if (!features) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'checkAllFirmwareRelease requires initialized device features');
+            }
+            const firmwareType = (_a = firmwareTypeParam !== null && firmwareTypeParam !== void 0 ? firmwareTypeParam : state.identity.firmwareType) !== null && _a !== void 0 ? _a : hdShared.EFirmwareType.Universal;
+            const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
             const plan = buildProtocolV2FirmwareRelease({
                 currentVersions: state.versions,
                 currentVerification: checkFirmwareHash ? state.verification : undefined,
@@ -47789,250 +47831,48 @@ class CheckAllFirmwareRelease extends BaseMethod {
                 deviceType: state.identity.deviceType,
             });
             const resourceDeviceType = state.identity.deviceType === 'neo' ? hdShared.EDeviceType.Neo : hdShared.EDeviceType.Pro2;
-            const resourceSource = DataManager.getProtocolV2ResourceSource(resourceDeviceType);
-            const resourceStatus = 'unknown';
-            const detectedComponentTargets = validatedForceUpdateTargets.includes('firmware')
-                ? plan.components.flatMap(component => component.updateTarget ? [component.updateTarget] : [])
-                : plan.targetsToUpdate;
-            const componentTargetsToUpdate = Array.from(new Set([
-                ...detectedComponentTargets,
-                ...validatedProtocolV2ForceUpdateTargets.filter(target => target !== 'resource'),
-            ]));
-            const forceResourceUpdate = validatedForceUpdateTargets.includes('resource') ||
-                validatedProtocolV2ForceUpdateTargets.includes('resource');
-            const targetsToUpdate = Array.from(new Set([
-                ...componentTargetsToUpdate,
-                ...(forceResourceUpdate ? ['resource'] : []),
-            ]));
-            let firmwareUpdatePlan;
-            const shouldBuildFirmwareUpdatePlan = targetsToUpdate.length > 0;
-            const requestedPlatform = platform !== null && platform !== void 0 ? platform : 'web';
-            const requiresPreparedPlan = shouldBuildFirmwareUpdatePlan &&
-                (requestedPlatform === 'native' || requestedPlatform === 'desktop');
-            try {
-                if (shouldBuildFirmwareUpdatePlan) {
-                    const validatedPlan = buildProtocolV2FirmwareUpdatePlan({
-                        features,
-                        firmwareType,
-                        platform: requestedPlatform,
-                        release,
-                        targetsToUpdate,
-                        forceUpdateTargets: validatedForceUpdateTargets,
-                        resourceArchive: resourceSource,
-                    });
-                    firmwareUpdatePlan = validatedPlan;
-                }
-                else {
-                    firmwareUpdatePlan = undefined;
-                }
-            }
-            catch (error) {
-                if (requiresPreparedPlan ||
-                    validatedForceUpdateTargets.length > 0 ||
-                    validatedProtocolV2ForceUpdateTargets.length > 0 ||
-                    !(error instanceof hdShared.HardwareError) ||
-                    ((_a = error.params) === null || _a === void 0 ? void 0 : _a.firmwareUpdateCode) !== 'FirmwarePlanInvalid') {
-                    throw error;
-                }
-                Log$c.warn('[CheckAllFirmwareRelease] Optional Protocol V2 firmware Plan is unavailable; using the release result');
-                firmwareUpdatePlan = undefined;
-            }
-            const firmwarePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_MAIN_FIRMWARE_TARGETS);
-            const blePlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BLE_TARGETS);
-            const bootloaderPlan = summarizeProtocolV2FirmwareRelease(plan, PROTOCOL_V2_BOOTLOADER_TARGETS);
-            const { status } = plan;
-            return Object.assign(Object.assign({ firmware: toProtocolV2FirmwareReleaseInfo({ plan: firmwarePlan, state, release }), ble: toProtocolV2FirmwareReleaseInfo({
-                    plan: blePlan,
-                    state,
-                    release: getProtocolV2ComponentReleaseInfo(plan, 'COPROCESSOR'),
-                }), bootloader: toProtocolV2FirmwareReleaseInfo({
-                    plan: bootloaderPlan,
-                    state,
-                    release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
-                }), features, protocol: 'V2', deviceType: state.identity.deviceType }, plan), { status,
-                resourceStatus, resourceArchive: resourceSource, hasUpgrade: targetsToUpdate.length > 0, targetsToUpdate,
-                firmwareUpdatePlan });
-        });
-    }
-}
-
-class CheckFirmwareRelease extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V1', 'V2'];
-    }
-    init() {
-        this.allowDeviceMode = [
-            ...this.allowDeviceMode,
-            UI_REQUEST.NOT_INITIALIZE,
-            UI_REQUEST.BOOTLOADER,
-        ];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            const payload = this.payload;
-            if (!this.device.features)
-                return null;
-            if (this.device.isProtocolV2()) {
-                const { state, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
-                    device: this.device,
-                    firmwareType: payload.firmwareType,
-                    methodName: 'checkFirmwareRelease',
-                });
-                const plan = summarizeProtocolV2FirmwareRelease(buildProtocolV2FirmwareRelease({
-                    currentVersions: state.versions,
-                    firmwareType,
-                    release,
-                    deviceType: state.identity.deviceType,
-                }), PROTOCOL_V2_MAIN_FIRMWARE_TARGETS);
-                return toProtocolV2FirmwareReleaseInfo({ plan, state, release });
-            }
-            const deviceFirmwareType = this.device.getCurrentFirmwareType();
-            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
-            const releaseInfo = getFirmwareReleaseInfo(this.device.features, firmwareType);
-            return releaseInfo;
-        });
-    }
-}
-
-class CheckBLEFirmwareRelease extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V1', 'V2'];
-    }
-    init() {
-        this.allowDeviceMode = [
-            ...this.allowDeviceMode,
-            UI_REQUEST.NOT_INITIALIZE,
-            UI_REQUEST.BOOTLOADER,
-        ];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features)
-                return null;
-            if (this.device.isProtocolV2()) {
-                const { state, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
-                    device: this.device,
-                    methodName: 'checkBLEFirmwareRelease',
-                });
-                const plan = summarizeProtocolV2FirmwareRelease(buildProtocolV2FirmwareRelease({
-                    currentVersions: state.versions,
-                    firmwareType,
-                    release,
-                    deviceType: state.identity.deviceType,
-                }), PROTOCOL_V2_BLE_TARGETS);
-                return toProtocolV2FirmwareReleaseInfo({
-                    plan,
-                    state,
-                    release: getProtocolV2ComponentReleaseInfo(plan, 'COPROCESSOR'),
-                });
-            }
-            const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-            return releaseInfo;
-        });
-    }
-}
-
-class CheckBridgeStatus extends BaseMethod {
-    init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve, reject) => {
-                axios__default["default"]
-                    .request({
-                    url: 'http://localhost:21320',
-                    method: 'POST',
-                    withCredentials: false,
-                    timeout: 3000,
-                })
-                    .then(() => resolve(true))
-                    .catch(e => {
-                    if (e.code === 'ECONNABORTED') {
-                        reject(hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError));
+            const resources = DataManager.getProtocolV2Resources(resourceDeviceType);
+            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) {
+                    try {
+                        const inventory = yield readProtocolV2ResourceInventory({
+                            commands: this.device.getCommands(),
+                            resources,
+                        });
+                        resourceStatus = buildProtocolV2ResourceUpdatePlan({
+                            resources,
+                            inventory,
+                            mode: 'bootloader-recovery',
+                        }).status;
                     }
-                    else {
-                        resolve(false);
+                    catch (_b) {
+                        resourceStatus = buildProtocolV2ResourceUpdatePlan({
+                            resources,
+                            mode: 'bootloader-recovery',
+                        }).status;
                     }
-                });
-            });
-        });
-    }
-}
-
-class CheckBridgeRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features) {
-                return null;
-            }
-            const { willUpdateFirmwareVersion } = this.payload;
-            const { features } = this.device;
-            const deviceType = getDeviceType(features);
-            const currentFirmwareVersion = getDeviceFirmwareVersion(features).join('.');
-            return getBridgeReleaseInfo({
-                deviceType,
-                currentFirmwareVersion,
-                willUpdateFirmwareVersion,
-            });
-        });
-    }
-}
-
-class CheckBootloaderRelease extends BaseMethod {
-    getSupportedProtocols() {
-        return ['V1', 'V2'];
-    }
-    init() {
-        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.BOOTLOADER];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    run() {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.device.features)
-                return null;
-            const { features } = this.device;
-            const payload = this.payload;
-            if (this.device.isProtocolV2()) {
-                const { state, firmwareType, release } = yield loadProtocolV2FirmwareReleaseContext({
-                    device: this.device,
-                    firmwareType: payload.firmwareType,
-                    methodName: 'checkBootloaderRelease',
-                });
-                const plan = summarizeProtocolV2FirmwareRelease(buildProtocolV2FirmwareRelease({
-                    currentVersions: state.versions,
-                    firmwareType,
-                    release,
-                    deviceType: state.identity.deviceType,
-                }), PROTOCOL_V2_BOOTLOADER_TARGETS);
-                return toProtocolV2FirmwareReleaseInfo({
-                    plan,
-                    state,
-                    release: getProtocolV2ComponentReleaseInfo(plan, 'BOOTLOADER'),
-                });
+                }
             }
-            const deviceFirmwareType = this.device.getCurrentFirmwareType();
-            const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
-            const releaseInfo = getBootloaderReleaseInfo({
-                features,
-                willUpdateFirmwareVersion: payload.willUpdateFirmwareVersion,
-                firmwareType,
-            });
-            return Promise.resolve(releaseInfo);
+            const targetsToUpdate = [
+                ...plan.targetsToUpdate,
+                ...(resourceStatus === 'outdated' ? ['resource'] : []),
+            ];
+            const firmwareStatus = plan.status === 'unavailable' ? 'unknown' : plan.status;
+            const emptyRelease = 'none';
+            return Object.assign(Object.assign({ firmware: {
+                    status: firmwareStatus,
+                    changelog: release ? [release.changelog] : [],
+                    release: release !== null && release !== void 0 ? release : emptyRelease,
+                    bootloaderMode: state.status.mode === 'bootloader' || state.status.mode === 'romloader',
+                }, ble: {
+                    status: 'valid',
+                    release: emptyRelease,
+                }, bootloader: {
+                    status: 'valid',
+                    release: emptyRelease,
+                }, features, protocol: 'V2', deviceType: state.identity.deviceType }, plan), { resourceStatus, hasUpgrade: plan.hasUpgrade || resourceStatus === 'outdated', targetsToUpdate });
         });
     }
 }
@@ -49404,6 +49244,8 @@ class FirmwareUpdateBaseMethod extends BaseMethod {
                 !this.payload.skipWebDevicePrompt &&
                 !hasPromptedWebDevice &&
                 !isPromptingWebDevice) {
+                clearInterval(intervalTimer);
+                clearTimeout(timeoutTimer);
                 isPromptingWebDevice = true;
                 try {
                     this.postTipMessage(exports.FirmwareUpdateTipMessage.SelectDeviceInBootloaderForWebDevice);
@@ -49777,35 +49619,24 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
         });
     }
     run() {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const { device } = this;
             const { features } = device;
             const payload = this.payload;
-            const hasPreparedPlan = payload.preparedPlan !== undefined;
-            const hasPreparedArtifact = payload.artifact !== undefined;
-            if (hasPreparedPlan !== hasPreparedArtifact) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Prepared bootloader plans require exactly one prepared artifact');
-            }
-            if (payload.binary !== undefined && hasPreparedArtifact) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Bootloader binary and prepared artifact are mutually exclusive');
-            }
-            const preparedPlan = hasPreparedArtifact
-                ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+            const hostBinding = payload.artifact
+                ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
                 : undefined;
-            const artifactReader = preparedPlan
-                ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration, preparedPlan.preparedPlanDigest).artifactReader
-                : payload.artifactReader;
-            const executionParams = Object.assign(Object.assign({}, payload), { artifactReader });
+            const executionParams = Object.assign(Object.assign({}, payload), { artifactReader: (_a = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _a !== void 0 ? _a : payload.artifactReader });
             if (payload.artifact) {
                 assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan,
+                    preparedPlan: payload.preparedPlan,
                     deviceIdentity: getDeviceUUID(features) || undefined,
                     bootloaderMode: resolveDeviceBootloaderMode(features),
                     deviceModel: String(getDeviceType(features)),
                 });
                 assertFirmwareUpdatePreparedPlanBinding({
-                    preparedPlan,
+                    preparedPlan: payload.preparedPlan,
                     executor: 'v2',
                     scopeTargets: ['bootloader'],
                     bindings: [
@@ -49825,7 +49656,7 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
                 try {
                     const deviceType = device.getCurrentDeviceType();
                     const deviceFirmwareType = device.getCurrentFirmwareType();
-                    const firmwareType = (_a = payload.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
+                    const firmwareType = (_b = payload.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
                     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
                         return yield this.updateTouchBootloader({
                             device,
@@ -49843,7 +49674,7 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
             const { binary } = payload;
             const deviceType = device.getCurrentDeviceType();
             const deviceFirmwareType = device.getCurrentFirmwareType();
-            const firmwareType = (_b = payload.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
+            const firmwareType = (_c = payload.firmwareType) !== null && _c !== void 0 ? _c : deviceFirmwareType;
             if (DeviceModelToTypes.model_touch.includes(deviceType)) {
                 return this.updateTouchBootloader({
                     device,
@@ -50197,9 +50028,6 @@ class FirmwareUpdateV2 extends BaseMethod {
             payload.artifact !== undefined) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Firmware update binary and artifact are mutually exclusive');
         }
-        if (payload.preparedPlan !== undefined && payload.artifact === undefined) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Prepared firmware plans require a prepared artifact');
-        }
         if (!payload.updateType) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
         }
@@ -50215,8 +50043,7 @@ class FirmwareUpdateV2 extends BaseMethod {
             this.params = Object.assign(Object.assign({}, this.params), { binary: payload.binary });
         }
         if ('artifact' in payload) {
-            const preparedPlan = validateFirmwareUpdatePreparedPlan(payload.preparedPlan);
-            const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration, preparedPlan.preparedPlanDigest);
+            const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration);
             const target = payload.isUpdateBootloader ? 'bootloader' : payload.updateType;
             const resourceBindings = ((_a = payload.resourceEntries) !== null && _a !== void 0 ? _a : []).map((entry) => ({
                 target: 'resource',
@@ -50224,13 +50051,13 @@ class FirmwareUpdateV2 extends BaseMethod {
                 artifact: entry.artifact,
             }));
             assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan,
+                preparedPlan: payload.preparedPlan,
                 executor: 'v2',
                 platform: payload.platform,
                 scopeTargets: [target, ...(target === 'firmware' ? ['resource'] : [])],
                 bindings: [{ target, artifact: payload.artifact }, ...resourceBindings],
             });
-            this.params = Object.assign(Object.assign({}, this.params), { preparedPlan, artifact: payload.artifact, resourceEntries: payload.resourceEntries, artifactReader: hostBinding.artifactReader });
+            this.params = Object.assign(Object.assign({}, this.params), { preparedPlan: payload.preparedPlan, artifact: payload.artifact, resourceEntries: payload.resourceEntries, artifactReader: hostBinding.artifactReader });
         }
     }
     _promptDeviceInBootloaderForWebDevice() {
@@ -50593,27 +50420,12 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             { name: 'firmwareType', type: 'string' },
             { name: 'platform', type: 'string' },
         ]);
-        const preparedPlan = payload.artifacts || payload.preparedPlan
-            ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+        const hostBinding = payload.artifacts || payload.preparedPlan
+            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
             : undefined;
-        const hasLegacyInputs = [
-            payload.bleVersion,
-            payload.bleBinary,
-            payload.firmwareVersion,
-            payload.firmwareBinary,
-            payload.resourceBinary,
-            payload.bootloaderVersion,
-            payload.bootloaderBinary,
-        ].some(input => input !== undefined);
-        if (preparedPlan && hasLegacyInputs) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Prepared firmware plans cannot be combined with legacy firmware inputs');
-        }
-        const artifactReader = preparedPlan
-            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration, preparedPlan.preparedPlanDigest).artifactReader
-            : payload.artifactReader;
-        if (preparedPlan) {
+        if (hostBinding) {
             assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan,
+                preparedPlan: payload.preparedPlan,
                 executor: 'v3',
                 platform: payload.platform,
                 scopeTargets: ['bootloader', 'firmware', 'resource', 'ble'],
@@ -50651,7 +50463,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             });
         }
         this.params = {
-            preparedPlan,
+            preparedPlan: payload.preparedPlan,
             bleBinary: payload.bleBinary,
             firmwareBinary: payload.firmwareBinary,
             forcedUpdateRes: payload.forcedUpdateRes,
@@ -50660,9 +50472,9 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             bootloaderBinary: payload.bootloaderBinary,
             firmwareVersion: payload.firmwareVersion,
             resourceBinary: payload.resourceBinary,
-            firmwareType: (_f = preparedPlan === null || preparedPlan === void 0 ? void 0 : preparedPlan.firmwareType) !== null && _f !== void 0 ? _f : payload.firmwareType,
+            firmwareType: payload.firmwareType,
             platform: payload.platform,
-            artifactReader,
+            artifactReader: (_f = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _f !== void 0 ? _f : payload.artifactReader,
             artifacts: payload.artifacts,
         };
     }
@@ -51278,88 +51090,6 @@ const INSTALLABLE_FIRMWARE_TARGET_IDS = new Set([
 ]);
 new Map(Object.entries(ProtocolV2FirmwareTargetType).flatMap(([key, value]) => INSTALLABLE_FIRMWARE_TARGET_IDS.has(value) ? [[key, value]] : []));
 
-let memoryHostSequence = 0;
-const createReference = (binary, prefix) => {
-    const digest = utils.bytesToHex(sha256.sha256(new Uint8Array(binary)));
-    return {
-        artifactRef: `fwmem:${prefix}:${digest.slice(0, 32)}`,
-        size: binary.byteLength,
-        sha256: digest,
-    };
-};
-function prepareFirmwareUpdateV4MemoryHost({ sdk, plan, artifacts, }) {
-    if (plan.executor !== 'v4') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware memory host only supports V4 plans');
-    }
-    memoryHostSequence += 1;
-    const hostId = `${Date.now()}:${memoryHostSequence}`;
-    const binaries = new Map();
-    const inputs = artifacts.map((input, artifactIndex) => {
-        var _a;
-        const artifactBinary = new Uint8Array(input.binary).slice();
-        const artifact = createReference(artifactBinary.buffer, `${hostId}:artifact:${artifactIndex}`);
-        binaries.set(artifact.artifactRef, artifactBinary);
-        const materializedEntries = (_a = input.materializedEntries) === null || _a === void 0 ? void 0 : _a.map((entry, entryIndex) => {
-            const entryBinary = new Uint8Array(entry.binary).slice();
-            const entryArtifact = createReference(entryBinary.buffer, `${hostId}:entry:${artifactIndex}:${entryIndex}`);
-            binaries.set(entryArtifact.artifactRef, entryBinary);
-            return {
-                entryName: entry.entryName,
-                artifact: entryArtifact,
-            };
-        });
-        return Object.assign({ artifactId: input.artifactId, artifact }, ((materializedEntries === null || materializedEntries === void 0 ? void 0 : materializedEntries.length) ? { materializedEntries } : {}));
-    });
-    const preparedPlan = sdk.prepareFirmwareUpdatePlan({
-        plan,
-        leaseRef: `fwmemlease:${hostId}`,
-        artifacts: inputs,
-    });
-    const readers = new Map();
-    let readerSequence = 0;
-    const artifactReader = {
-        open({ artifactRef }) {
-            const binary = binaries.get(artifactRef);
-            if (!binary) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware memory artifact is unavailable');
-            }
-            readerSequence += 1;
-            const readerId = `fwmemreader:${hostId}:${readerSequence}`;
-            readers.set(readerId, binary);
-            return Promise.resolve({ readerId, size: binary.byteLength });
-        },
-        read({ readerId, offset, length }) {
-            const binary = readers.get(readerId);
-            if (!binary || offset < 0 || length <= 0 || offset + length > binary.byteLength) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware memory artifact read is invalid');
-            }
-            const data = binary.slice(offset, offset + length).buffer;
-            return Promise.resolve({
-                data,
-                bytesRead: data.byteLength,
-                eof: offset + length === binary.byteLength,
-            });
-        },
-        close({ readerId }) {
-            readers.delete(readerId);
-            return Promise.resolve();
-        },
-    };
-    const hostBindingGeneration = sdk.registerFirmwareUpdateHostBinding({
-        artifactReader,
-        preparedPlanDigest: preparedPlan.preparedPlanDigest,
-    });
-    return {
-        preparedPlan,
-        hostBindingGeneration,
-        release: () => {
-            sdk.unregisterFirmwareUpdateHostBinding(hostBindingGeneration);
-            readers.clear();
-            binaries.clear();
-        },
-    };
-}
-
 const Log$6 = getLogger(exports.LoggerNames.Method);
 const SESSION_ERROR$1 = 'session not found';
 const PROTOCOL_V2_BOOTLOADER_RECONNECT_TIMEOUT = 90 * 1000;
@@ -51386,24 +51116,7 @@ const PROTOCOL_V2_OKPP_HEADER_SIZE = 0x52a0;
 const PROTOCOL_V2_OKPP_PAYLOAD_HASH_OFFSET = 0x200;
 const PROTOCOL_V2_OKPP_HEADER_HASH_OFFSET = 0x240;
 const PROTOCOL_V2_OKPP_HASH_SIZE = 64;
-const PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES = 1024 * 1024;
-const PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT = 512;
-const PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES = 256 * 1024 * 1024;
 const PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS = new Set(['se03', 'se04']);
-const getProtocolV2ZipEntrySizes = (entry) => {
-    var _a;
-    const { compressedSize, uncompressedSize } = (_a = entry._data) !== null && _a !== void 0 ? _a : {};
-    if (!Number.isSafeInteger(compressedSize) ||
-        Number(compressedSize) < 0 ||
-        !Number.isSafeInteger(uncompressedSize) ||
-        Number(uncompressedSize) <= 0) {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource ZIP entry size is invalid: ${entry.name}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-    }
-    return {
-        compressedSize: Number(compressedSize),
-        uncompressedSize: Number(uncompressedSize),
-    };
-};
 function assertProtocolV2FirmwareTargetsSupported(deviceType, params) {
     var _a;
     const unsupportedTargets = new Set(((_a = params.targetsToUpdate) !== null && _a !== void 0 ? _a : []).filter(target => PROTOCOL_V2_NEO_UNSUPPORTED_TARGETS.has(target)));
@@ -51474,14 +51187,6 @@ const PROTOCOL_V2_REMOTE_COMPONENT_TARGETS = {
     },
 };
 const PROTOCOL_V2_FIRMWARE_STAGING_PATHS = new Set(Object.values(PROTOCOL_V2_REMOTE_COMPONENT_TARGETS).map(target => `${PROTOCOL_V2_FIRMWARE_STAGING_VOLUME}${target.fileName}`));
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH = 'vol0:/loaders/bootloader/boot_resource.okpkg';
-const PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH = `${PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH}.staging`;
-const resolveProtocolV2ResourceWritePath = (devicePath) => {
-    const normalizedPath = devicePath.replace(/^vol0:(?!\/)/i, 'vol0:/').toLowerCase();
-    return normalizedPath === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH
-        ? PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH
-        : devicePath;
-};
 const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map([
     [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_BOOTLOADER, 'boot'],
     [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_APPLICATION_P1, 'app_v1'],
@@ -51492,10 +51197,6 @@ const PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID = new Map([
     [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE03, 'se03'],
     [ProtocolV2FirmwareTargetType.FW_MGMT_TARGET_SE04, 'se04'],
 ]);
-const PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET = new Map(Object.values(PROTOCOL_V2_REMOTE_COMPONENT_TARGETS).map(target => [
-    PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId),
-    target,
-]));
 const PROTOCOL_V2_ROMLOADER_UNSUPPORTED_MESSAGE = 'FW_MGMT_TARGET_ROMLOADER is not accepted by the current Pro2 bootloader update request. Flash romloader with the loader-specific flow instead of firmwareUpdateV4.';
 const PROTOCOL_V2_TARGET_ID_BY_DECODED_NAME = new Map(Object.entries(ProtocolV2FirmwareTargetType).map(([key, value]) => [key, value]));
 const PROTOCOL_V2_TARGET_STATUS_BY_DECODED_NAME = new Map([
@@ -51660,7 +51361,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return ['V2'];
     }
     init() {
-        var _a, _b;
+        var _a, _b, _c;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.unlockPolicy = 'unlock-before-run';
@@ -51691,85 +51392,54 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             { name: 'se02Binary', type: 'buffer' },
             { name: 'se03Binary', type: 'buffer' },
             { name: 'se04Binary', type: 'buffer' },
-            { name: 'resourceArchiveBinary', type: 'buffer' },
             { name: 'firmwareType', type: 'string' },
             { name: 'targetsToUpdate', type: 'array', allowEmpty: true },
             { name: 'platform', type: 'string' },
             { name: 'expectedDeviceId', type: 'string' },
+            { name: 'resourceFiles', type: 'array', allowEmpty: true },
         ]);
         if (payload.expectedDeviceId !== undefined &&
             (payload.expectedDeviceId.length === 0 || payload.expectedDeviceId.length > 160)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Protocol V2 expected device identity is invalid');
         }
-        const preparedPlan = payload.preparedPlan
-            ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
+        const hostBinding = payload.preparedPlan || payload.componentArtifacts || payload.resourceBundleArtifacts
+            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
             : undefined;
-        const hasLocalArtifacts = [
-            payload.bootloaderBinary,
-            payload.romloaderBinary,
-            payload.applicationP1Binary,
-            payload.applicationP2Binary,
-            payload.coprocessorBinary,
-            payload.se01Binary,
-            payload.se02Binary,
-            payload.se03Binary,
-            payload.se04Binary,
-            payload.resourceArchiveBinary,
-        ].some(Boolean);
-        if (preparedPlan && hasLocalArtifacts) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Prepared firmware plans cannot be combined with legacy or local firmware inputs');
-        }
-        let { artifactReader } = payload;
-        if (preparedPlan) {
-            artifactReader = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration, preparedPlan.preparedPlanDigest).artifactReader;
-        }
-        else if (payload.hostBindingGeneration !== undefined) {
-            artifactReader = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration).artifactReader;
-        }
-        if (preparedPlan) {
+        if (hostBinding) {
             assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan,
+                preparedPlan: payload.preparedPlan,
                 executor: 'v4',
                 platform: payload.platform,
-                scopeTargets: [],
-                bindings: [],
+                scopeTargets: [
+                    'boot',
+                    'app_v1',
+                    'app_v2',
+                    'coprocessor',
+                    'resource',
+                    'se01',
+                    'se02',
+                    'se03',
+                    'se04',
+                ],
+                bindings: [
+                    ...Object.entries((_a = payload.componentArtifacts) !== null && _a !== void 0 ? _a : {}).flatMap(([target, artifact]) => artifact
+                        ? [
+                            {
+                                target: target,
+                                artifact,
+                            },
+                        ]
+                        : []),
+                    ...((_b = payload.resourceBundleArtifacts) !== null && _b !== void 0 ? _b : []).map((entry) => ({
+                        target: 'resource',
+                        logicalName: entry.name,
+                        artifact: entry.artifact,
+                    })),
+                ],
             });
-            if (payload.componentArtifacts) {
-                const componentBindings = Object.entries(payload.componentArtifacts).flatMap(([target, artifact]) => artifact
-                    ? [
-                        {
-                            target: target,
-                            artifact: artifact,
-                        },
-                    ]
-                    : []);
-                assertFirmwareUpdatePreparedPlanBinding({
-                    preparedPlan,
-                    executor: 'v4',
-                    platform: payload.platform,
-                    scopeTargets: componentBindings.map(binding => binding.target),
-                    bindings: componentBindings,
-                });
-            }
-        }
-        const preparedExpectedTargetVersions = preparedPlan === null || preparedPlan === void 0 ? void 0 : preparedPlan.artifacts.reduce((result, artifact) => {
-            if (artifact.role === 'component' &&
-                artifact.target !== 'resource' &&
-                artifact.targetVersion &&
-                PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET.has(artifact.target)) {
-                result[artifact.target] = artifact.targetVersion;
-            }
-            return result;
-        }, {});
-        const localTargetsToUpdate = (_a = payload.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.map((target) => target === 'boot_resources' ? 'resource' : target);
-        if (payload.resourceArchiveBinary &&
-            localTargetsToUpdate &&
-            !localTargetsToUpdate.includes('resource')) {
-            localTargetsToUpdate.push('resource');
         }
-        const resolvedLocalTargetsToUpdate = localTargetsToUpdate !== null && localTargetsToUpdate !== void 0 ? localTargetsToUpdate : (payload.resourceArchiveBinary ? ['resource'] : undefined);
         this.params = {
-            preparedPlan,
+            preparedPlan: payload.preparedPlan,
             chunkSize: payload.chunkSize,
             forcedUpdateRes: payload.forcedUpdateRes,
             bootloaderBinary: payload.bootloaderBinary,
@@ -51781,18 +51451,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             se02Binary: payload.se02Binary,
             se03Binary: payload.se03Binary,
             se04Binary: payload.se04Binary,
-            resourceArchiveBinary: payload.resourceArchiveBinary,
-            firmwareType: (_b = preparedPlan === null || preparedPlan === void 0 ? void 0 : preparedPlan.firmwareType) !== null && _b !== void 0 ? _b : payload.firmwareType,
-            targetsToUpdate: preparedPlan
-                ? [...preparedPlan.targetsToUpdate]
-                : resolvedLocalTargetsToUpdate,
-            expectedTargetVersions: preparedPlan
-                ? preparedExpectedTargetVersions
-                : payload.expectedTargetVersions,
+            resourceFiles: payload.resourceFiles,
+            firmwareType: payload.firmwareType,
+            targetsToUpdate: payload.targetsToUpdate,
+            expectedTargetVersions: payload.expectedTargetVersions,
             platform: payload.platform,
             expectedDeviceId: payload.expectedDeviceId,
-            artifactReader,
-            componentArtifacts: preparedPlan ? undefined : payload.componentArtifacts,
+            artifactReader: (_c = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _c !== void 0 ? _c : payload.artifactReader,
+            componentArtifacts: payload.componentArtifacts,
+            resourceBundleArtifacts: payload.resourceBundleArtifacts,
         };
     }
     getProtocolV2FirmwareChunkSize(direction, filePath) {
@@ -51823,7 +51490,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     runProtocolV2() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.captureProtocolV2PhysicalIdentity();
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
@@ -51835,80 +51502,85 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const deviceFirmwareType = getFirmwareType(deviceFeatures);
             const firmwareType = (_a = this.params.firmwareType) !== null && _a !== void 0 ? _a : deviceFirmwareType;
             this.validateExpectedTargetVersions();
-            if (!this.params.preparedPlan &&
-                this.params.resourceArchiveBinary &&
-                ((_b = this.params.targetsToUpdate) === null || _b === void 0 ? void 0 : _b.includes('resource'))) {
-                const localMemoryHost = yield this.prepareProtocolV2LocalMemoryHost({
-                    features: deviceFeatures,
-                    firmwareType,
-                });
-                try {
-                    return yield this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
-                }
-                finally {
-                    localMemoryHost.release();
-                }
-            }
-            const hasPreparedComponentArtifacts = Object.values((_c = this.params.componentArtifacts) !== null && _c !== void 0 ? _c : {}).some(Boolean);
-            if (this.params.preparedPlan || hasPreparedComponentArtifacts) {
+            if ((this.params.componentArtifacts && Object.keys(this.params.componentArtifacts).length > 0) ||
+                ((_b = this.params.resourceBundleArtifacts) === null || _b === void 0 ? void 0 : _b.length)) {
                 return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
             }
-            const wantsResources = !!((_d = this.params.targetsToUpdate) === null || _d === void 0 ? void 0 : _d.includes('resource'));
+            const hasExplicitResourceFiles = !!((_c = this.params.resourceFiles) === null || _c === void 0 ? void 0 : _c.length);
+            const wantsStableResources = !!((_d = this.params.targetsToUpdate) === null || _d === void 0 ? void 0 : _d.includes('resource'));
+            const wantsBootResources = !!((_e = this.params.targetsToUpdate) === null || _e === void 0 ? void 0 : _e.includes('boot_resources'));
+            const needsRemoteResources = !hasExplicitResourceFiles && wantsStableResources;
+            const needsRemoteBootResources = !hasExplicitResourceFiles && (wantsBootResources || wantsStableResources);
             let fwBinaryMap = [];
             let bootloaderBinary = null;
             let installItems;
+            let resourceBundles;
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
+                resourceBundles = this.prepareExplicitProtocolV2ResourceFiles();
                 fwBinaryMap = this.collectExplicitTargetBinaries();
                 bootloaderBinary = this.prepareBootloaderBinary();
-                const explicitInstallItems = this.buildProtocolV2InstallItems({
-                    bootloaderBinary,
-                    fwBinaryMap,
-                });
-                const missingFirmwareTargets = this.getMissingProtocolV2FirmwareTargets(explicitInstallItems);
-                const needsRemoteFirmware = ((_e = this.params.targetsToUpdate) === null || _e === void 0 ? void 0 : _e.length)
-                    ? missingFirmwareTargets.length > 0
-                    : explicitInstallItems.length === 0;
-                if (wantsResources) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource archive must be provided through a local or external PreparedPlan', {
-                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                    });
-                }
-                if (needsRemoteFirmware &&
+                const needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
+                if ((needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) &&
                     (this.params.artifactReader ||
                         DataManager.getSettings('firmwareManifestMode') === 'external-only')) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware artifacts must be prepared by the external firmware host', {
                         firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
                     });
                 }
-                if (needsRemoteFirmware) {
-                    yield DataManager.forceReloadData();
+                if (needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) {
+                    yield DataManager.forceReloadData({
+                        requireResources: needsRemoteResources || needsRemoteBootResources,
+                    });
                 }
                 if (needsRemoteFirmware) {
-                    const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures, explicitInstallItems);
+                    const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures);
                     bootloaderBinary = remoteBinaries.bootloaderBinary;
                     fwBinaryMap = remoteBinaries.fwBinaryMap;
                     installItems = remoteBinaries.installItems;
                 }
-                this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
+                const bootResourceFiles = yield this.prepareProtocolV2BootResources();
+                if (bootResourceFiles === null || bootResourceFiles === void 0 ? void 0 : bootResourceFiles.length) {
+                    resourceBundles = this.mergeProtocolV2ResourceBundles(resourceBundles, bootResourceFiles);
+                }
+                if (!needsRemoteResources) {
+                    this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
+                }
             }
             catch (err) {
-                if (typeof err === 'object' &&
-                    err !== null &&
-                    'params' in err &&
-                    ((_f = err.params) === null || _f === void 0 ? void 0 : _f.firmwareUpdateCode) === 'FirmwareArtifactsNotPrepared') {
-                    throw err;
-                }
                 if (err instanceof hdShared.HardwareError && err.errorCode === hdShared.HardwareErrorCode.NetworkError) {
                     throw err;
                 }
                 throw normalizeFirmwarePreparationError(err);
             }
-            if (!bootloaderBinary && fwBinaryMap.length === 0 && !(installItems === null || installItems === void 0 ? void 0 : installItems.length)) {
+            if (!bootloaderBinary &&
+                fwBinaryMap.length === 0 &&
+                !(installItems === null || installItems === void 0 ? void 0 : installItems.length) &&
+                !(resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) &&
+                !needsRemoteResources) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
             }
-            return this.executeProtocolV2Update(Object.assign({ fwBinaryMap,
-                bootloaderBinary }, (installItems ? { installItems } : undefined)));
+            if (needsRemoteResources) {
+                const enteredBootloader = yield this.enterProtocolV2BootloaderMode();
+                try {
+                    const stableResources = yield this.prepareProtocolV2ResourceBundles();
+                    resourceBundles = this.mergeProtocolV2ResourceBundles(resourceBundles, stableResources);
+                    this.postTipMessage(exports.FirmwareUpdateTipMessage.FinishDownloadFirmware);
+                }
+                catch (err) {
+                    if (enteredBootloader) {
+                        try {
+                            yield this.exitProtocolV2BootloaderToNormal();
+                        }
+                        catch (restoreError) {
+                            Log$6.warn('[FirmwareUpdateV4] failed to restore App mode after resource preparation error:', restoreError);
+                        }
+                    }
+                    throw normalizeFirmwarePreparationError(err);
+                }
+            }
+            return this.executeProtocolV2Update(Object.assign(Object.assign({ fwBinaryMap,
+                bootloaderBinary }, (installItems ? { installItems } : undefined)), ((resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) ? { resourceBundles } : undefined)));
         });
     }
     openProtocolV2PreparedSource(artifact) {
@@ -51945,34 +51617,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     prepareProtocolV2InstallSources(firmwareType, features) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.params.preparedPlan) {
-                const requestedTargets = new Set(this.params.preparedPlan.targetsToUpdate.filter((target) => target !== 'resource'));
-                const installSources = [];
-                const preparedTargets = new Set();
-                for (const artifact of this.params.preparedPlan.artifacts) {
-                    if (artifact.target !== 'resource') {
-                        const target = artifact.target;
-                        const installTarget = PROTOCOL_V2_INSTALL_TARGET_BY_UPDATE_TARGET.get(target);
-                        if (!requestedTargets.has(target) ||
-                            artifact.role !== 'component' ||
-                            artifact.container !== 'raw' ||
-                            !installTarget ||
-                            preparedTargets.has(target)) {
-                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 prepared component artifact is invalid: ${artifact.artifactId}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                        }
-                        installSources.push(Object.assign(Object.assign({}, installTarget), { source: yield this.openProtocolV2PreparedSource(artifact.artifact) }));
-                        preparedTargets.add(target);
-                    }
-                }
-                const missingTarget = Array.from(requestedTargets).find(target => !preparedTargets.has(target));
-                if (missingTarget) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 ${missingTarget} artifact is not prepared`, {
-                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                        artifactName: missingTarget,
-                    });
-                }
-                return installSources;
-            }
             const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
             if (!release) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 firmware release is unavailable');
@@ -52003,278 +51647,39 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return installSources;
         });
     }
-    prepareProtocolV2LocalMemoryHost({ features, firmwareType, }) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const installItems = this.buildProtocolV2InstallItems({
-                bootloaderBinary: this.prepareBootloaderBinary(),
-                fwBinaryMap: this.collectExplicitTargetBinaries(),
-            });
-            const requestedComponentTargets = new Set(((_a = this.params.targetsToUpdate) !== null && _a !== void 0 ? _a : []).filter((target) => target !== 'resource' && target !== 'boot_resources'));
-            const localComponentTargets = new Set(installItems.flatMap(item => {
-                const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-                return target ? [target] : [];
-            }));
-            const missingTarget = Array.from(requestedComponentTargets).find(target => !localComponentTargets.has(target));
-            if (missingTarget) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local update has no binary for requested target ${missingTarget}`, {
-                    firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                    artifactName: missingTarget,
-                });
-            }
-            const planArtifacts = [];
-            const memoryArtifacts = [];
-            for (const item of installItems) {
-                const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-                if (!target || item.binary.byteLength <= 0) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local firmware artifact is invalid: ${item.fileName}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                const artifactId = `component:${target}`;
-                planArtifacts.push(Object.assign({ artifactId,
-                    target, container: 'raw', logicalName: item.fileName, expectedSize: item.binary.byteLength, expectedSha256: bytesToHex(sha256.sha256(new Uint8Array(item.binary))) }, (((_b = this.params.expectedTargetVersions) === null || _b === void 0 ? void 0 : _b[target])
-                    ? { targetVersion: this.params.expectedTargetVersions[target] }
-                    : {})));
-                memoryArtifacts.push({ artifactId, binary: item.binary });
-            }
-            const resourceArchive = yield this.prepareProtocolV2LocalResourceArchive(this.params.resourceArchiveBinary);
-            const resourceArtifactId = 'resource:archive';
-            planArtifacts.push({
-                artifactId: resourceArtifactId,
-                target: 'resource',
-                container: 'zip',
-                logicalName: 'protocol-v2-local-resource-archive',
-                expectedSize: resourceArchive.binary.byteLength,
-                expectedSha256: bytesToHex(sha256.sha256(new Uint8Array(resourceArchive.binary))),
-            });
-            memoryArtifacts.push({
-                artifactId: resourceArtifactId,
-                binary: resourceArchive.binary,
-                materializedEntries: resourceArchive.materializedEntries,
-            });
-            const plan = buildProtocolV2LocalFirmwareUpdatePlan({
-                features,
-                firmwareType,
-                platform: this.params.platform,
-                artifacts: planArtifacts,
-            });
-            let memoryHost;
-            try {
-                memoryHost = prepareFirmwareUpdateV4MemoryHost({
-                    sdk: {
-                        prepareFirmwareUpdatePlan,
-                        registerFirmwareUpdateHostBinding,
-                        unregisterFirmwareUpdateHostBinding,
-                    },
-                    plan,
-                    artifacts: memoryArtifacts,
-                });
-                const preparedPlan = validateFirmwareUpdatePreparedPlan(memoryHost.preparedPlan);
-                assertFirmwareUpdatePreparedPlanBinding({
-                    preparedPlan,
-                    executor: 'v4',
-                    platform: this.params.platform,
-                    scopeTargets: [],
-                    bindings: [],
-                });
-                assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan,
-                    deviceIdentity: this.protocolV2ExpectedSerialNumber,
-                    deviceModel: this.getProtocolV2PreparedPlanDeviceModel(features),
-                });
-                const hostBinding = resolveFirmwareUpdateHostBinding(memoryHost.hostBindingGeneration, preparedPlan.preparedPlanDigest);
-                this.params.preparedPlan = preparedPlan;
-                this.params.targetsToUpdate = [...preparedPlan.targetsToUpdate];
-                this.params.artifactReader = hostBinding.artifactReader;
-                this.params.componentArtifacts = undefined;
-                return memoryHost;
-            }
-            catch (error) {
-                memoryHost === null || memoryHost === void 0 ? void 0 : memoryHost.release();
-                throw error;
-            }
-        });
-    }
-    prepareProtocolV2LocalResourceArchive(binary) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            if (binary.byteLength <= 0 || binary.byteLength > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP archive size is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const zip = yield JSZip__default["default"].loadAsync(binary);
-            const zipEntries = Object.values(zip.files);
-            if (zipEntries.some(entry => entry.unsafeOriginalName && entry.unsafeOriginalName !== entry.name)) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP contains an unsafe entry path', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const entries = zipEntries.filter(entry => !entry.dir);
-            if (entries.length === 0 || entries.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT + 1) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP entry set is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let declaredUncompressedSize = 0;
-            let declaredCompressedSize = 0;
-            for (const entry of entries) {
-                const sizes = getProtocolV2ZipEntrySizes(entry);
-                declaredCompressedSize += sizes.compressedSize;
-                declaredUncompressedSize += sizes.uncompressedSize;
-                const entryLimit = entry.name === 'manifest.json'
-                    ? PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES
-                    : PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES;
-                if (sizes.uncompressedSize > entryLimit ||
-                    declaredCompressedSize > binary.byteLength ||
-                    declaredUncompressedSize >
-                        PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES + PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP declared size exceeds the allowed limit', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-            }
-            const manifestEntry = zip.file('manifest.json');
-            if (!manifestEntry) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP has no manifest.json', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const manifestBinary = yield manifestEntry.async('arraybuffer');
-            if (manifestBinary.byteLength <= 0 ||
-                manifestBinary.byteLength > PROTOCOL_V2_RESOURCE_MANIFEST_MAX_BYTES) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource manifest size is invalid', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let manifestValue;
-            try {
-                manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-            }
-            catch (error) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource manifest is invalid: ${String(error)}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const manifest = parseProtocolV2ResourceManifest(manifestValue);
-            const selectedFiles = selectProtocolV2ResourceManifestFiles({
-                manifest,
-                targetsToUpdate: (_a = this.params.targetsToUpdate) !== null && _a !== void 0 ? _a : [],
-            });
-            const expectedEntryNames = new Set([
-                'manifest.json',
-                ...selectedFiles.map(file => file.archive_path),
-            ]);
-            if (entries.length !== expectedEntryNames.size ||
-                entries.some(entry => !expectedEntryNames.has(entry.name))) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 local resource ZIP contains an unexpected entry', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let totalSize = 0;
-            const materializedEntries = [
-                { entryName: 'manifest.json', binary: manifestBinary },
-            ];
-            for (const file of selectedFiles) {
-                const entry = zip.file(file.archive_path);
-                if (!entry) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource ZIP is missing ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                const { uncompressedSize } = getProtocolV2ZipEntrySizes(entry);
-                totalSize += uncompressedSize;
-                if (uncompressedSize !== file.size || totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource file declared size is invalid: ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-                }
-                const fileBinary = yield entry.async('arraybuffer');
-                const digest = bytesToHex(sha256.sha256(new Uint8Array(fileBinary)));
-                if (fileBinary.byteLength !== file.size || digest !== file.sha256.toLowerCase()) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 local resource file does not match manifest: ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
-                }
-                materializedEntries.push({ entryName: file.archive_path, binary: fileBinary });
-            }
-            return { binary, materializedEntries };
-        });
-    }
-    prepareProtocolV2ResourceSources() {
-        var _a, _b;
+    prepareProtocolV2ResourceSources(firmwareType, features) {
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
-            const resourceRequested = (_b = (_a = this.params.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.includes('resource')) !== null && _b !== void 0 ? _b : false;
+            const preparedArtifacts = (_a = this.params.resourceBundleArtifacts) !== null && _a !== void 0 ? _a : [];
+            const resourceRequested = ((_b = this.params.targetsToUpdate) === null || _b === void 0 ? void 0 : _b.includes('resource')) || preparedArtifacts.length > 0;
             if (!resourceRequested) {
                 return [];
             }
-            const archiveSources = yield this.prepareProtocolV2ResourceArchiveSources();
-            if (archiveSources) {
-                return archiveSources;
-            }
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 resource archive is not prepared', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-        });
-    }
-    prepareProtocolV2ResourceArchiveSources() {
-        var _a, _b, _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            const archiveArtifacts = (_b = (_a = this.params.preparedPlan) === null || _a === void 0 ? void 0 : _a.artifacts.filter(artifact => artifact.role === 'resourceBundle' &&
-                artifact.target === 'resource' &&
-                artifact.container === 'zip')) !== null && _b !== void 0 ? _b : [];
-            if (archiveArtifacts.length === 0) {
-                return undefined;
-            }
-            if (archiveArtifacts.length !== 1) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared plan must contain exactly one resource archive', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const archiveArtifact = archiveArtifacts[0];
-            const archiveSource = yield this.openProtocolV2PreparedSource(archiveArtifact.artifact);
-            if (archiveSource.size > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive exceeds the total size limit', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let archiveBinary;
-            try {
-                archiveBinary = yield readFirmwareByteSourceFully(archiveSource);
-            }
-            finally {
-                yield archiveSource.close();
-            }
-            const archiveDigest = bytesToHex(sha256.sha256(new Uint8Array(archiveBinary)));
-            if (archiveDigest !== archiveArtifact.artifact.sha256.toLowerCase()) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive does not match its approved receipt', { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
-            }
-            const verifiedArchive = yield this.prepareProtocolV2LocalResourceArchive(archiveBinary);
-            const entries = (_c = archiveArtifact.materializedEntries) !== null && _c !== void 0 ? _c : [];
-            const entriesByName = new Map(entries.map(entry => [entry.entryName, entry]));
-            if (entries.length !== verifiedArchive.materializedEntries.length ||
-                verifiedArchive.materializedEntries.some(entry => {
-                    const preparedEntry = entriesByName.get(entry.entryName);
-                    const digest = bytesToHex(sha256.sha256(new Uint8Array(entry.binary)));
-                    return (!preparedEntry ||
-                        preparedEntry.artifact.size !== entry.binary.byteLength ||
-                        preparedEntry.artifact.sha256.toLowerCase() !== digest);
-                })) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource entries do not match the approved archive', { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
-            }
-            const verifiedEntriesByName = new Map(verifiedArchive.materializedEntries.map(entry => [entry.entryName, entry.binary]));
-            const manifestBinary = verifiedEntriesByName.get('manifest.json');
-            if (!manifestBinary) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive has no valid manifest.json', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let manifestValue;
-            try {
-                manifestValue = JSON.parse(new TextDecoder().decode(manifestBinary));
-            }
-            catch (error) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 prepared resource manifest is invalid: ${String(error)}`, { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            const manifest = parseProtocolV2ResourceManifest(manifestValue);
-            const selectedFiles = selectProtocolV2ResourceManifestFiles({
-                manifest,
-                targetsToUpdate: (_d = this.params.targetsToUpdate) !== null && _d !== void 0 ? _d : [],
-            });
-            if (selectedFiles.length > PROTOCOL_V2_RESOURCE_FILE_MAX_COUNT) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive contains too many files', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
-            }
-            let totalSize = 0;
+            const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
+            const descriptors = (_c = release === null || release === void 0 ? void 0 : release.resourceBundles) !== null && _c !== void 0 ? _c : [];
+            const artifactByName = new Map(preparedArtifacts.map(item => [item.name, item.artifact]));
             const sources = [];
-            for (const [index, file] of selectedFiles.entries()) {
-                const binary = verifiedEntriesByName.get(file.archive_path);
-                if (!binary || binary.byteLength !== file.size) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 prepared resource file does not match manifest: ${file.archive_path}`, { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
-                }
-                totalSize += binary.byteLength;
-                if (totalSize > PROTOCOL_V2_RESOURCE_TOTAL_MAX_BYTES) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 prepared resource archive exceeds the total size limit', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared' });
+            for (const descriptor of descriptors) {
+                const artifact = artifactByName.get(descriptor.name);
+                if (!artifact) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 resource bundle ${descriptor.name} is not prepared`, {
+                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                        artifactName: descriptor.name,
+                    });
                 }
-                const source = yield this.openProtocolV2MemorySource(binary);
-                const header = source.size >= PROTOCOL_V2_OKPP_HEADER_SIZE
-                    ? parseProtocolV2OkppHeader(new Uint8Array(yield source.readAt(0, PROTOCOL_V2_OKPP_HEADER_SIZE)))
-                    : null;
-                sources.push(Object.assign({ name: file.original_name || `resource-${index}`, source, devicePath: file.device_path }, (header
-                    ? {
-                        version: header.version,
-                        payloadHash: header.payloadHash,
-                        headerHash: header.headerHash,
-                    }
-                    : {})));
+                const devicePath = validateProtocolV2FilesystemPath(descriptor.devicePath, 'resourceBundles[].devicePath');
+                sources.push({
+                    name: descriptor.name,
+                    source: yield this.openProtocolV2PreparedSource(artifact),
+                    devicePath,
+                    version: descriptor.version,
+                    payloadHash: descriptor.payloadHash,
+                    headerHash: descriptor.headerHash,
+                });
+                artifactByName.delete(descriptor.name);
+            }
+            if (artifactByName.size > 0) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 release does not contain resource bundle ${artifactByName.keys().next().value}`);
             }
             return sources;
         });
@@ -52284,7 +51689,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
                 const installSources = yield this.prepareProtocolV2InstallSources(firmwareType, features);
-                const resourceSources = yield this.prepareProtocolV2ResourceSources();
+                const resourceSources = yield this.prepareProtocolV2ResourceSources(firmwareType, features);
                 if (installSources.length === 0 && resourceSources.length === 0) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
                 }
@@ -52368,15 +51773,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
     }
     getProtocolV2RequestedTargets() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         if ((_a = this.params.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.length) {
             return [...new Set(this.params.targetsToUpdate)];
         }
-        if ((_b = this.params.preparedPlan) === null || _b === void 0 ? void 0 : _b.targetsToUpdate.length) {
-            return [...new Set(this.params.preparedPlan.targetsToUpdate)];
-        }
         const targets = new Set();
-        Object.keys((_c = this.params.componentArtifacts) !== null && _c !== void 0 ? _c : {}).forEach(target => targets.add(target));
+        Object.keys((_b = this.params.componentArtifacts) !== null && _b !== void 0 ? _b : {}).forEach(target => targets.add(target));
+        if (((_c = this.params.resourceBundleArtifacts) === null || _c === void 0 ? void 0 : _c.length) || ((_d = this.params.resourceFiles) === null || _d === void 0 ? void 0 : _d.length)) {
+            targets.add('resource');
+        }
         if (this.params.bootloaderBinary)
             targets.add('boot');
         if (this.params.applicationP1Binary)
@@ -52413,26 +51818,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         const serialNumber = (_b = (_a = deviceInfo.hw) === null || _a === void 0 ? void 0 : _a.serial_no) === null || _b === void 0 ? void 0 : _b.trim();
         return serialNumber || undefined;
     }
-    getProtocolV2PreparedPlanDeviceModel(features) {
-        const currentDeviceType = this.device.getCurrentDeviceType();
-        const featureDeviceType = features ? getDeviceType(features) : undefined;
-        const deviceType = currentDeviceType === hdShared.EDeviceType.Pro2 || currentDeviceType === hdShared.EDeviceType.Neo
-            ? currentDeviceType
-            : featureDeviceType;
-        return deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo
-            ? String(deviceType)
-            : undefined;
-    }
-    getProtocolV2ConnectionRoute() {
-        var _a, _b, _c, _d, _e;
-        const descriptor = this.device.originalDescriptor;
-        return (((_a = descriptor === null || descriptor === void 0 ? void 0 : descriptor.path) === null || _a === void 0 ? void 0 : _a.trim()) ||
-            ((_d = (_c = (_b = this.device).getConnectId) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.trim()) ||
-            ((_e = descriptor === null || descriptor === void 0 ? void 0 : descriptor.id) === null || _e === void 0 ? void 0 : _e.trim()) ||
-            undefined);
-    }
     assertProtocolV2DeviceInfoIdentity(deviceInfo) {
-        assertProtocolV2ReconnectIdentity(this.protocolV2ExpectedSerialNumber, this.getProtocolV2SerialNumber(deviceInfo), this.protocolV2ExpectedPath, this.getProtocolV2ConnectionRoute());
+        assertProtocolV2ReconnectIdentity(this.protocolV2ExpectedSerialNumber, this.getProtocolV2SerialNumber(deviceInfo), this.protocolV2ExpectedPath, this.device.originalDescriptor.path);
     }
     getProtocolV2DeviceInfoTimeout() {
         var _a;
@@ -52449,20 +51836,19 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     captureProtocolV2PhysicalIdentity() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         return __awaiter(this, void 0, void 0, function* () {
             const deviceInfo = yield this.requestProtocolV2PhysicalIdentity();
             const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-            const path = this.getProtocolV2ConnectionRoute();
-            if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.preparedPlan) {
+            const path = ((_b = (_a = this.device.originalDescriptor) === null || _a === void 0 ? void 0 : _a.path) === null || _b === void 0 ? void 0 : _b.trim()) || undefined;
+            if ((_c = this.params) === null || _c === void 0 ? void 0 : _c.preparedPlan) {
                 assertFirmwareUpdatePreparedPlanDeviceIdentity({
                     preparedPlan: this.params.preparedPlan,
                     deviceIdentity: serialNumber,
-                    deviceModel: this.getProtocolV2PreparedPlanDeviceModel(this.device.features),
                 });
             }
-            else if ((_b = this.params) === null || _b === void 0 ? void 0 : _b.expectedDeviceId) {
-                assertProtocolV2ReconnectIdentity((_c = this.params) === null || _c === void 0 ? void 0 : _c.expectedDeviceId, serialNumber);
+            else if ((_d = this.params) === null || _d === void 0 ? void 0 : _d.expectedDeviceId) {
+                assertProtocolV2ReconnectIdentity((_e = this.params) === null || _e === void 0 ? void 0 : _e.expectedDeviceId, serialNumber);
             }
             else {
                 assertProtocolV2ReconnectIdentity(serialNumber, serialNumber, path, path);
@@ -52482,15 +51868,11 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         var _a;
         return (_a = this.params.bootloaderBinary) !== null && _a !== void 0 ? _a : null;
     }
-    getMissingProtocolV2FirmwareTargets(installItems) {
+    hasExplicitProtocolV2Payload(fwBinaryMap) {
         var _a;
-        const preparedTargets = new Set(installItems.flatMap(item => {
-            const target = PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(item.targetId);
-            return target ? [target] : [];
-        }));
-        return ((_a = this.params.targetsToUpdate) !== null && _a !== void 0 ? _a : [])
-            .filter((target) => target !== 'resource' && target !== 'boot_resources')
-            .filter(target => !preparedTargets.has(target));
+        return (!!((_a = this.params.resourceFiles) === null || _a === void 0 ? void 0 : _a.length) ||
+            !!this.params.bootloaderBinary ||
+            fwBinaryMap.length > 0);
     }
     buildProtocolV2InstallItems({ bootloaderBinary, fwBinaryMap, }) {
         const installItems = [];
@@ -52539,17 +51921,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             if (!component.url) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Missing Protocol V2 firmware component url: ${key}/${component.target}`);
             }
-            const expectedFingerprint = normalizeProtocolV2Hex(component.fingerprint);
-            if (!Number.isSafeInteger(component.expectedSize) ||
-                Number(component.expectedSize) <= 0 ||
-                !expectedFingerprint ||
-                !/^[0-9a-f]{64}$/u.test(expectedFingerprint)) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 firmware component integrity metadata is invalid: ${key}/${component.target}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
-            }
             const { binary } = yield getSysResourceBinary(component.url);
-            if (binary.byteLength !== component.expectedSize) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 firmware size mismatch: ${key}/${component.target}`, { firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch' });
-            }
             if (!isProtocolV2FirmwareFingerprintValid(binary, component.fingerprint)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 firmware fingerprint mismatch: ${key}/${component.target}`);
             }
@@ -52563,7 +51935,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return Object.assign(Object.assign({}, target), { binary });
         });
     }
-    prepareRemoteProtocolV2Binaries(firmwareType, features, explicitInstallItems = []) {
+    prepareRemoteProtocolV2Binaries(firmwareType, features) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
@@ -52571,10 +51943,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             const fwBinaryMap = [];
             const installItems = [];
             if (!release) {
-                const missingFirmwareTargets = this.getMissingProtocolV2FirmwareTargets(explicitInstallItems);
-                if (missingFirmwareTargets.length > 0) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 firmware release is unavailable for requested targets: ${missingFirmwareTargets.join(', ')}`);
-                }
                 return {
                     bootloaderBinary,
                     fwBinaryMap,
@@ -52583,8 +51951,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             }
             const entries = this.getRemoteComponentEntries(release);
             const targetsToUpdate = new Set((_a = this.params.targetsToUpdate) !== null && _a !== void 0 ? _a : []);
-            const explicitInstallItemByTargetId = new Map(explicitInstallItems.map(item => [item.targetId, item]));
-            const preparedTargets = new Set();
             for (const [key, component] of entries) {
                 const targetName = (_b = component.target) === null || _b === void 0 ? void 0 : _b.toUpperCase();
                 const target = PROTOCOL_V2_REMOTE_COMPONENT_TARGETS[targetName];
@@ -52592,27 +51958,27 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
                     : undefined;
                 if (updateTarget && targetsToUpdate.has(updateTarget)) {
-                    const explicitInstallItem = explicitInstallItemByTargetId.get(target.targetId);
-                    const installItem = explicitInstallItem !== null && explicitInstallItem !== void 0 ? explicitInstallItem : (yield this.downloadRemoteProtocolV2Component(key, component));
-                    if (installItem.kind === 'bootloader') {
-                        bootloaderBinary = installItem.binary;
+                    const remoteBinary = yield this.downloadRemoteProtocolV2Component(key, component);
+                    if (remoteBinary.kind === 'bootloader') {
+                        bootloaderBinary = remoteBinary.binary;
+                        installItems.push({
+                            fileName: remoteBinary.fileName,
+                            binary: remoteBinary.binary,
+                            targetId: remoteBinary.targetId,
+                            kind: remoteBinary.kind,
+                        });
                     }
                     else {
                         const binaryEntry = {
-                            fileName: installItem.fileName,
-                            binary: installItem.binary,
-                            targetId: installItem.targetId,
+                            fileName: remoteBinary.fileName,
+                            binary: remoteBinary.binary,
+                            targetId: remoteBinary.targetId,
                         };
                         fwBinaryMap.push(binaryEntry);
+                        installItems.push(Object.assign(Object.assign({}, binaryEntry), { kind: remoteBinary.kind }));
                     }
-                    installItems.push(Object.assign({}, installItem));
-                    preparedTargets.add(updateTarget);
                 }
             }
-            const missingTarget = Array.from(targetsToUpdate).find(target => target !== 'resource' && !preparedTargets.has(target));
-            if (missingTarget) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 release does not contain requested target ${missingTarget}`);
-            }
             return {
                 bootloaderBinary,
                 fwBinaryMap,
@@ -52620,6 +51986,178 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             };
         });
     }
+    getProtocolV2DeviceType() {
+        const deviceType = this.device.getCurrentDeviceType();
+        if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo)
+            return deviceType;
+        throw new Error(`Unsupported Protocol V2 device type: ${deviceType}`);
+    }
+    prepareProtocolV2BootResources() {
+        var _a, _b, _c, _d, _e;
+        return __awaiter(this, void 0, void 0, function* () {
+            const wantsStableResources = !!((_a = this.params.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.includes('resource'));
+            const wantsBootResources = !!((_b = this.params.targetsToUpdate) === null || _b === void 0 ? void 0 : _b.includes('boot_resources'));
+            if (!wantsStableResources && !wantsBootResources) {
+                return undefined;
+            }
+            if ((_c = this.params.resourceFiles) === null || _c === void 0 ? void 0 : _c.length) {
+                return undefined;
+            }
+            const resource = DataManager.getProtocolV2BootResources(this.getProtocolV2DeviceType());
+            if (!resource) {
+                if (wantsBootResources) {
+                    throw new Error('Missing Protocol V2 boot resources configuration');
+                }
+                Log$6.debug('[FirmwareUpdateV4] no boot resources configured; continue with stable resources');
+                return undefined;
+            }
+            const files = [];
+            for (const file of resource.files) {
+                const isCurrent = !this.params.forcedUpdateRes && (yield this.isProtocolV2BootResourceCurrent(file));
+                if (isCurrent) {
+                    Log$6.log(`[FirmwareUpdateV4] boot resource unchanged, skipping ${file.devicePath}`);
+                }
+                else {
+                    Log$6.log(`[FirmwareUpdateV4] downloading boot resource ${file.devicePath}`);
+                    const { binary } = yield getSysResourceBinary(file.url);
+                    if (!isProtocolV2ResourceFileValid(binary, file)) {
+                        throw new Error(`Boot resource file verification failed: ${file.devicePath}`);
+                    }
+                    files.push({
+                        name: (_e = (_d = file.name) !== null && _d !== void 0 ? _d : file.devicePath.split('/').pop()) !== null && _e !== void 0 ? _e : file.devicePath,
+                        binary,
+                        devicePath: file.devicePath,
+                    });
+                }
+            }
+            return files;
+        });
+    }
+    isProtocolV2BootResourceCurrent(file) {
+        var _a, _b, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const commands = this.device.getCommands();
+                const pathInfo = yield commands.typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', { path: file.devicePath }, { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT });
+                const size = toProtocolV2FiniteNumber((_a = pathInfo.message) === null || _a === void 0 ? void 0 : _a.size);
+                if (!((_b = pathInfo.message) === null || _b === void 0 ? void 0 : _b.exist) ||
+                    ((_c = pathInfo.message) === null || _c === void 0 ? void 0 : _c.directory) ||
+                    !Number.isSafeInteger(size) ||
+                    size !== file.size) {
+                    return false;
+                }
+                const digest = sha256.sha256.create();
+                const chunkSize = this.getProtocolV2FirmwareChunkSize('write');
+                let offset = 0;
+                while (offset < file.size) {
+                    const response = yield commands.typedCall('FilesystemFileRead', 'FilesystemFile', {
+                        file: { path: file.devicePath, offset, total_size: 0 },
+                        chunk_len: Math.min(chunkSize, file.size - offset),
+                    }, { timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT });
+                    const data = toProtocolV2Bytes((_d = response.message) === null || _d === void 0 ? void 0 : _d.data);
+                    if (data.byteLength === 0)
+                        return false;
+                    const consumed = data.subarray(0, Math.min(data.byteLength, file.size - offset));
+                    digest.update(consumed);
+                    offset += consumed.byteLength;
+                }
+                return bytesToHex(digest.digest()) === normalizeProtocolV2Hex(file.fileHash);
+            }
+            catch (error) {
+                Log$6.debug(`[FirmwareUpdateV4] unable to compare boot resource ${file.devicePath}; scheduling rewrite`, error);
+                return false;
+            }
+        });
+    }
+    mergeProtocolV2ResourceBundles(...groups) {
+        const merged = groups.flatMap(group => group !== null && group !== void 0 ? group : []);
+        if (!merged.length)
+            return undefined;
+        const seenPaths = new Set();
+        for (const bundle of merged) {
+            if (seenPaths.has(bundle.devicePath)) {
+                throw new Error(`Duplicate Protocol V2 resource devicePath: ${bundle.devicePath}`);
+            }
+            seenPaths.add(bundle.devicePath);
+        }
+        return merged;
+    }
+    prepareExplicitProtocolV2ResourceFiles() {
+        var _a;
+        const files = (_a = this.params.resourceFiles) !== null && _a !== void 0 ? _a : [];
+        if (!(files === null || files === void 0 ? void 0 : files.length))
+            return undefined;
+        const prepared = files.map((file, index) => {
+            var _a;
+            const devicePath = validateProtocolV2FilesystemPath(file.devicePath, `resourceFiles[${index}].devicePath`);
+            const descriptor = file;
+            if (descriptor.size !== undefined && descriptor.size !== file.binary.byteLength) {
+                throw new Error(`resourceFiles[${index}] size mismatch`);
+            }
+            if (descriptor.fileHash &&
+                !isProtocolV2ResourceFileValid(file.binary, {
+                    size: file.binary.byteLength,
+                    fileHash: descriptor.fileHash,
+                })) {
+                throw new Error(`resourceFiles[${index}] SHA-256 mismatch`);
+            }
+            return {
+                name: (_a = devicePath.split('/').pop()) !== null && _a !== void 0 ? _a : devicePath,
+                binary: file.binary,
+                devicePath,
+            };
+        });
+        if (new Set(prepared.map(file => file.devicePath)).size !== prepared.length) {
+            throw new Error('resourceFiles contain duplicate devicePath values');
+        }
+        return prepared;
+    }
+    prepareProtocolV2ResourceBundles() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!((_a = this.params.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.includes('resource'))) {
+                return undefined;
+            }
+            const resources = DataManager.getProtocolV2Resources(this.getProtocolV2DeviceType());
+            if (!(resources === null || resources === void 0 ? void 0 : resources.length)) {
+                throw new Error('Missing Pro2 stable resource configuration');
+            }
+            const inventory = this.params.forcedUpdateRes
+                ? undefined
+                : yield readProtocolV2ResourceInventory({
+                    commands: this.device.getCommands(),
+                    resources,
+                    chunkSize: this.getProtocolV2FirmwareChunkSize('write'),
+                    timeoutMs: PROTOCOL_V2_SHORT_RESPONSE_TIMEOUT,
+                });
+            const plan = buildProtocolV2ResourceUpdatePlan({
+                resources,
+                inventory,
+                mode: 'bootloader-recovery',
+                forced: this.params.forcedUpdateRes,
+            });
+            Log$6.log(`[FirmwareUpdateV4] Protocol V2 resource plan mode=bootloader-recovery status=${plan.status} count=${plan.resources.length}`);
+            const bundles = [];
+            for (const resource of plan.resources) {
+                bundles.push(yield this.downloadProtocolV2Resource(resource));
+            }
+            return bundles;
+        });
+    }
+    downloadProtocolV2Resource(resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            Log$6.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 {
+                name: `${resource.type}.okpkg`,
+                binary,
+                devicePath: PROTOCOL_V2_RESOURCE_DEVICE_PATHS[resource.type],
+            };
+        });
+    }
     getProtocolV2ResourceFilePath(path) {
         if (path.startsWith('vol'))
             return path;
@@ -52627,7 +52165,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return `vol0:${path}`;
         return `vol0:/${path}`;
     }
-    readProtocolV2DeviceFileHeader(path, expectedSize) {
+    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());
@@ -52639,8 +52177,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             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 ||
-                (expectedSize !== undefined && fileSize !== expectedSize)) {
+                fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE) {
                 return null;
             }
             const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
@@ -52677,10 +52214,10 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return __awaiter(this, void 0, void 0, function* () {
             if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.forcedUpdateRes)
                 return false;
-            if (!bundle.payloadHash || !bundle.headerHash)
+            if (!bundle.version && !bundle.payloadHash)
                 return false;
             try {
-                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath, bundle.source.size);
+                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath);
                 if (!header)
                     return false;
                 if (bundle.version) {
@@ -52688,12 +52225,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     if (cmp === undefined || cmp !== 0)
                         return false;
                 }
-                const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
-                const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
-                if (!expectedPayloadHash || header.payloadHash !== expectedPayloadHash)
-                    return false;
-                if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash)
-                    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) {
@@ -52808,6 +52349,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     buildProtocolV2ExecutionPhases({ installSources, resourceSources, }) {
         const phases = [];
+        if (resourceSources.length > 0) {
+            phases.push({
+                kind: 'resource-sync',
+                installSources: [],
+                resourceSources,
+            });
+        }
         const bootloaderSources = installSources.filter(source => source.kind === 'bootloader');
         if (bootloaderSources.length > 0) {
             phases.push({
@@ -52820,13 +52368,6 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 resourceSources: [],
             });
         }
-        if (resourceSources.length > 0) {
-            phases.push({
-                kind: 'resource-sync',
-                installSources: [],
-                resourceSources,
-            });
-        }
         const componentSources = installSources.filter(source => source.kind !== 'bootloader');
         if (componentSources.length > 0) {
             phases.push({
@@ -52877,7 +52418,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             });
         });
     }
-    executeProtocolV2Update({ fwBinaryMap, bootloaderBinary, installItems, }) {
+    executeProtocolV2Update({ fwBinaryMap, bootloaderBinary, installItems, resourceBundles, }) {
         return __awaiter(this, void 0, void 0, function* () {
             const memoryInstallItems = installItems !== null && installItems !== void 0 ? installItems : this.buildProtocolV2InstallItems({
                 fwBinaryMap: fwBinaryMap !== null && fwBinaryMap !== void 0 ? fwBinaryMap : [],
@@ -52892,9 +52433,16 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                         kind: item.kind,
                     });
                 })));
+                const resourceSources = yield Promise.all((resourceBundles !== null && resourceBundles !== void 0 ? resourceBundles : []).map((bundle) => __awaiter(this, void 0, void 0, function* () {
+                    return ({
+                        name: bundle.name,
+                        source: yield this.openProtocolV2MemorySource(bundle.binary),
+                        devicePath: bundle.devicePath,
+                    });
+                })));
                 return yield this.executeProtocolV2Phases({
                     installSources,
-                    resourceSources: [],
+                    resourceSources,
                 });
             }
             finally {
@@ -52918,14 +52466,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             this.postTipMessage(exports.FirmwareUpdateTipMessage.StartTransferData);
             let processedSize = 0;
             for (const resource of resourcesToSync) {
-                const writePath = resolveProtocolV2ResourceWritePath(resource.devicePath);
                 processedSize = yield this.protocolV2SourceUpdateProcess({
                     source: resource.source,
-                    filePath: writePath,
+                    filePath: resource.devicePath,
                     processedSize,
                     totalSize,
                 });
-                yield this.verifyProtocolV2StagedFile(writePath, resource.source.size);
+                yield this.verifyProtocolV2StagedFile(resource.devicePath, resource.source.size);
             }
             const stagedInstallTargets = [];
             for (const item of installSources) {
@@ -53915,7 +53462,7 @@ class DeviceUploadWallpaper extends BaseMethod {
 }
 
 const FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE = 60802;
-const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$1 = 60805;
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
 const FILESYSTEM_DIR_LIST_MESSAGE_TYPE = 60808;
 const NFT_UPDATE_MESSAGE_TYPE = 61500;
 class DeviceUploadNft extends BaseMethod {
@@ -53944,7 +53491,7 @@ class DeviceUploadNft extends BaseMethod {
     assertCapabilities() {
         return __awaiter(this, void 0, void 0, function* () {
             const protocolInfo = yield this.device.ensureProtocolV2RuntimeContext();
-            const hasFileWrite = supportsProtocolV2Message(protocolInfo, FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$1);
+            const hasFileWrite = supportsProtocolV2Message(protocolInfo, FILESYSTEM_FILE_WRITE_MESSAGE_TYPE);
             const hasPathInfo = supportsProtocolV2Message(protocolInfo, FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE);
             const hasDirList = supportsProtocolV2Message(protocolInfo, FILESYSTEM_DIR_LIST_MESSAGE_TYPE);
             const hasNftUpdate = supportsProtocolV2Message(protocolInfo, NFT_UPDATE_MESSAGE_TYPE);
@@ -54079,8 +53626,6 @@ class FileWrite extends BaseMethod {
 
 const PORTFOLIO_PENDING_PATH = 'vol1:/portfolio/portfolio.okpkg.pending';
 const PORTFOLIO_CHUNK_SIZE = 2048;
-const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
-const PORTFOLIO_UPDATE_MESSAGE_TYPE = 61400;
 class UploadPortfolio extends FileWrite {
     init() {
         const { packageBytes, timeoutMs } = this.payload;
@@ -54094,12 +53639,6 @@ class UploadPortfolio extends FileWrite {
             run: { get: () => super.run }
         });
         return __awaiter(this, void 0, void 0, function* () {
-            const protocolInfo = yield this.device.ensureProtocolV2RuntimeContext();
-            const hasFileWrite = supportsProtocolV2Message(protocolInfo, FILESYSTEM_FILE_WRITE_MESSAGE_TYPE);
-            const hasPortfolioUpdate = supportsProtocolV2Message(protocolInfo, PORTFOLIO_UPDATE_MESSAGE_TYPE);
-            if (!hasFileWrite || !hasPortfolioUpdate) {
-                throw hdShared.createDeviceNotSupportMethodError(this.name, this.device.getCurrentFirmwareType());
-            }
             const stagedFile = yield _super.run.call(this);
             this.throwIfAborted();
             yield this.device.commands.typedCall('PortfolioUpdate', 'Success', {});
@@ -65641,14 +65180,11 @@ exports.normalizeSafetyCheckLevel = normalizeSafetyCheckLevel;
 exports.normalizeVersionArray = normalizeVersionArray;
 exports.parseConnectSettings = parseConnectSettings;
 exports.parseMessage = parseMessage;
-exports.parseProtocolV2ResourceManifest = parseProtocolV2ResourceManifest;
 exports.patchFeatures = patchFeatures;
 exports.preloadSessionCache = preloadSessionCache;
-exports.prepareFirmwareUpdateV4MemoryHost = prepareFirmwareUpdateV4MemoryHost;
 exports.projectDeviceStateFeatures = projectFeatures;
 exports.registerFirmwareUpdateHostBinding = registerFirmwareUpdateHostBinding;
 exports.safeThrowError = safeThrowError;
-exports.selectProtocolV2ResourceManifestFiles = selectProtocolV2ResourceManifestFiles;
 exports.setLoggerPostMessage = setLoggerPostMessage;
 exports.supportInputPinOnSoftware = supportInputPinOnSoftware;
 exports.switchTransport = switchTransport;