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

package/dist/index.js

@@ -522,6 +522,10 @@ 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;
@@ -591,6 +595,16 @@ const planError = (message) => {
         firmwareUpdateCode: 'FirmwarePlanInvalid',
     });
 };
+const requireArtifactIntegrity = (input, label) => {
+    const integrity = asIntegrity(input);
+    if (integrity.expectedSize === undefined || integrity.expectedSha256 === undefined) {
+        return planError(`${label} integrity metadata is invalid`);
+    }
+    return {
+        expectedSize: integrity.expectedSize,
+        expectedSha256: integrity.expectedSha256,
+    };
+};
 const FIRMWARE_UPDATE_PLAN_FORCE_TARGETS = new Set([
     'firmware',
     'ble',
@@ -609,6 +623,18 @@ 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)) ||
@@ -689,7 +715,7 @@ const assertFirmwareUpdatePlan = (value) => {
         if (!artifact) {
             return planError('Firmware update plan artifact is invalid');
         }
-        assertExactKeys(artifact, ['artifactId', 'role', 'target', 'url', 'container'], ['logicalName', 'expectedSize', 'expectedSha256', 'targetVersion']);
+        assertExactKeys(artifact, ['artifactId', 'role', 'target', 'url', 'container', 'expectedSize', 'expectedSha256'], ['logicalName', 'targetVersion']);
         const artifactId = assertBoundedString(artifact.artifactId, 'artifact id', 160);
         if (artifactIds.has(artifactId)) {
             return planError('Firmware update plan contains duplicate artifact ids');
@@ -705,13 +731,11 @@ const assertFirmwareUpdatePlan = (value) => {
         if (artifact.logicalName !== undefined) {
             assertBoundedString(artifact.logicalName, 'logical name', 256);
         }
-        if (artifact.expectedSize !== undefined &&
-            (!Number.isSafeInteger(artifact.expectedSize) || artifact.expectedSize <= 0)) {
+        if (!Number.isSafeInteger(artifact.expectedSize) || artifact.expectedSize <= 0) {
             return planError('Firmware update plan artifact size is invalid');
         }
-        if (artifact.expectedSha256 !== undefined &&
-            (typeof artifact.expectedSha256 !== 'string' ||
-                !/^[a-f0-9]{64}$/u.test(artifact.expectedSha256))) {
+        if (typeof artifact.expectedSha256 !== 'string' ||
+            !/^[a-f0-9]{64}$/u.test(artifact.expectedSha256)) {
             return planError('Firmware update plan artifact digest is invalid');
         }
         if (artifact.targetVersion !== undefined) {
@@ -738,7 +762,7 @@ const assertFirmwareUpdatePlan = (value) => {
             plan.targetsToUpdate.some(target => legacyOnlyTargets.has(target))) ||
         (plan.artifacts.length > 0 &&
             (plan.platform === 'native' || plan.platform === 'desktop') &&
-            plan.executor !== 'v2' &&
+            plan.executor === 'v3' &&
             plan.deviceIdentity === 'unavailable')) {
         return planError('Firmware update plan executor contract is invalid');
     }
@@ -773,7 +797,7 @@ const selectResourceUrl = ({ release, features, platform, }) => {
 };
 const getExecutor = (features) => {
     const deviceType = getDeviceType(features);
-    if (deviceType === hdShared.EDeviceType.Pro2) {
+    if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) {
         return 'v4';
     }
     if (deviceType === hdShared.EDeviceType.Pro &&
@@ -782,7 +806,7 @@ const getExecutor = (features) => {
     }
     return 'v2';
 };
-const buildProtocolV2Artifacts = (release, { includeComponents = true, includeResources = true, } = {}) => {
+const buildProtocolV2Artifacts = (release, { includeComponents = true, componentTargets: selectedComponentTargets, } = {}) => {
     var _a;
     const components = asRecord(release.components);
     if (includeComponents && !components) {
@@ -794,49 +818,36 @@ const buildProtocolV2Artifacts = (release, { includeComponents = true, includeRe
     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 componentTargets = new Set();
-    for (const key of componentKeys) {
+    const componentTargetSet = new Set();
+    for (const key of selectedComponentKeys) {
         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 (componentTargets.has(target)) {
+        if (componentTargetSet.has(target)) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Protocol V2 component ${key} duplicates target ${target}`, { firmwareUpdateCode: 'FirmwarePlanInvalid' });
         }
-        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,
-        })), (asVersion(component.version) ? { targetVersion: asVersion(component.version) } : {})));
+        componentTargetSet.add(target);
+        const integrity = requireArtifactIntegrity({ size: component.expectedSize, sha256: component.fingerprint }, `Protocol V2 component ${key}`);
+        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) } : {})));
         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, }) => {
@@ -865,8 +876,91 @@ 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 = requireArtifactIntegrity({ size: archive.archiveSize, sha256: archive.archiveSha256 }, 'Protocol V2 resource archive');
+        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;
+    var _a, _b;
     const executor = getExecutor(features);
     let artifacts = [];
     let targetsToUpdate = [];
@@ -878,7 +972,8 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
         ((release === null || release === void 0 ? void 0 : release.status) === 'none' || (release === null || release === void 0 ? void 0 : release.status) === 'unknown') &&
         !!asRelease(release);
     const shouldUpdateFirmware = isUpgrade(firmware) || isRecoveryInstall(firmware) || forcedTargets.has('firmware');
-    const shouldUpdateResource = isUpgrade(firmware) || forcedTargets.has('resource');
+    const shouldUpdateResource = !(executor === 'v2' && bootloaderMode) &&
+        (isUpgrade(firmware) || forcedTargets.has('resource'));
     if (executor === 'v4' &&
         validatedForceTargets.some(target => target === 'ble' || target === 'bootloader')) {
         planError('Protocol V2 does not support forced BLE or legacy bootloader targets');
@@ -886,19 +981,20 @@ 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;
     }
     else {
         if (isUpgrade(bootloader) || forcedTargets.has('bootloader')) {
-            artifacts.push(Object.assign(Object.assign({ artifactId: 'bootloader', role: 'bootloader', target: 'bootloader', url: assertArtifactUrl((_a = asRelease(bootloader)) === null || _a === void 0 ? void 0 : _a.bootloaderResource, 'Bootloader release'), container: 'raw' }, asIntegrity({
-                size: (_b = asRelease(bootloader)) === null || _b === void 0 ? void 0 : _b.bootloaderExpectedSize,
-                sha256: (_c = asRelease(bootloader)) === null || _c === void 0 ? void 0 : _c.bootloaderFingerprint,
-            })), (asVersion((_d = asRelease(bootloader)) === null || _d === void 0 ? void 0 : _d.bootloaderVersion)
+            const bootloaderRelease = asRelease(bootloader);
+            const integrity = requireArtifactIntegrity({
+                size: bootloaderRelease === null || bootloaderRelease === void 0 ? void 0 : bootloaderRelease.bootloaderExpectedSize,
+                sha256: bootloaderRelease === null || bootloaderRelease === void 0 ? void 0 : bootloaderRelease.bootloaderFingerprint,
+            }, 'Bootloader release');
+            artifacts.push(Object.assign(Object.assign({ artifactId: 'bootloader', role: 'bootloader', target: 'bootloader', url: assertArtifactUrl(bootloaderRelease === null || bootloaderRelease === void 0 ? void 0 : bootloaderRelease.bootloaderResource, 'Bootloader release'), container: 'raw' }, integrity), (asVersion(bootloaderRelease === null || bootloaderRelease === void 0 ? void 0 : bootloaderRelease.bootloaderVersion)
                 ? {
-                    targetVersion: asVersion((_e = asRelease(bootloader)) === null || _e === void 0 ? void 0 : _e.bootloaderVersion),
+                    targetVersion: asVersion(bootloaderRelease === null || bootloaderRelease === void 0 ? void 0 : bootloaderRelease.bootloaderVersion),
                 }
                 : {})));
         }
@@ -909,10 +1005,8 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
                 });
             }
             if (shouldUpdateFirmware) {
-                artifacts.push(Object.assign(Object.assign({ artifactId: 'firmware', role: 'firmware', target: 'firmware', url: assertArtifactUrl(firmwareRelease.url, 'Firmware release'), container: 'raw' }, asIntegrity({
-                    size: firmwareRelease.expectedSize,
-                    sha256: firmwareRelease.fingerprint,
-                })), (asVersion(firmwareRelease.version)
+                const integrity = requireArtifactIntegrity({ size: firmwareRelease.expectedSize, sha256: firmwareRelease.fingerprint }, 'Firmware release');
+                artifacts.push(Object.assign(Object.assign({ artifactId: 'firmware', role: 'firmware', target: 'firmware', url: assertArtifactUrl(firmwareRelease.url, 'Firmware release'), container: 'raw' }, integrity), (asVersion(firmwareRelease.version)
                     ? { targetVersion: asVersion(firmwareRelease.version) }
                     : {})));
             }
@@ -923,23 +1017,25 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
                     platform,
                 });
                 if (resourceUrl) {
-                    artifacts.push(Object.assign({ artifactId: 'resource', role: 'resource', target: 'resource', url: assertArtifactUrl(resourceUrl, 'Firmware resource release'), container: 'zip' }, asIntegrity({
+                    const integrity = requireArtifactIntegrity({
                         size: resourceUrl === asString(firmwareRelease.fullResource)
                             ? firmwareRelease.fullResourceExpectedSize
                             : firmwareRelease.resourceExpectedSize,
                         sha256: resourceUrl === asString(firmwareRelease.fullResource)
                             ? firmwareRelease.fullResourceFingerprint
                             : firmwareRelease.resourceFingerprint,
-                    })));
+                    }, 'Legacy resource archive');
+                    artifacts.push(Object.assign({ artifactId: 'resource', role: 'resource', target: 'resource', url: assertArtifactUrl(resourceUrl, 'Firmware resource release'), container: 'zip' }, integrity));
                 }
             }
         }
         if (isUpgrade(ble) || isRecoveryInstall(ble) || forcedTargets.has('ble')) {
             const bleRelease = asRelease(ble);
-            artifacts.push(Object.assign(Object.assign({ artifactId: 'ble', role: 'ble', target: 'ble', url: assertArtifactUrl((_f = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.webUpdate) !== null && _f !== void 0 ? _f : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.url, 'BLE release'), container: 'raw' }, asIntegrity({
+            const integrity = requireArtifactIntegrity({
                 size: bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.expectedSize,
-                sha256: (_g = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.fingerprintWeb) !== null && _g !== void 0 ? _g : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.fingerprint,
-            })), (asVersion(bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.version)
+                sha256: (_a = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.fingerprintWeb) !== null && _a !== void 0 ? _a : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.fingerprint,
+            }, 'BLE release');
+            artifacts.push(Object.assign(Object.assign({ artifactId: 'ble', role: 'ble', target: 'ble', url: assertArtifactUrl((_b = bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.webUpdate) !== null && _b !== void 0 ? _b : bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.url, 'BLE release'), container: 'raw' }, integrity), (asVersion(bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.version)
                 ? { targetVersion: asVersion(bleRelease === null || bleRelease === void 0 ? void 0 : bleRelease.version) }
                 : {})));
         }
@@ -951,25 +1047,13 @@ const buildFirmwareUpdatePlan = ({ features, firmwareType, platform, firmware, b
         artifacts,
         targetsToUpdate,
     });
-    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)),
+    return finalizeFirmwareUpdatePlan({
+        features,
         firmwareType,
         platform,
         artifacts,
         targetsToUpdate,
-    };
-    return assertFirmwareUpdatePlan(Object.assign(Object.assign({}, planWithoutDigest), { planDigest: digestFirmwareUpdatePlan(planWithoutDigest) }));
+    });
 };
 
 const preparedPlanError = (message) => {
@@ -1090,7 +1174,7 @@ const prepareFirmwareUpdatePlan = ({ plan: value, leaseRef, artifacts, }) => {
     return Object.assign(Object.assign({}, planWithoutDigest), { preparedPlanDigest: digestPreparedPlan(planWithoutDigest) });
 };
 const validateFirmwareUpdatePreparedPlan = (value) => {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     if (!value || typeof value !== 'object' || Array.isArray(value)) {
         return preparedPlanError('Firmware prepared plan must be an object');
     }
@@ -1170,7 +1254,13 @@ const validateFirmwareUpdatePreparedPlan = (value) => {
         artifactIds.add(artifact.artifactId);
         artifactTargets.add(artifact.target);
         assertFirmwareArtifactReference(artifact.artifact);
-        (_c = artifact.materializedEntries) === null || _c === void 0 ? void 0 : _c.forEach(assertPreparedEntry);
+        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');
+        }
     }
     if (preparedPlan.targetsToUpdate.some(target => !FIRMWARE_UPDATE_PLAN_TARGETS.has(target)) ||
         new Set(preparedPlan.targetsToUpdate).size !== preparedPlan.targetsToUpdate.length ||
@@ -1184,6 +1274,14 @@ const validateFirmwareUpdatePreparedPlan = (value) => {
     }
     return preparedPlan;
 };
+const getFirmwareUpdatePreparedRawArtifact = ({ preparedPlan: value, target, role, }) => {
+    const preparedPlan = validateFirmwareUpdatePreparedPlan(value);
+    const artifacts = preparedPlan.artifacts.filter(artifact => artifact.target === target);
+    if (artifacts.length !== 1 || artifacts[0].role !== role || artifacts[0].container !== 'raw') {
+        return preparedPlanError(`Firmware prepared plan ${target} artifact is invalid`);
+    }
+    return artifacts[0];
+};
 const degradedPlanIdentityPins = new Map();
 const DEGRADED_PLAN_IDENTITY_PIN_LIMIT = 32;
 const pinDegradedPlanIdentity = (leaseRef, deviceIdentity) => {
@@ -1204,7 +1302,7 @@ const assertFirmwareUpdatePreparedPlanDeviceIdentity = ({ preparedPlan: value, d
         }
         const pinnedIdentity = degradedPlanIdentityPins.get(preparedPlan.leaseRef);
         if (!deviceIdentity) {
-            if (bootloaderMode !== true) {
+            if (preparedPlan.executor !== 'v4' && bootloaderMode !== true) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.DeviceCheckDeviceIdError);
             }
             return preparedPlan;
@@ -1277,6 +1375,8 @@ 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') {
@@ -1297,7 +1397,7 @@ class FirmwareHostBindingRegistry {
     getGeneration() {
         return this.generation;
     }
-    resolve(generation) {
+    resolve(generation, preparedPlanDigest) {
         if (!Number.isSafeInteger(generation) ||
             generation <= 0 ||
             generation !== this.generation ||
@@ -1305,12 +1405,17 @@ 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();
@@ -1343,7 +1448,7 @@ const firmwareHostBindingRegistry = new FirmwareHostBindingRegistry();
 const registerFirmwareUpdateHostBinding = (binding) => firmwareHostBindingRegistry.register(binding);
 const unregisterFirmwareUpdateHostBinding = (generation) => firmwareHostBindingRegistry.unregister(generation);
 const getFirmwareUpdateHostBindingGeneration = () => firmwareHostBindingRegistry.getGeneration();
-const resolveFirmwareUpdateHostBinding = (generation) => firmwareHostBindingRegistry.resolve(generation !== null && generation !== void 0 ? generation : Number.NaN);
+const resolveFirmwareUpdateHostBinding = (generation, preparedPlanDigest) => firmwareHostBindingRegistry.resolve(generation !== null && generation !== void 0 ? generation : Number.NaN, preparedPlanDigest);
 
 const callbackManager = new Map();
 const generateCallbackId = () => `callback_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
@@ -40504,143 +40609,8 @@ const findLatestRelease = (releases) => {
     return leastRelease;
 };
 
-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 PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1 = 'vol0:/loaders/bootloader/boot_resource.okpkg';
 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`);
@@ -40651,132 +40621,158 @@ function normalizeHex$1(value, expectedLength, field) {
     }
     return normalized;
 }
-function validateResource(value, index) {
+function parseProtocolV2Resources(value) {
+    if (value === undefined)
+        return undefined;
     if (!value || typeof value !== 'object') {
-        throw new Error(`Invalid Pro2 resource at stable[${index}]`);
+        throw new Error('Invalid Pro2 resources config');
     }
-    const resource = value;
-    if (typeof resource.type !== 'string' || !RESOURCE_TYPE_SET.has(resource.type)) {
-        throw new Error(`Invalid Pro2 resource type at stable[${index}]`);
+    const { source } = value;
+    if (!source || typeof source !== 'object') {
+        throw new Error('Invalid Pro2 resources config: source is required');
     }
-    if (typeof resource.url !== 'string' || !resource.url.startsWith('https://')) {
-        throw new Error(`Invalid Pro2 resource url 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');
     }
-    if (!Number.isSafeInteger(resource.size) || Number(resource.size) <= 0) {
-        throw new Error(`Invalid Pro2 resource size 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 (!Number.isSafeInteger(archiveSize) || archiveSize <= 0) {
+        throw new Error('Invalid Pro2 resources config: source.archiveSize must be a positive integer');
     }
     return {
-        type: resource.type,
-        url: resource.url,
-        size: Number(resource.size),
-        fileHash: normalizeHex$1(resource.fileHash, SHA256_HEX_LENGTH, 'fileHash'),
-        headerHash: normalizeHex$1(resource.headerHash, SHA3_512_HEX_LENGTH, 'headerHash'),
+        source: {
+            archiveUrl,
+            archiveSha256: archiveSha256.toLowerCase(),
+            archiveSize: archiveSize,
+        },
     };
 }
-function validateBootResources(value) {
-    if (!value || typeof value !== 'object') {
-        throw new Error('Invalid Pro2 boot resources config');
+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;
     }
-    const resource = value;
-    if (resource.required !== false) {
-        throw new Error('Invalid Pro2 boot resources required flag: expected false');
+    if (path === PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH$1) {
+        return true;
     }
-    if (resource.target !== 'RES') {
-        throw new Error('Invalid Pro2 boot resources target: expected RES');
+    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.manifestUrl !== undefined &&
-        (typeof resource.manifestUrl !== 'string' || !resource.manifestUrl.startsWith('https://'))) {
-        throw new Error('Invalid Pro2 boot resources manifestUrl');
+    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 (!Array.isArray(resource.files) || resource.files.length === 0) {
-        throw new Error('Invalid Pro2 boot resources files');
+    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`);
     }
-    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');
+    const devicePath = assertManifestString(file.device_path, `files[${index}].device_path`);
+    if (!isAllowedManifestDevicePath(devicePath)) {
+        throw new Error(`Invalid Pro2 resource manifest files[${index}].device_path`);
     }
-    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');
+    if (!Number.isSafeInteger(file.size) || Number(file.size) <= 0) {
+        throw new Error(`Invalid Pro2 resource manifest files[${index}].size`);
     }
-    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`);
+    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`);
     }
-    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.sig_algo !== 'ed25519' && file.sig_algo !== 'mldsa65') {
+        throw new Error(`Invalid Pro2 resource manifest files[${index}].sig_algo`);
     }
-    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 (file.payload_version !== null && typeof file.payload_version !== 'string') {
+        throw new Error(`Invalid Pro2 resource manifest files[${index}].payload_version`);
     }
-    if (!inventory) {
-        return mode === 'bootloader-recovery'
-            ? {
-                status: resources.length > 0 ? 'outdated' : 'valid',
-                resources: [...resources],
-            }
-            : { status: 'unknown', resources: [] };
+    if (!archivePath.endsWith('.okpkg') || !originalName.endsWith('.okpkg')) {
+        throw new Error(`Invalid Pro2 resource manifest files[${index}] package extension`);
     }
-    const inventoryByType = new Map(inventory.map(item => [item.type, item]));
-    const changedResources = resources.filter(resource => {
-        const current = inventoryByType.get(resource.type);
-        return (!current ||
-            current.size !== resource.size ||
-            current.headerHash.toLowerCase() !== resource.headerHash.toLowerCase());
-    });
     return {
-        status: changedResources.length === 0 ? 'valid' : 'outdated',
-        resources: changedResources,
+        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,
     };
 }
-function bytesToHex$3(bytes) {
-    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+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 isProtocolV2ResourceFileValid(binary, resource) {
-    if (binary.byteLength !== resource.size)
-        return false;
-    return bytesToHex$3(sha256.sha256(new Uint8Array(binary))) === resource.fileHash.toLowerCase();
+function selectProtocolV2ResourceManifestFiles({ manifest, targetsToUpdate, }) {
+    return targetsToUpdate.includes('resource') ? [...manifest.files] : [];
 }
 
 var _a$1;
@@ -40837,6 +40833,7 @@ 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);
@@ -40897,12 +40894,19 @@ class DataManager {
         let neoResources;
         try {
             pro2Resources = parseProtocolV2Resources((_b = data.pro2) === null || _b === void 0 ? void 0 : _b.resources);
-            neoResources = parseProtocolV2Resources((_c = data.neo) === null || _c === void 0 ? void 0 : _c.resources);
         }
         catch (error) {
             this.protocolV2ResourcesConfigError =
                 error instanceof Error ? error : new Error(String(error));
-            Log$k.warn('[DataConfig] Ignoring invalid Protocol V2 resources config:', 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 =
+                error instanceof Error ? error : new Error(String(error));
+            Log$k.warn('[DataConfig] Ignoring invalid Neo resources config:', error);
         }
         const enrichedPro2Config = this.enrichFirmwareReleaseInfo(data.pro2);
         const enrichedNeoConfig = this.enrichFirmwareReleaseInfo(data.neo);
@@ -40940,16 +40944,20 @@ class DataManager {
             }
         });
     }
-    static forceReloadData({ requireResources = false, } = {}) {
+    static forceReloadData({ requireResources = false, resourceDeviceType = hdShared.EDeviceType.Pro2, } = {}) {
         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) {
-                if (requireResources && this.protocolV2ResourcesConfigError) {
-                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`);
+                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}`);
                 }
                 return;
             }
@@ -40957,19 +40965,18 @@ class DataManager {
             if (!loaded) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.NetworkError, 'Unable to refresh the latest remote config');
             }
-            if (requireResources && this.protocolV2ResourcesConfigError) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, `Invalid Pro2 resources config: ${this.protocolV2ResourcesConfigError.message}`);
+            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}`);
             }
             this.lastCheckTimestamp = getTimeStamp();
         });
     }
-    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) {
+    static getProtocolV2ResourceSource(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.boot;
+        return (_c = (_b = this.deviceMap[deviceType]) === null || _b === void 0 ? void 0 : _b.resources) === null || _c === void 0 ? void 0 : _c.source;
     }
     static getProtobufMessages(schema = 'v1CurrentSchema') {
         return this.messages[schema];
@@ -41006,12 +41013,10 @@ DataManager.deviceMap = {
         ble: [],
     },
     [hdShared.EDeviceType.Pro2]: {
-        firmware: [],
-        ble: [],
+        'firmware-v1': [],
     },
     [hdShared.EDeviceType.Neo]: {
-        firmware: [],
-        ble: [],
+        'firmware-v1': [],
     },
     [hdShared.EDeviceType.ClassicPure]: {
         firmware: [],
@@ -42008,7 +42013,7 @@ const getFirmwareUpdateField = ({ features, updateType, targetVersion, firmwareT
     if (deviceType === hdShared.EDeviceType.Pro) {
         return latestFirmwareField;
     }
-    if (deviceType === hdShared.EDeviceType.Pro2) {
+    if (deviceType === hdShared.EDeviceType.Pro2 || deviceType === hdShared.EDeviceType.Neo) {
         return 'firmware-v1';
     }
     return 'firmware';
@@ -42040,7 +42045,7 @@ const getFirmwareUpdateFieldArray = (features, updateType) => {
     if (deviceType === 'pro') {
         return ['firmware-v8'];
     }
-    if (deviceType === 'pro2') {
+    if (deviceType === 'pro2' || deviceType === 'neo') {
         return ['firmware-v1'];
     }
     return ['firmware'];
@@ -47383,76 +47388,93 @@ class ClearSessionCache extends BaseMethod {
     }
 }
 
-class CheckFirmwareRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [
-            ...this.allowDeviceMode,
-            UI_REQUEST.NOT_INITIALIZE,
-            UI_REQUEST.BOOTLOADER,
-        ];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
-    }
-    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);
+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`);
         }
-        return Promise.resolve(null);
-    }
+        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),
+        };
+    });
 }
-
-class CheckBLEFirmwareRelease extends BaseMethod {
-    init() {
-        this.allowDeviceMode = [
-            ...this.allowDeviceMode,
-            UI_REQUEST.NOT_INITIALIZE,
-            UI_REQUEST.BOOTLOADER,
-        ];
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
+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';
     }
-    run() {
-        if (this.device.features) {
-            const releaseInfo = getBleFirmwareReleaseInfo(this.device.features);
-            return Promise.resolve(releaseInfo);
-        }
-        return Promise.resolve(null);
+    else if (required) {
+        status = 'required';
+    }
+    else if (hasUpgrade) {
+        status = 'outdated';
+    }
+    else if (components.some(component => component.status === 'unknown')) {
+        status = 'unknown';
+    }
+    else if (components.every(component => component.status === 'unsupported')) {
+        status = 'unavailable';
     }
+    return Object.assign(Object.assign({}, plan), { status,
+        hasUpgrade,
+        required,
+        components,
+        targetsToUpdate });
 }
-
-class CheckBridgeStatus extends BaseMethod {
-    init() {
-        this.useDevice = false;
-        this.useDevicePassphraseState = false;
-        this.skipForceUpdateCheck = true;
+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;
     }
-    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);
-                    }
-                });
-            });
-        });
+    const component = (_a = plan.release.components) === null || _a === void 0 ? void 0 : _a[componentRelease.configKey];
+    if (!component) {
+        return undefined;
     }
+    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';
@@ -47509,56 +47531,6 @@ 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',
@@ -47806,22 +47778,15 @@ class CheckAllFirmwareRelease extends BaseMethod {
     runProtocolV2() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const { checkFirmwareHash = false, firmwareType: firmwareTypeParam } = this
-                .payload;
-            const state = yield this.device.getDeviceState({
-                refreshSections: checkFirmwareHash
-                    ? ['identity', 'versions', 'verification']
-                    : ['identity', 'versions'],
+            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',
             });
-            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,
@@ -47831,48 +47796,250 @@ class CheckAllFirmwareRelease extends BaseMethod {
                 deviceType: state.identity.deviceType,
             });
             const resourceDeviceType = state.identity.deviceType === 'neo' ? hdShared.EDeviceType.Neo : hdShared.EDeviceType.Pro2;
-            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;
+            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));
                     }
-                    catch (_b) {
-                        resourceStatus = buildProtocolV2ResourceUpdatePlan({
-                            resources,
-                            mode: 'bootloader-recovery',
-                        }).status;
+                    else {
+                        resolve(false);
                     }
-                }
+                });
+            });
+        });
+    }
+}
+
+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 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 });
+            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);
         });
     }
 }
@@ -49619,35 +49786,52 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
         });
     }
     run() {
-        var _a, _b, _c;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const { device } = this;
             const { features } = device;
             const payload = this.payload;
-            const hostBinding = payload.artifact
-                ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+            const hasPreparedPlan = payload.preparedPlan !== undefined;
+            if (hasPreparedPlan && payload.binary !== undefined) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Prepared bootloader plans cannot be combined with a legacy binary');
+            }
+            if (!hasPreparedPlan && payload.artifact !== undefined) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Bootloader artifacts require a prepared plan');
+            }
+            const preparedPlan = hasPreparedPlan
+                ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
                 : undefined;
-            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) {
+            const plannedArtifact = preparedPlan
+                ? getFirmwareUpdatePreparedRawArtifact({
+                    preparedPlan,
+                    target: 'bootloader',
+                    role: 'bootloader',
+                }).artifact
+                : undefined;
+            const artifactReader = preparedPlan
+                ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration, preparedPlan.preparedPlanDigest).artifactReader
+                : payload.artifactReader;
+            const executionParams = Object.assign(Object.assign({}, payload), { artifactReader });
+            if (preparedPlan && plannedArtifact) {
                 assertFirmwareUpdatePreparedPlanDeviceIdentity({
-                    preparedPlan: payload.preparedPlan,
+                    preparedPlan,
                     deviceIdentity: getDeviceUUID(features) || undefined,
                     bootloaderMode: resolveDeviceBootloaderMode(features),
                     deviceModel: String(getDeviceType(features)),
                 });
                 assertFirmwareUpdatePreparedPlanBinding({
-                    preparedPlan: payload.preparedPlan,
+                    preparedPlan,
                     executor: 'v2',
                     scopeTargets: ['bootloader'],
                     bindings: [
                         {
                             target: 'bootloader',
-                            artifact: payload.artifact,
+                            artifact: (_a = payload.artifact) !== null && _a !== void 0 ? _a : plannedArtifact,
                         },
                     ],
                 });
                 const source = yield openFirmwareByteSource({
-                    artifact: payload.artifact,
+                    artifact: plannedArtifact,
                     reader: executionParams.artifactReader,
                 });
                 if (!source) {
@@ -49655,13 +49839,11 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
                 }
                 try {
                     const deviceType = device.getCurrentDeviceType();
-                    const deviceFirmwareType = device.getCurrentFirmwareType();
-                    const firmwareType = (_b = payload.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
                     if (DeviceModelToTypes.model_touch.includes(deviceType)) {
                         return yield this.updateTouchBootloader({
                             device,
                             features,
-                            firmwareType,
+                            firmwareType: preparedPlan.firmwareType,
                             source,
                         });
                     }
@@ -49674,7 +49856,7 @@ class DeviceUpdateBootloader extends FirmwareUpdateBaseMethod {
             const { binary } = payload;
             const deviceType = device.getCurrentDeviceType();
             const deviceFirmwareType = device.getCurrentFirmwareType();
-            const firmwareType = (_c = payload.firmwareType) !== null && _c !== void 0 ? _c : deviceFirmwareType;
+            const firmwareType = (_b = payload.firmwareType) !== null && _b !== void 0 ? _b : deviceFirmwareType;
             if (DeviceModelToTypes.model_touch.includes(deviceType)) {
                 return this.updateTouchBootloader({
                     device,
@@ -49935,6 +50117,119 @@ const normalizeFirmwarePreparationError = (error) => {
     return hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, error instanceof Error ? error.message : String(error));
 };
 
+const PREPARED_RESOURCE_ARCHIVE_MAX_BYTES = 256 * 1024 * 1024;
+const PREPARED_RESOURCE_ENTRY_MAX_COUNT = 512;
+const resourceArchiveError = (message, firmwareUpdateCode) => {
+    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, message, { firmwareUpdateCode });
+};
+const getZipEntrySizes = (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) {
+        return resourceArchiveError(`Firmware prepared resource ZIP entry size is invalid: ${entry.name}`, 'FirmwareArtifactsNotPrepared');
+    }
+    return {
+        compressedSize: Number(compressedSize),
+        uncompressedSize: Number(uncompressedSize),
+    };
+};
+const readVerifiedPreparedResourceArchive = ({ preparedPlan, reader, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const resourceArtifacts = preparedPlan.artifacts.filter(artifact => artifact.target === 'resource');
+    if (!preparedPlan.targetsToUpdate.includes('resource')) {
+        if (resourceArtifacts.length > 0) {
+            return resourceArchiveError('Firmware prepared resource artifact is outside the approved targets', 'FirmwareArtifactsNotPrepared');
+        }
+        return [];
+    }
+    if (resourceArtifacts.length !== 1) {
+        return resourceArchiveError('Firmware prepared plan must contain exactly one materialized resource ZIP', 'FirmwareArtifactsNotPrepared');
+    }
+    const archiveArtifact = resourceArtifacts[0];
+    const preparedEntries = archiveArtifact.materializedEntries;
+    if (archiveArtifact.role !== 'resource' ||
+        archiveArtifact.container !== 'zip' ||
+        !(preparedEntries === null || preparedEntries === void 0 ? void 0 : preparedEntries.length)) {
+        return resourceArchiveError('Firmware prepared plan must contain exactly one materialized resource ZIP', 'FirmwareArtifactsNotPrepared');
+    }
+    const archiveSource = yield openFirmwareByteSource({
+        artifact: archiveArtifact.artifact,
+        reader,
+    });
+    if (!archiveSource) {
+        return resourceArchiveError('Firmware prepared resource ZIP is unavailable', 'FirmwareArtifactsNotPrepared');
+    }
+    if (archiveSource.size > PREPARED_RESOURCE_ARCHIVE_MAX_BYTES) {
+        yield archiveSource.close().catch(() => undefined);
+        return resourceArchiveError('Firmware prepared resource ZIP exceeds the archive size limit', 'FirmwareArtifactsNotPrepared');
+    }
+    let archiveBinary;
+    try {
+        archiveBinary = yield readFirmwareByteSourceFully(archiveSource);
+    }
+    finally {
+        yield archiveSource.close().catch(() => undefined);
+    }
+    const archiveDigest = utils.bytesToHex(sha256.sha256(new Uint8Array(archiveBinary)));
+    if (archiveDigest !== archiveArtifact.artifact.sha256.toLowerCase()) {
+        return resourceArchiveError('Firmware prepared resource ZIP does not match its approved receipt', 'FirmwareArtifactReceiptMismatch');
+    }
+    let zip;
+    try {
+        zip = yield JSZip__default["default"].loadAsync(archiveBinary);
+    }
+    catch (_a) {
+        return resourceArchiveError('Firmware prepared resource ZIP cannot be parsed', 'FirmwareArtifactsNotPrepared');
+    }
+    const zipEntries = Object.values(zip.files);
+    if (zipEntries.some(entry => entry.unsafeOriginalName && entry.unsafeOriginalName !== entry.name)) {
+        return resourceArchiveError('Firmware prepared resource ZIP contains an unsafe entry path', 'FirmwareArtifactsNotPrepared');
+    }
+    const files = zipEntries.filter(entry => !entry.dir);
+    if (files.length === 0 || files.length > PREPARED_RESOURCE_ENTRY_MAX_COUNT) {
+        return resourceArchiveError('Firmware prepared resource ZIP entry set is invalid', 'FirmwareArtifactsNotPrepared');
+    }
+    let totalSize = 0;
+    const canonicalNames = new Set();
+    for (const entry of files) {
+        const { compressedSize, uncompressedSize } = getZipEntrySizes(entry);
+        const resourceName = getFirmwareUpdateResourceName(entry.name);
+        const canonicalName = resourceName.toLowerCase();
+        totalSize += uncompressedSize;
+        if (compressedSize > archiveBinary.byteLength ||
+            uncompressedSize > PREPARED_RESOURCE_ARCHIVE_MAX_BYTES ||
+            totalSize > PREPARED_RESOURCE_ARCHIVE_MAX_BYTES ||
+            canonicalNames.has(canonicalName)) {
+            return resourceArchiveError(`Firmware prepared resource ZIP entry bounds are invalid: ${entry.name}`, 'FirmwareArtifactsNotPrepared');
+        }
+        canonicalNames.add(canonicalName);
+    }
+    const preparedEntriesByName = new Map(preparedEntries.map(entry => [entry.entryName, entry]));
+    if (preparedEntriesByName.size !== files.length || preparedEntries.length !== files.length) {
+        return resourceArchiveError('Firmware prepared resource entries do not match the approved ZIP', 'FirmwareArtifactReceiptMismatch');
+    }
+    const verifiedEntries = [];
+    for (const entry of files) {
+        const { uncompressedSize } = getZipEntrySizes(entry);
+        const binary = yield entry.async('arraybuffer');
+        const preparedEntry = preparedEntriesByName.get(entry.name);
+        const digest = utils.bytesToHex(sha256.sha256(new Uint8Array(binary)));
+        if (binary.byteLength !== uncompressedSize ||
+            !preparedEntry ||
+            preparedEntry.artifact.size !== binary.byteLength ||
+            preparedEntry.artifact.sha256.toLowerCase() !== digest) {
+            return resourceArchiveError(`Firmware prepared resource entry does not match the approved ZIP: ${entry.name}`, 'FirmwareArtifactReceiptMismatch');
+        }
+        verifiedEntries.push({
+            entryName: getFirmwareUpdateResourceName(entry.name),
+            binary,
+        });
+    }
+    return verifiedEntries;
+});
+
 const Log$8 = getLogger(exports.LoggerNames.Method);
 const FIRMWARE_DOWNLOAD_REQUEST_OPTIONS = {
     connectTimeoutMs: 60000,
@@ -50009,7 +50304,7 @@ class FirmwareUpdateV2 extends BaseMethod {
         };
     }
     init() {
-        var _a;
+        var _a, _b;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.useDevicePassphraseState = false;
@@ -50022,11 +50317,12 @@ class FirmwareUpdateV2 extends BaseMethod {
             { name: 'platform', type: 'string', required: true },
             { name: 'firmwareType', type: 'string' },
         ]);
-        if ('binary' in payload &&
-            payload.binary !== undefined &&
-            'artifact' in payload &&
-            payload.artifact !== undefined) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Firmware update binary and artifact are mutually exclusive');
+        const hasPreparedPlan = payload.preparedPlan !== undefined;
+        if (hasPreparedPlan && (payload.binary !== undefined || payload.version !== undefined)) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Prepared firmware plans cannot be combined with legacy firmware inputs');
+        }
+        if (!hasPreparedPlan && payload.artifact !== undefined) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Firmware artifacts require a prepared plan');
         }
         if (!payload.updateType) {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'updateType is required');
@@ -50036,28 +50332,37 @@ class FirmwareUpdateV2 extends BaseMethod {
             forcedUpdateRes: payload.forcedUpdateRes,
             isUpdateBootloader: payload.isUpdateBootloader,
         };
-        if ('version' in payload) {
+        if (!hasPreparedPlan && 'version' in payload) {
             this.params = Object.assign(Object.assign({}, this.params), { version: payload.version, firmwareType: payload.firmwareType });
         }
-        if ('binary' in payload) {
+        if (!hasPreparedPlan && 'binary' in payload) {
             this.params = Object.assign(Object.assign({}, this.params), { binary: payload.binary });
         }
-        if ('artifact' in payload) {
-            const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration);
+        if (hasPreparedPlan) {
+            const preparedPlan = validateFirmwareUpdatePreparedPlan(payload.preparedPlan);
+            const hostBinding = resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration, preparedPlan.preparedPlanDigest);
             const target = payload.isUpdateBootloader ? 'bootloader' : payload.updateType;
+            const plannedArtifact = getFirmwareUpdatePreparedRawArtifact({
+                preparedPlan,
+                target,
+                role: target,
+            }).artifact;
             const resourceBindings = ((_a = payload.resourceEntries) !== null && _a !== void 0 ? _a : []).map((entry) => ({
                 target: 'resource',
                 entryName: entry.entryName,
                 artifact: entry.artifact,
             }));
             assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan: payload.preparedPlan,
+                preparedPlan,
                 executor: 'v2',
                 platform: payload.platform,
-                scopeTargets: [target, ...(target === 'firmware' ? ['resource'] : [])],
-                bindings: [{ target, artifact: payload.artifact }, ...resourceBindings],
+                scopeTargets: [
+                    target,
+                    ...(target === 'firmware' && resourceBindings.length ? ['resource'] : []),
+                ],
+                bindings: [{ target, artifact: (_b = payload.artifact) !== null && _b !== void 0 ? _b : plannedArtifact }, ...resourceBindings],
             });
-            this.params = Object.assign(Object.assign({}, this.params), { preparedPlan: payload.preparedPlan, artifact: payload.artifact, resourceEntries: payload.resourceEntries, artifactReader: hostBinding.artifactReader });
+            this.params = Object.assign(Object.assign({}, this.params), { preparedPlan, artifact: plannedArtifact, artifactReader: hostBinding.artifactReader, firmwareType: preparedPlan.firmwareType });
         }
     }
     _promptDeviceInBootloaderForWebDevice() {
@@ -50207,7 +50512,7 @@ class FirmwareUpdateV2 extends BaseMethod {
         }
     }
     run() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         return __awaiter(this, void 0, void 0, function* () {
             const { device, params } = this;
             const { features, commands } = device;
@@ -50295,13 +50600,48 @@ class FirmwareUpdateV2 extends BaseMethod {
                         throw normalizeFirmwarePreparationError(err);
                     }
                 });
+                const preparedResourceRequested = !params.isUpdateBootloader &&
+                    params.updateType === 'firmware' &&
+                    ((_c = (_b = params.preparedPlan) === null || _b === void 0 ? void 0 : _b.targetsToUpdate.includes('resource')) !== null && _c !== void 0 ? _c : false);
+                if (preparedResourceRequested && device.isBootloader()) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware resources require the device application mode', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared', artifactName: 'resource' });
+                }
                 if (!device.isBootloader() && features) {
                     const serialNo = device.getCurrentSerialNo();
                     if (this.isEnteredManuallyBoot()) {
                         throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateManuallyEnterBoot);
                     }
                     yield acquireFirmwareSource();
-                    if (this.isSupportResourceUpdate(params.updateType)) {
+                    if (preparedResourceRequested) {
+                        if (!this.isSupportResourceUpdate(params.updateType)) {
+                            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Prepared firmware resources are not supported by this device', { firmwareUpdateCode: 'FirmwareArtifactsNotPrepared', artifactName: 'resource' });
+                        }
+                        this.postTipMessage('CheckLatestUiResource');
+                        this.postTipMessage('DownloadLatestUiResource');
+                        const verifiedEntries = yield readVerifiedPreparedResourceArchive({
+                            preparedPlan: params.preparedPlan,
+                            reader: params.artifactReader,
+                        });
+                        const sources = [];
+                        try {
+                            for (const entry of verifiedEntries) {
+                                const source = yield openFirmwareByteSource({ binary: entry.binary });
+                                if (!source) {
+                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware resource entry ${entry.entryName} is empty`, {
+                                        firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+                                        artifactName: 'resource',
+                                    });
+                                }
+                                sources.push({ entryName: entry.entryName, source });
+                            }
+                            yield updateResourcesFromSources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, sources);
+                        }
+                        finally {
+                            yield Promise.all(sources.map(entry => entry.source.close().catch(() => undefined)));
+                        }
+                        this.postTipMessage('DownloadLatestUiResourceSuccess');
+                    }
+                    else if (this.isSupportResourceUpdate(params.updateType)) {
                         this.postTipMessage('CheckLatestUiResource');
                         const resourceUrl = DataManager.getSysResourcesLatestRelease({
                             features,
@@ -50310,46 +50650,20 @@ class FirmwareUpdateV2 extends BaseMethod {
                         });
                         if (resourceUrl) {
                             this.postTipMessage('DownloadLatestUiResource');
-                            if ((_b = params.resourceEntries) === null || _b === void 0 ? void 0 : _b.length) {
-                                const sources = [];
-                                try {
-                                    for (const entry of params.resourceEntries) {
-                                        const resourceName = getFirmwareUpdateResourceName(entry.entryName);
-                                        const source = yield openFirmwareByteSource({
-                                            artifact: entry.artifact,
-                                            reader: params.artifactReader,
-                                        });
-                                        if (!source) {
-                                            throw new Error('Firmware resource entry is not prepared');
-                                        }
-                                        sources.push({ entryName: resourceName, source });
-                                    }
-                                    yield updateResourcesFromSources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, sources.map(entry => ({
-                                        entryName: entry.entryName,
-                                        source: entry.source,
-                                    })));
-                                }
-                                finally {
-                                    yield Promise.all(sources.map(entry => entry.source.close().catch(() => undefined)));
-                                }
-                                this.postTipMessage('DownloadLatestUiResourceSuccess');
-                            }
-                            else {
-                                if (params.artifactReader ||
-                                    DataManager.getSettings('firmwareManifestMode') === 'external-only') {
-                                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware resource must be prepared by the external firmware host', {
-                                        firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
-                                        artifactName: 'resource',
-                                    });
-                                }
-                                const resourceBinary = (yield getSysResourceBinary(resourceUrl))
-                                    .binary;
-                                this.postTipMessage('DownloadLatestUiResourceSuccess');
-                                yield updateResources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, resourceBinary);
+                            if (params.artifactReader ||
+                                DataManager.getSettings('firmwareManifestMode') === 'external-only') {
+                                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware resource must be prepared by the external firmware host', {
+                                    firmwareUpdateCode: 'FirmwareArtifactsNotPrepared',
+                                    artifactName: 'resource',
+                                });
                             }
+                            const resourceBinary = (yield getSysResourceBinary(resourceUrl))
+                                .binary;
+                            this.postTipMessage('DownloadLatestUiResourceSuccess');
+                            yield updateResources(this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, resourceBinary);
                         }
                     }
-                    (_d = (_c = this.device) === null || _c === void 0 ? void 0 : _c.commands) === null || _d === void 0 ? void 0 : _d.checkDisposed();
+                    (_e = (_d = this.device) === null || _d === void 0 ? void 0 : _d.commands) === null || _e === void 0 ? void 0 : _e.checkDisposed();
                     try {
                         this.postTipMessage('AutoRebootToBootloader');
                         const bootRes = yield commands.typedCall('DeviceBackToBoot', 'Success');
@@ -50362,9 +50676,9 @@ class FirmwareUpdateV2 extends BaseMethod {
                             DevicePool.clearDeviceCache(serialNo);
                         }
                         delete DevicePool.devicesCache[''];
-                        yield ((_e = this.checkPromise) === null || _e === void 0 ? void 0 : _e.promise);
+                        yield ((_f = this.checkPromise) === null || _f === void 0 ? void 0 : _f.promise);
                         this.checkPromise = null;
-                        (_g = (_f = this.device) === null || _f === void 0 ? void 0 : _f.commands) === null || _g === void 0 ? void 0 : _g.checkDisposed();
+                        (_h = (_g = this.device) === null || _g === void 0 ? void 0 : _g.commands) === null || _h === void 0 ? void 0 : _h.checkDisposed();
                         const isTouch = DeviceModelToTypes.model_touch.includes(deviceType);
                         yield wait(isTouch ? 3000 : 1500);
                     }
@@ -50377,7 +50691,7 @@ class FirmwareUpdateV2 extends BaseMethod {
                     }
                 }
                 const source = yield acquireFirmwareSource();
-                (_j = (_h = this.device) === null || _h === void 0 ? void 0 : _h.commands) === null || _j === void 0 ? void 0 : _j.checkDisposed();
+                (_k = (_j = this.device) === null || _j === void 0 ? void 0 : _j.commands) === null || _k === void 0 ? void 0 : _k.checkDisposed();
                 yield this.device.acquire();
                 const response = yield uploadFirmwareFromSource(params.updateType, this.device.getCommands().typedCall.bind(this.device.getCommands()), this.postMessage, device, source, true, params.isUpdateBootloader);
                 if (this.connectId) {
@@ -50402,7 +50716,7 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
         this.artifactSources = [];
     }
     init() {
-        var _a, _b, _c, _d, _e, _f;
+        var _a, _b, _c;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.useDevicePassphraseState = false;
@@ -50420,50 +50734,80 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             { name: 'firmwareType', type: 'string' },
             { name: 'platform', type: 'string' },
         ]);
-        const hostBinding = payload.artifacts || payload.preparedPlan
-            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+        const hasPreparedPlan = payload.preparedPlan !== undefined;
+        if (!hasPreparedPlan && payload.artifacts !== undefined) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Firmware artifacts require a prepared plan');
+        }
+        const preparedPlan = hasPreparedPlan
+            ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
             : undefined;
-        if (hostBinding) {
+        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;
+        const preparedArtifacts = {};
+        if (preparedPlan) {
+            const componentTargets = ['bootloader', 'firmware', 'ble'];
+            const supportedTargets = new Set([...componentTargets, 'resource']);
+            const unsupportedTarget = preparedPlan.targetsToUpdate.find(target => !supportedTargets.has(target));
+            if (unsupportedTarget) {
+                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware prepared plan target ${unsupportedTarget} is not supported by V3`, { firmwareUpdateCode: 'FirmwarePreparedPlanInvalid' });
+            }
+            for (const target of componentTargets) {
+                if (preparedPlan.targetsToUpdate.includes(target)) {
+                    preparedArtifacts[target] = getFirmwareUpdatePreparedRawArtifact({
+                        preparedPlan,
+                        target,
+                        role: target,
+                    }).artifact;
+                }
+            }
+            const resourceBindings = ((_b = (_a = payload.artifacts) === null || _a === void 0 ? void 0 : _a.resourceEntries) !== null && _b !== void 0 ? _b : []).map((entry) => ({
+                target: 'resource',
+                entryName: entry.entryName,
+                artifact: entry.artifact,
+            }));
             assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan: payload.preparedPlan,
+                preparedPlan,
                 executor: 'v3',
                 platform: payload.platform,
-                scopeTargets: ['bootloader', 'firmware', 'resource', 'ble'],
+                scopeTargets: [
+                    'bootloader',
+                    'firmware',
+                    'ble',
+                    ...(resourceBindings.length ? ['resource'] : []),
+                ],
                 bindings: [
-                    ...(((_a = payload.artifacts) === null || _a === void 0 ? void 0 : _a.bootloader)
-                        ? [
-                            {
-                                target: 'bootloader',
-                                artifact: payload.artifacts.bootloader,
-                            },
-                        ]
-                        : []),
-                    ...(((_b = payload.artifacts) === null || _b === void 0 ? void 0 : _b.firmware)
-                        ? [
-                            {
-                                target: 'firmware',
-                                artifact: payload.artifacts.firmware,
-                            },
-                        ]
-                        : []),
-                    ...(((_c = payload.artifacts) === null || _c === void 0 ? void 0 : _c.ble)
-                        ? [
-                            {
-                                target: 'ble',
-                                artifact: payload.artifacts.ble,
-                            },
-                        ]
-                        : []),
-                    ...((_e = (_d = payload.artifacts) === null || _d === void 0 ? void 0 : _d.resourceEntries) !== null && _e !== void 0 ? _e : []).map((entry) => ({
-                        target: 'resource',
-                        entryName: entry.entryName,
-                        artifact: entry.artifact,
-                    })),
+                    ...componentTargets.flatMap(target => {
+                        var _a;
+                        const plannedArtifact = preparedArtifacts[target];
+                        const suppliedArtifact = (_a = payload.artifacts) === null || _a === void 0 ? void 0 : _a[target];
+                        return plannedArtifact || suppliedArtifact
+                            ? [
+                                {
+                                    target,
+                                    artifact: suppliedArtifact !== null && suppliedArtifact !== void 0 ? suppliedArtifact : plannedArtifact,
+                                },
+                            ]
+                            : [];
+                    }),
+                    ...resourceBindings,
                 ],
             });
         }
         this.params = {
-            preparedPlan: payload.preparedPlan,
+            preparedPlan,
             bleBinary: payload.bleBinary,
             firmwareBinary: payload.firmwareBinary,
             forcedUpdateRes: payload.forcedUpdateRes,
@@ -50472,10 +50816,10 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
             bootloaderBinary: payload.bootloaderBinary,
             firmwareVersion: payload.firmwareVersion,
             resourceBinary: payload.resourceBinary,
-            firmwareType: payload.firmwareType,
+            firmwareType: (_c = preparedPlan === null || preparedPlan === void 0 ? void 0 : preparedPlan.firmwareType) !== null && _c !== void 0 ? _c : payload.firmwareType,
             platform: payload.platform,
-            artifactReader: (_f = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _f !== void 0 ? _f : payload.artifactReader,
-            artifacts: payload.artifacts,
+            artifactReader,
+            artifacts: preparedPlan ? preparedArtifacts : undefined,
         };
     }
     run() {
@@ -50581,19 +50925,21 @@ class FirmwareUpdateV3 extends FirmwareUpdateBaseMethod {
     prepareResourceInput(firmwareType) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const preparedEntries = (_a = this.params.artifacts) === null || _a === void 0 ? void 0 : _a.resourceEntries;
-            if ((preparedEntries === null || preparedEntries === void 0 ? void 0 : preparedEntries.length) && this.params.resourceBinary) {
-                throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Firmware resource input must not contain both archive binary and prepared entries');
-            }
-            if (preparedEntries === null || preparedEntries === void 0 ? void 0 : preparedEntries.length) {
+            if ((_a = this.params.preparedPlan) === null || _a === void 0 ? void 0 : _a.targetsToUpdate.includes('resource')) {
+                const verifiedEntries = yield readVerifiedPreparedResourceArchive({
+                    preparedPlan: this.params.preparedPlan,
+                    reader: this.params.artifactReader,
+                });
                 const resourceEntries = [];
-                for (const entry of preparedEntries) {
-                    const resourceName = getFirmwareUpdateResourceName(entry.entryName);
-                    const source = yield this.openArtifactSource(undefined, entry.artifact);
+                for (const entry of verifiedEntries) {
+                    const source = yield this.openArtifactSource(entry.binary, undefined);
                     if (!source) {
-                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware resource entry ${entry.entryName} is not prepared`);
+                        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, `Firmware resource entry ${entry.entryName} is empty`, {
+                            firmwareUpdateCode: 'FirmwareArtifactReceiptMismatch',
+                            artifactName: 'resource',
+                        });
                     }
-                    resourceEntries.push({ entryName: resourceName, source });
+                    resourceEntries.push({ entryName: entry.entryName, source });
                 }
                 return {
                     resourceBinary: null,
@@ -51090,6 +51436,88 @@ 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;
@@ -51116,7 +51544,24 @@ 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)));
@@ -51187,6 +51632,14 @@ 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 isProtocolV2BootResourcePackagePath = (devicePath) => typeof devicePath === 'string' &&
+    devicePath.replace(/^vol0:(?!\/)/i, 'vol0:/').toLowerCase() ===
+        PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_PATH;
+const resolveProtocolV2ResourceWritePath = (devicePath) => isProtocolV2BootResourcePackagePath(devicePath)
+    ? 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'],
@@ -51197,6 +51650,10 @@ 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([
@@ -51354,6 +51811,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         super(...arguments);
         this.protocolV2PreparedSources = [];
         this.protocolV2ExecutionInLoader = false;
+        this.protocolV2BootResourceStagingSafe = false;
         this.protocolV2CompletedTargetVersions = new Map();
         this.protocolV2FinalStatusVerified = false;
     }
@@ -51361,7 +51819,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         return ['V2'];
     }
     init() {
-        var _a, _b, _c;
+        var _a, _b;
         this.allowDeviceMode = [UI_REQUEST.BOOTLOADER, UI_REQUEST.NOT_INITIALIZE];
         this.requireDeviceMode = [];
         this.unlockPolicy = 'unlock-before-run';
@@ -51392,54 +51850,85 @@ 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 hostBinding = payload.preparedPlan || payload.componentArtifacts || payload.resourceBundleArtifacts
-            ? resolveFirmwareUpdateHostBinding(payload.hostBindingGeneration)
+        const preparedPlan = payload.preparedPlan
+            ? validateFirmwareUpdatePreparedPlan(payload.preparedPlan)
             : undefined;
-        if (hostBinding) {
+        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) {
             assertFirmwareUpdatePreparedPlanBinding({
-                preparedPlan: payload.preparedPlan,
+                preparedPlan,
                 executor: 'v4',
                 platform: payload.platform,
-                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,
-                    })),
-                ],
+                scopeTargets: [],
+                bindings: [],
             });
+            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: payload.preparedPlan,
+            preparedPlan,
             chunkSize: payload.chunkSize,
             forcedUpdateRes: payload.forcedUpdateRes,
             bootloaderBinary: payload.bootloaderBinary,
@@ -51451,15 +51940,18 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             se02Binary: payload.se02Binary,
             se03Binary: payload.se03Binary,
             se04Binary: payload.se04Binary,
-            resourceFiles: payload.resourceFiles,
-            firmwareType: payload.firmwareType,
-            targetsToUpdate: payload.targetsToUpdate,
-            expectedTargetVersions: payload.expectedTargetVersions,
+            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,
             platform: payload.platform,
             expectedDeviceId: payload.expectedDeviceId,
-            artifactReader: (_c = hostBinding === null || hostBinding === void 0 ? void 0 : hostBinding.artifactReader) !== null && _c !== void 0 ? _c : payload.artifactReader,
-            componentArtifacts: payload.componentArtifacts,
-            resourceBundleArtifacts: payload.resourceBundleArtifacts,
+            artifactReader,
+            componentArtifacts: preparedPlan ? undefined : payload.componentArtifacts,
         };
     }
     getProtocolV2FirmwareChunkSize(direction, filePath) {
@@ -51490,7 +51982,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     runProtocolV2() {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f;
         return __awaiter(this, void 0, void 0, function* () {
             yield this.captureProtocolV2PhysicalIdentity();
             const deviceFeatures = yield this.getProtocolV2DeviceFeatures();
@@ -51502,85 +51994,80 @@ 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.componentArtifacts && Object.keys(this.params.componentArtifacts).length > 0) ||
-                ((_b = this.params.resourceBundleArtifacts) === null || _b === void 0 ? void 0 : _b.length)) {
+            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) {
                 return this.runProtocolV2PreparedArtifacts(deviceFeatures, firmwareType);
             }
-            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);
+            const wantsResources = !!((_d = this.params.targetsToUpdate) === null || _d === void 0 ? void 0 : _d.includes('resource'));
             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 needsRemoteFirmware = !this.hasExplicitProtocolV2Payload(fwBinaryMap);
-                if ((needsRemoteFirmware || needsRemoteResources || needsRemoteBootResources) &&
+                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 &&
                     (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 || needsRemoteResources || needsRemoteBootResources) {
-                    yield DataManager.forceReloadData({
-                        requireResources: needsRemoteResources || needsRemoteBootResources,
-                    });
+                if (needsRemoteFirmware) {
+                    yield DataManager.forceReloadData();
                 }
                 if (needsRemoteFirmware) {
-                    const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures);
+                    const remoteBinaries = yield this.prepareRemoteProtocolV2Binaries(firmwareType, deviceFeatures, explicitInstallItems);
                     bootloaderBinary = remoteBinaries.bootloaderBinary;
                     fwBinaryMap = remoteBinaries.fwBinaryMap;
                     installItems = remoteBinaries.installItems;
                 }
-                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);
-                }
+                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) &&
-                !(resourceBundles === null || resourceBundles === void 0 ? void 0 : resourceBundles.length) &&
-                !needsRemoteResources) {
+            if (!bootloaderBinary && fwBinaryMap.length === 0 && !(installItems === null || installItems === void 0 ? void 0 : installItems.length)) {
                 throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
             }
-            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)));
+            return this.executeProtocolV2Update(Object.assign({ fwBinaryMap,
+                bootloaderBinary }, (installItems ? { installItems } : undefined)));
         });
     }
     openProtocolV2PreparedSource(artifact) {
@@ -51617,6 +52104,34 @@ 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');
@@ -51647,39 +52162,278 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return installSources;
         });
     }
-    prepareProtocolV2ResourceSources(firmwareType, features) {
-        var _a, _b, _c;
+    prepareProtocolV2LocalMemoryHost({ features, firmwareType, }) {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            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;
+            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;
+        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;
             if (!resourceRequested) {
                 return [];
             }
-            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 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 sources = [];
-            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,
-                    });
+            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' });
                 }
-                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}`);
+                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' });
+                }
+                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,
+                    }
+                    : {})));
             }
             return sources;
         });
@@ -51689,7 +52443,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             try {
                 this.postTipMessage(exports.FirmwareUpdateTipMessage.StartDownloadFirmware);
                 const installSources = yield this.prepareProtocolV2InstallSources(firmwareType, features);
-                const resourceSources = yield this.prepareProtocolV2ResourceSources(firmwareType, features);
+                const resourceSources = yield this.prepareProtocolV2ResourceSources();
                 if (installSources.length === 0 && resourceSources.length === 0) {
                     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.FirmwareUpdateDownloadFailed, 'No firmware to update');
                 }
@@ -51773,15 +52527,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         }
     }
     getProtocolV2RequestedTargets() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         if ((_a = this.params.targetsToUpdate) === null || _a === void 0 ? void 0 : _a.length) {
             return [...new Set(this.params.targetsToUpdate)];
         }
-        const targets = new Set();
-        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 ((_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));
         if (this.params.bootloaderBinary)
             targets.add('boot');
         if (this.params.applicationP1Binary)
@@ -51818,8 +52572,26 @@ 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.device.originalDescriptor.path);
+        assertProtocolV2ReconnectIdentity(this.protocolV2ExpectedSerialNumber, this.getProtocolV2SerialNumber(deviceInfo), this.protocolV2ExpectedPath, this.getProtocolV2ConnectionRoute());
     }
     getProtocolV2DeviceInfoTimeout() {
         var _a;
@@ -51836,19 +52608,20 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         });
     }
     captureProtocolV2PhysicalIdentity() {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
             const deviceInfo = yield this.requestProtocolV2PhysicalIdentity();
             const serialNumber = this.getProtocolV2SerialNumber(deviceInfo);
-            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) {
+            const path = this.getProtocolV2ConnectionRoute();
+            if ((_a = this.params) === null || _a === void 0 ? void 0 : _a.preparedPlan) {
                 assertFirmwareUpdatePreparedPlanDeviceIdentity({
                     preparedPlan: this.params.preparedPlan,
                     deviceIdentity: serialNumber,
+                    deviceModel: this.getProtocolV2PreparedPlanDeviceModel(this.device.features),
                 });
             }
-            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 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 {
                 assertProtocolV2ReconnectIdentity(serialNumber, serialNumber, path, path);
@@ -51868,11 +52641,15 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
         var _a;
         return (_a = this.params.bootloaderBinary) !== null && _a !== void 0 ? _a : null;
     }
-    hasExplicitProtocolV2Payload(fwBinaryMap) {
+    getMissingProtocolV2FirmwareTargets(installItems) {
         var _a;
-        return (!!((_a = this.params.resourceFiles) === null || _a === void 0 ? void 0 : _a.length) ||
-            !!this.params.bootloaderBinary ||
-            fwBinaryMap.length > 0);
+        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));
     }
     buildProtocolV2InstallItems({ bootloaderBinary, fwBinaryMap, }) {
         const installItems = [];
@@ -51921,7 +52698,17 @@ 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}`);
             }
@@ -51935,7 +52722,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return Object.assign(Object.assign({}, target), { binary });
         });
     }
-    prepareRemoteProtocolV2Binaries(firmwareType, features) {
+    prepareRemoteProtocolV2Binaries(firmwareType, features, explicitInstallItems = []) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const release = DataManager.getFirmwareLatestRelease(features, firmwareType);
@@ -51943,6 +52730,10 @@ 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,
@@ -51951,6 +52742,8 @@ 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];
@@ -51958,27 +52751,27 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     ? PROTOCOL_V2_UPDATE_TARGET_BY_TARGET_ID.get(target.targetId)
                     : undefined;
                 if (updateTarget && targetsToUpdate.has(updateTarget)) {
-                    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,
-                        });
+                    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;
                     }
                     else {
                         const binaryEntry = {
-                            fileName: remoteBinary.fileName,
-                            binary: remoteBinary.binary,
-                            targetId: remoteBinary.targetId,
+                            fileName: installItem.fileName,
+                            binary: installItem.binary,
+                            targetId: installItem.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,
@@ -51986,178 +52779,6 @@ 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;
@@ -52165,7 +52786,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             return `vol0:${path}`;
         return `vol0:/${path}`;
     }
-    readProtocolV2DeviceFileHeader(path) {
+    readProtocolV2DeviceFileHeader(path, expectedSize) {
         var _a, _b, _c, _d;
         return __awaiter(this, void 0, void 0, function* () {
             const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
@@ -52177,7 +52798,8 @@ 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) {
+                fileSize < PROTOCOL_V2_OKPP_HEADER_SIZE ||
+                (expectedSize !== undefined && fileSize !== expectedSize)) {
                 return null;
             }
             const chunkSize = this.getProtocolV2FirmwareChunkSize('read');
@@ -52214,10 +52836,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.version && !bundle.payloadHash)
+            if (!bundle.payloadHash || !bundle.headerHash)
                 return false;
             try {
-                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath);
+                const header = yield this.readProtocolV2DeviceFileHeader(bundle.devicePath, bundle.source.size);
                 if (!header)
                     return false;
                 if (bundle.version) {
@@ -52225,16 +52847,12 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                     if (cmp === undefined || cmp !== 0)
                         return false;
                 }
-                if (bundle.payloadHash) {
-                    const expected = normalizeProtocolV2Hex(bundle.payloadHash);
-                    if (expected && header.payloadHash !== expected)
-                        return false;
-                }
-                if (bundle.headerHash) {
-                    const expected = normalizeProtocolV2Hex(bundle.headerHash);
-                    if (expected && header.headerHash !== expected)
-                        return false;
-                }
+                const expectedPayloadHash = normalizeProtocolV2Hex(bundle.payloadHash);
+                const expectedHeaderHash = normalizeProtocolV2Hex(bundle.headerHash);
+                if (!expectedPayloadHash || header.payloadHash !== expectedPayloadHash)
+                    return false;
+                if (!expectedHeaderHash || header.headerHash !== expectedHeaderHash)
+                    return false;
                 return true;
             }
             catch (error) {
@@ -52349,11 +52967,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     buildProtocolV2ExecutionPhases({ installSources, resourceSources, }) {
         const phases = [];
-        if (resourceSources.length > 0) {
+        const bootResourceSources = resourceSources.filter(source => isProtocolV2BootResourcePackagePath(source.devicePath));
+        const remainingResourceSources = resourceSources.filter(source => !isProtocolV2BootResourcePackagePath(source.devicePath));
+        if (bootResourceSources.length > 0) {
             phases.push({
                 kind: 'resource-sync',
                 installSources: [],
-                resourceSources,
+                resourceSources: bootResourceSources,
             });
         }
         const bootloaderSources = installSources.filter(source => source.kind === 'bootloader');
@@ -52368,6 +52988,13 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 resourceSources: [],
             });
         }
+        if (remainingResourceSources.length > 0) {
+            phases.push({
+                kind: 'resource-sync',
+                installSources: [],
+                resourceSources: remainingResourceSources,
+            });
+        }
         const componentSources = installSources.filter(source => source.kind !== 'bootloader');
         if (componentSources.length > 0) {
             phases.push({
@@ -52385,6 +53012,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
     }
     executeProtocolV2Phases({ installSources, resourceSources, }) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.protocolV2BootResourceStagingSafe = false;
             const phases = this.buildProtocolV2ExecutionPhases({
                 installSources,
                 resourceSources,
@@ -52395,10 +53023,14 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
                 }
                 if (phase.kind === 'resource-sync') {
                     yield this.enterProtocolV2BootloaderMode();
+                    if (!phase.resourceSources.some(source => isProtocolV2BootResourcePackagePath(source.devicePath))) {
+                        yield this.ensureProtocolV2BootResourceStagingIsEmpty();
+                    }
                     yield this.executeProtocolV2TransferPhase(phase);
                 }
                 else if (phase.kind === 'bootloader-install' || phase.kind === 'component-install') {
                     yield this.enterProtocolV2BootloaderMode();
+                    yield this.ensureProtocolV2BootResourceStagingIsEmpty();
                     yield this.executeProtocolV2TransferPhase(phase);
                     yield this.exitProtocolV2BootloaderToNormal();
                 }
@@ -52410,6 +53042,31 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'Protocol V2 execution has no final verification phase');
         });
     }
+    ensureProtocolV2BootResourceStagingIsEmpty() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.protocolV2BootResourceStagingSafe)
+                return;
+            const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+            const query = () => typedCall('FilesystemPathInfoQuery', 'FilesystemPathInfo', {
+                path: PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH,
+            });
+            const current = yield query();
+            if ((_a = current.message) === null || _a === void 0 ? void 0 : _a.exist) {
+                if (current.message.directory) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'Protocol V2 boot resource staging path is not a file');
+                }
+                yield typedCall('FilesystemFileDelete', 'Success', {
+                    path: PROTOCOL_V2_BOOT_RESOURCE_PACKAGE_STAGING_PATH,
+                });
+                const remaining = yield query();
+                if ((_b = remaining.message) === null || _b === void 0 ? void 0 : _b.exist) {
+                    throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.EmmcFileWriteFirmwareError, 'Protocol V2 stale boot resource staging file could not be removed');
+                }
+            }
+            this.protocolV2BootResourceStagingSafe = true;
+        });
+    }
     executeProtocolV2SourceUpdate({ installSources, resourceSources, }) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.executeProtocolV2Phases({
@@ -52418,7 +53075,7 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             });
         });
     }
-    executeProtocolV2Update({ fwBinaryMap, bootloaderBinary, installItems, resourceBundles, }) {
+    executeProtocolV2Update({ fwBinaryMap, bootloaderBinary, installItems, }) {
         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 : [],
@@ -52433,16 +53090,9 @@ 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 {
@@ -52455,7 +53105,8 @@ class FirmwareUpdateV4 extends FirmwareUpdateBaseMethod {
             let totalSize = installSources.reduce((total, item) => total + item.source.size, 0);
             const resourcesToSync = [];
             for (const resource of resourceSources) {
-                if (yield this.isProtocolV2ResourceBundleUpToDate(resource)) {
+                const requiresFreshStaging = isProtocolV2BootResourcePackagePath(resource.devicePath);
+                if (!requiresFreshStaging && (yield this.isProtocolV2ResourceBundleUpToDate(resource))) {
                     Log$6.log(`[FirmwareUpdateV4] skip RESC bundle ${resource.name}; already up to date`);
                 }
                 else {
@@ -52466,13 +53117,17 @@ 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: resource.devicePath,
+                    filePath: writePath,
                     processedSize,
                     totalSize,
                 });
-                yield this.verifyProtocolV2StagedFile(resource.devicePath, resource.source.size);
+                yield this.verifyProtocolV2StagedFile(writePath, resource.source.size);
+                if (isProtocolV2BootResourcePackagePath(resource.devicePath)) {
+                    this.protocolV2BootResourceStagingSafe = true;
+                }
             }
             const stagedInstallTargets = [];
             for (const item of installSources) {
@@ -53462,7 +54117,7 @@ class DeviceUploadWallpaper extends BaseMethod {
 }
 
 const FILESYSTEM_PATH_INFO_QUERY_MESSAGE_TYPE = 60802;
-const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE = 60805;
+const FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$1 = 60805;
 const FILESYSTEM_DIR_LIST_MESSAGE_TYPE = 60808;
 const NFT_UPDATE_MESSAGE_TYPE = 61500;
 class DeviceUploadNft extends BaseMethod {
@@ -53491,7 +54146,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);
+            const hasFileWrite = supportsProtocolV2Message(protocolInfo, FILESYSTEM_FILE_WRITE_MESSAGE_TYPE$1);
             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);
@@ -53626,6 +54281,8 @@ 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;
@@ -53639,6 +54296,12 @@ 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', {});
@@ -65180,11 +65843,14 @@ 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;