react-native-update 10.60.0 → 10.61.0

package/harmony/pushy/src/main/ets/SyncCoordinator.ts

@@ -5,40 +5,32 @@ import NativePatchCore from './NativePatchCore';
 import type { UpdateContext } from './UpdateContext';
 import { BundlePreparationRound, bundlePreparationResult } from './BundlePreparationResult';
 import type { BundlePreparationResult } from './BundlePreparationResult';
-import { isSafePathComponent } from './PathUtils';
-import { STATUS_NONE } from './Texts';
 import { monotonicNowMs } from './MonotonicClock';
-import {
-  ERROR_DELTA_FAILED,
-  ERROR_DOWNLOAD_FAILED,
-  PushyError,
-  createPushyError,
-  getErrorMessage,
-} from './ErrorCodes';
+import { PushyError, getErrorMessage } from './ErrorCodes';
 
 // 原生冷启动检测(NATIVE_CHECKUPDATE_DESIGN §10):每进程一次,getBundleUrl
 // 后延迟数秒运行,完全不依赖 app bundle——坏热更把 JS 砸挂后,下次启动仍能
-// 拉到修复版。决策全部来自 cpp/update_flow_core(经 NativePatchCore 的
-// NAPI 面),本文件只是 IO 胶水。失败静默且有界:每次启动至多一轮,无重试
+// 拉到修复版。轮次本身由共享引擎驱动(cpp/update_flow_core/round_engine.h,
+// 经 NativePatchCore.stepRound,NATIVE_CHECKUPDATE_DESIGN §12),本文件只
+// 执行它要求的 IO。失败静默且有界:每次启动至多一轮,无重试
 // 风暴,不拉黑版本。
 // 鸿蒙的 debug 门控由触发点天然承担:dev 走 MetroJSBundleProvider,
 // PushyFileJSBundleProvider.getBundleUrl 不会被调用。
 const TAG = 'NativeSync';
+// 与 Android 共用的存储键。鸿蒙不做 crash-hold(errorManager 的同步回调驱动
+// 不了 ArkTS 异步网络 IO),续传 + 零延迟标记是收敛砖机的全部机制。
+// <generated:storage-keys> (scripts/contract.ts; bun scripts/generate-contract.ts)
+// The persisted native check config (JS syncNativeConfig or the host).
 export const KEY_CONFIG = 'nativeConfig';
-// 供 JS 侧复用的原始响应缓存(§10.3),同时记录请求与配置指纹以限定命中范围。
+// Raw response cache for the JS side to reuse (§10.3), scoped to the exact
+// logical request and native config that produced it.
 export const KEY_RESP_CACHE = 'nativeCheckResp';
-// 轮次开始落盘、结束清除(§11.4)。下次启动读到残留 = 上个进程死于轮中
-// (砖机的签名),该次启动跳过 5s 延迟立即续传。鸿蒙本版不做 crash-hold
-// (errorManager 的同步回调驱动不了 ArkTS 异步网络 IO),续传 + 零延迟
-// 标记是收敛砖机的全部机制。
+// Set when a round starts, cleared when it ends (§11.4). Residue on the
+// next launch means the previous process died mid-round: that launch
+// resumes immediately instead of waiting 5s.
 export const KEY_ROUND_INCOMPLETE = 'nativeCheckIncomplete';
-const REQUEST_TIMEOUT_MS = 10000;
-const REQUEST_CALL_TIMEOUT_MS = 15000;
-const MAX_QUERY_HTTP_ATTEMPTS = 8;
+// </generated:storage-keys>
 const START_DELAY_MS = 5000;
-const DOWNLOAD_PHASE_TIMEOUT_MS = 10 * 60 * 1000;
-const DOWNLOAD_TYPE_DIFF = 'diff';
-const DOWNLOAD_TYPE_PDIFF = 'pdiff';
 
 // 本次启动的事实,交给共享内核(cpp/update_flow_core/native_round.h)。
 interface RoundEnv {
@@ -51,32 +43,49 @@ interface RoundEnv {
   bundleHash: string;
 }
 
-interface PreparedRound {
-  body: string;
-  query: Object;
+// 引擎的事件与命令(字段含义见 round_engine.h)。
+interface RoundEvent {
+  type?: string;
+  now?: number;
+  config?: string;
+  resetGeneration?: number;
+  configGeneration?: number;
+  sample?: number;
+  deadline?: number;
+  env?: RoundEnv;
+  text?: string;
+  at?: number;
+  installed?: boolean;
+  ok?: boolean;
+  code?: string;
+  timedOut?: boolean;
+  reason?: string;
+  error?: boolean;
 }
 
-interface QueryStep {
+interface RoundCommand {
+  type: string;
   url?: string;
   post?: boolean;
-  found?: boolean;
-}
-
-interface DecisionAttempt {
-  type?: string;
-  urls?: string[];
-}
-
-interface Decision {
-  action?: string;
-  reason?: string;
+  body?: string;
+  timeoutMs?: number;
+  callTimeoutMs?: number;
   hash?: string;
-  attempts?: DecisionAttempt[];
+  strategy?: string;
+  originHash?: string;
+  deadline?: number;
+  hashInfo?: string;
   activate?: boolean;
-  // 要与版本一起持久化的元信息(JS 侧 setLocalHashInfo;forceBootRescue 由内核标记)。
-  hashInfo?: Object;
-  // 供 JS 复用的响应缓存文本(§10.3)。
   cache?: string;
+  resetGeneration?: number;
+  status?: string;
+  reason?: string;
+  activated?: boolean;
+}
+
+interface RoundStep {
+  state: Object;
+  commands: RoundCommand[];
 }
 
 let scheduled = false;
@@ -141,8 +150,13 @@ function configurationError(context: UpdateContext): BundlePreparationResult | u
   return readNativeConfig(context).rejection;
 }
 
+// timeoutMs bounds how long the host waits, as iOS/Android's
+// prepareBundle(timeout): on expiry the result is failed/timeout and the round
+// keeps running (its result still applies to the next launch). Without one the
+// host waits for the round; nothing blocks meanwhile (single-threaded ArkTS).
 export async function prepareBundleNative(
   context: UpdateContext,
+  timeoutMs?: number,
 ): Promise<BundlePreparationResult> {
   if (scheduledContext !== context) {
     return bundlePreparationResult('skipped', 'not_initialized');
@@ -152,9 +166,26 @@ export async function prepareBundleNative(
     return read.rejection;
   }
   const configJson = read.json;
-  const result = await startNativeRound(context, scheduledRollback);
+  const round = startNativeRound(context, scheduledRollback);
+  let result: BundlePreparationResult;
+  if (timeoutMs === undefined) {
+    result = await round;
+  } else {
+    let timer: number | undefined;
+    const expired = new Promise<undefined>((resolve) => {
+      timer = setTimeout(() => resolve(undefined), Math.max(0, timeoutMs));
+    });
+    const settled = await Promise.race([round, expired]);
+    clearTimeout(timer);
+    if (settled === undefined) {
+      return bundlePreparationResult('failed', 'timeout');
+    }
+    result = settled;
+  }
+  // 与引擎的 HostCancellation 同一规则:三方 C1 等价且配置代数未变。
   if (roundConfigGeneration !== context.getNativeConfigGeneration()
-      || configJson !== roundConfigJson || configJson !== context.getKv(KEY_CONFIG)) {
+      || !NativePatchCore.configsEquivalent(configJson, roundConfigJson)
+      || !context.isStoredNativeConfig(configJson)) {
     return bundlePreparationResult('cancelled', 'config_changed');
   }
   if (roundGeneration !== context.getResetGeneration()) {
@@ -211,58 +242,109 @@ async function runOnce(
   context: UpdateContext,
   launchRolledBackVersion: string,
 ): Promise<void> {
-  // 在任何 IO 之前采样:resetToPackagedBundle 会递增它,本轮运行期间发生的
-  // reset 必须赢过本轮的决策。
+  // 在任何 IO 之前采样:resetToPackagedBundle 与配置替换都会递增 reset 代数,
+  // 本轮运行期间发生的 reset 必须赢过本轮的决策。
   const resetGeneration = context.getResetGeneration();
+  const configGeneration = context.getNativeConfigGeneration();
   roundGeneration = resetGeneration;
-  roundConfigGeneration = context.getNativeConfigGeneration();
+  roundConfigGeneration = configGeneration;
   roundResult = bundlePreparationResult('failed', 'check_failed');
-  const read = readNativeConfig(context);
-  roundConfigJson = read.json;
-  if (read.rejection !== undefined) {
-    roundResult = read.rejection;
-    return;
-  }
-  const configJson = read.json;
-  // 从这里起本轮开始做真实工作:留下面包屑,死于轮中时下次启动零延迟续传。
-  logger.info(
-    TAG,
-    `round started (resume=${!!context.getKv(KEY_ROUND_INCOMPLETE)})`,
-  );
-  // 面包屑只是"下次零延迟"的优化:落盘失败不能阻止救援轮次本身。
-  try {
-    await context.setKv(KEY_ROUND_INCOMPLETE, '1');
-  } catch (e) {
-    logger.warn(TAG, `cannot persist round marker: ${getErrorMessage(e)}`);
-  }
+  const configJson = context.getKv(KEY_CONFIG);
+  roundConfigJson = configJson;
+
+  let event: RoundEvent = {
+    type: 'start',
+    config: configJson ?? '',
+    resetGeneration,
+    configGeneration,
+    sample: Math.random(),
+    deadline: 0,
+  };
+  let state: string | undefined = undefined;
+  let marked = false;
   try {
-    await runConfiguredRound(
-      context,
-      launchRolledBackVersion,
-      resetGeneration,
-      configJson,
-    );
+    for (;;) {
+      event.now = monotonicNowMs();
+      const step = JSON.parse(
+        NativePatchCore.stepRound(state, JSON.stringify(event)),
+      ) as RoundStep;
+      state = JSON.stringify(step.state);
+      event = {};
+      for (const command of step.commands) {
+        if (command.type === 'markIncomplete') {
+          // 从这里起本轮开始做真实工作:留下面包屑,死于轮中时下次启动零延迟续传。
+          marked = true;
+          logger.info(
+            TAG,
+            `round started (resume=${!!context.getKv(KEY_ROUND_INCOMPLETE)})`,
+          );
+          // 面包屑只是"下次零延迟"的优化:落盘失败不能阻止救援轮次本身。
+          try {
+            await context.setKv(KEY_ROUND_INCOMPLETE, '1');
+          } catch (e) {
+            logger.warn(TAG, `cannot persist round marker: ${getErrorMessage(e)}`);
+          }
+        } else if (command.type === 'finish') {
+          finishRound(command);
+          return;
+        } else {
+          event = await perform(context, launchRolledBackVersion, command, configGeneration);
+        }
+      }
+    }
   } finally {
-    try {
-      await context.removeKv(KEY_ROUND_INCOMPLETE);
-    } catch (e) {
-      // 残留标记只意味着下次启动少等 5 秒。
-      logger.warn(TAG, `cannot clear round marker: ${getErrorMessage(e)}`);
+    if (marked) {
+      try {
+        await context.removeKv(KEY_ROUND_INCOMPLETE);
+      } catch (e) {
+        // 残留标记只意味着下次启动少等 5 秒。
+        logger.warn(TAG, `cannot clear round marker: ${getErrorMessage(e)}`);
+      }
     }
   }
 }
 
-async function runConfiguredRound(
+// 执行引擎的一条命令,返回回应它的事件。
+async function perform(
   context: UpdateContext,
   launchRolledBackVersion: string,
-  resetGeneration: number,
-  configJson: string,
-): Promise<void> {
-  const currentVersion = context.getCurrentVersion();
-  const env: RoundEnv = {
+  command: RoundCommand,
+  configGeneration: number,
+): Promise<RoundEvent> {
+  switch (command.type) {
+    case 'collectEnv':
+      return { type: 'env', env: await launchEnv(context, launchRolledBackVersion) };
+    case 'http': {
+      const text = await httpRequest(
+        command.url ?? '',
+        command.post ? command.body ?? '' : undefined,
+        command.timeoutMs ?? 0,
+        command.callTimeoutMs ?? 0,
+      );
+      return text === undefined
+        ? { type: 'http' }
+        : { type: 'http', text, at: Date.now() / 1000 };
+    }
+    case 'checkInstalled':
+      return { type: 'installed', installed: context.hasDownloadedVersion(command.hash ?? '') };
+    case 'download':
+      return download(context, command);
+    case 'commit':
+      return commit(context, command, configGeneration);
+    default:
+      // 本适配器不认识的命令:引擎会以 internal_error 结束本轮。
+      return { type: command.type };
+  }
+}
+
+async function launchEnv(
+  context: UpdateContext,
+  launchRolledBackVersion: string,
+): Promise<RoundEnv> {
+  return {
     packageVersion: context.getPackageVersion(),
     // 与 JS 常量同形(无版本时为 ''),JS 才能复用这次请求的响应缓存。
-    currentVersion,
+    currentVersion: context.getCurrentVersion(),
     uuid: context.getKv('uuid') ?? '',
     // getConstants consumes the persisted rollback marker during startup; use
     // the launch-path snapshot captured before that happens.
@@ -273,122 +355,107 @@ async function runConfiguredRound(
     os: `harmony ${deviceInfo.osFullName}`,
     bundleHash: await context.getBundleHash(),
   };
-  const envJson = JSON.stringify(env);
-  const preparedJson = NativePatchCore.prepareRound(configJson, envJson, Math.random());
-  if (!preparedJson) {
-    roundResult = bundlePreparationResult('failed', 'invalid_request');
-    return;
-  }
-  const prepared = JSON.parse(preparedJson) as PreparedRound;
-  const responseText = await runQueryRequest(
-    JSON.stringify(prepared.query),
-    prepared.body,
-  );
-  if (!responseText) {
-    logger.warn(TAG, 'no endpoint reachable, giving up until next launch');
-    return;
-  }
-  // 规划好的 attempts、hashInfo 与响应缓存(时间戳取响应到达时)都来自共享内核。
-  const decisionJson = NativePatchCore.handleResponse(
-    responseText,
-    configJson,
-    envJson,
-    prepared.body,
-    Math.floor(Date.now() / 1000),
-  );
-  if (!decisionJson) {
-    roundResult = bundlePreparationResult('failed', 'invalid_response');
-    return;
-  }
-  const decision = JSON.parse(decisionJson) as Decision;
-  const responseCacheJson = decision.cache ?? '';
-  // Commits the round's persistent outcome (see commitSyncResult) and maps
-  // it to the round result; a reset during the round wins over `result`.
-  const commit = async (
-    hash: string,
-    hashInfoJson: string,
-    activate: boolean,
-    result: BundlePreparationResult,
-  ): Promise<boolean> => {
-    const committed = await context.commitSyncResult(
-      resetGeneration,
-      hash,
-      hashInfoJson,
-      activate,
-      responseCacheJson,
-    );
-    roundResult = committed
-      ? result
-      : bundlePreparationResult('cancelled', 'reset');
-    return committed;
-  };
-
-  if (decision.action !== 'download') {
-    await commit(
-      '',
-      '',
-      false,
-      bundlePreparationResult(STATUS_NONE, decision.reason ?? ''),
-    );
-    logger.info(TAG, `nothing to do (${decision.reason ?? ''})`);
-    return;
-  }
-  const hash = decision.hash ?? '';
-  if (!isSafePathComponent(hash)) {
-    logger.warn(TAG, 'decision carries an unsafe hash, ignoring');
-    roundResult = bundlePreparationResult('failed', 'invalid_response');
-    return;
-  }
+}
 
-  let downloaded = context.hasDownloadedVersion(hash);
-  if (downloaded) {
-    logger.info(TAG, `${hash} already installed, skipping download`);
-  } else {
-    logger.info(TAG, `downloading ${hash}`);
-    downloaded = await performAttempts(
-      context,
-      decision.attempts ?? [],
-      hash,
-      currentVersion,
-    );
-  }
-  if (!downloaded) {
-    logger.warn(TAG, `all download attempts for ${hash} failed`);
-    await commit('', '', false, bundlePreparationResult('failed', 'download_failed'));
-    return;
+// 一次下载尝试,以引擎给的 deadline 为界:超时即 timedOut,失败带错误码
+// (PATCH_FAILED 由引擎决定换策略而不换镜像)。
+async function download(
+  context: UpdateContext,
+  command: RoundCommand,
+): Promise<RoundEvent> {
+  const strategy = command.strategy ?? '';
+  const url = command.url ?? '';
+  const hash = command.hash ?? '';
+  const deadline = command.deadline ?? 0;
+  let timedOut = false;
+  let timer = 0;
+  const expired = new Promise<void>((resolve) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      resolve();
+    }, Math.max(0, deadline - monotonicNowMs()));
+  });
+  // This bounds queueing, HTTP, decompression and native hpatch work from the
+  // round's perspective. The serialized task may still finish later, but it
+  // can no longer hold the round.
+  const start = (): Promise<void> => {
+    if (strategy === 'diff') {
+      return context.downloadPatchFromPpk(url, hash, command.originHash ?? '', deadline);
+    }
+    if (strategy === 'pdiff') {
+      return context.downloadPatchFromPackage(url, hash, deadline);
+    }
+    return context.downloadFullUpdate(url, hash, deadline);
+  };
+  try {
+    await Promise.race([start(), expired]);
+    if (timedOut) {
+      logger.warn(TAG, `${strategy} attempt timed out`);
+      return { type: 'download', timedOut: true };
+    }
+    return { type: 'download', ok: true };
+  } catch (e) {
+    logger.warn(TAG, `${strategy} attempt failed: ${getErrorMessage(e)}`);
+    // 无错误码的失败(网络异常等)可换镜像重试。
+    return e instanceof PushyError
+      ? { type: 'download', ok: false, code: e.code }
+      : { type: 'download', ok: false };
+  } finally {
+    clearTimeout(timer);
   }
+}
 
-  const hashInfoJson = JSON.stringify(decision.hashInfo);
-
-  // 版本元信息、激活与响应缓存一次性原子提交(见 commitSyncResult);
-  // 缓存只在原生文件/状态工作结束后公开,避免 JS 观察到响应后并发下载。
-  // 静默策略、或服务端按版本标记的 forceBoot(远程覆盖,救砖指令)才激活。
-  const activate = decision.activate === true;
-  let committed = false;
+// 版本元信息、激活与响应缓存一次性原子提交(见 commitSyncResult)。配置替换
+// 也会递增 reset 代数,提交因此被拒;配置代数用来区分是哪一种。
+async function commit(
+  context: UpdateContext,
+  command: RoundCommand,
+  configGeneration: number,
+): Promise<RoundEvent> {
   try {
-    committed = await commit(
-      hash,
-      hashInfoJson,
-      activate,
-      bundlePreparationResult('downloaded', '', hash, activate),
+    const committed = await context.commitSyncResult(
+      command.resetGeneration ?? -1,
+      command.hash ?? '',
+      command.hashInfo ?? '',
+      command.activate === true,
+      command.cache ?? '',
     );
+    if (!committed && context.getNativeConfigGeneration() !== configGeneration) {
+      return { type: 'committed', ok: false, reason: 'config_changed' };
+    }
+    return { type: 'committed', ok: committed };
   } catch (e) {
     logger.error(TAG, `commit failed: ${getErrorMessage(e)}`);
-    roundResult = bundlePreparationResult('failed', 'commit_failed');
-    return;
+    return { type: 'committed', ok: false, error: true };
   }
-  if (!committed) {
-    logger.warn(TAG, 'reset during round, dropping result');
-  } else if (activate) {
-    logger.info(TAG, `downloaded ${hash} and set for next launch`);
-  } else {
-    logger.info(TAG, `downloaded ${hash}, activation left to JS`);
+}
+
+function finishRound(finish: RoundCommand): void {
+  const status = finish.status ?? 'failed';
+  const reason = finish.reason ?? '';
+  if (status === 'downloaded') {
+    const hash = finish.hash ?? '';
+    const activated = finish.activated === true;
+    logger.info(
+      TAG,
+      activated
+        ? `downloaded ${hash} and set for next launch`
+        : `downloaded ${hash}, activation left to JS`,
+    );
+    roundResult = bundlePreparationResult(status, reason, hash, activated);
+    return;
   }
+  logger.info(TAG, `${status} (${reason})`);
+  roundResult = bundlePreparationResult(status, reason);
 }
 
+// The engine's per-request bounds: timeoutMs for connect/read, callTimeoutMs
+// for the whole call.
 async function httpRequest(
   url: string,
-  postBody?: string,
+  postBody: string | undefined,
+  timeoutMs: number,
+  callTimeoutMs: number,
 ): Promise<string | undefined> {
   const client = http.createHttp();
   let callTimer: number | null = null;
@@ -403,14 +470,14 @@ async function httpRequest(
         : http.RequestMethod.GET,
       header,
       extraData: postBody,
-      connectTimeout: REQUEST_TIMEOUT_MS,
-      readTimeout: REQUEST_TIMEOUT_MS,
+      connectTimeout: Math.max(1, Math.floor(timeoutMs)),
+      readTimeout: Math.max(1, Math.floor(timeoutMs)),
       expectDataType: http.HttpDataType.STRING,
     });
     const timeoutPromise = new Promise<http.HttpResponse>((_, reject) => {
       callTimer = setTimeout(() => {
-        reject(Error(`HTTP request exceeded ${REQUEST_CALL_TIMEOUT_MS}ms`));
-      }, REQUEST_CALL_TIMEOUT_MS);
+        reject(Error(`HTTP request exceeded ${callTimeoutMs}ms`));
+      }, Math.max(0, callTimeoutMs));
     });
     const response = await Promise.race([requestPromise, timeoutPromise]);
     if (
@@ -430,123 +497,3 @@ async function httpRequest(
     client.destroy();
   }
 }
-
-// 顺序回退(§5.1):按共享内核给出的下一步逐个请求,单请求超时
-// (NativePatchCore.nextQueryStep:候选序、queryUrls 发现、远程端点的 https
-// 门槛、请求预算、响应 schema)。刻意不做 hedged race——该路径对延迟不敏感。
-async function runQueryRequest(
-  query: string,
-  body: string,
-): Promise<string | undefined> {
-  let state: string | undefined = query;
-  let text: string | undefined = undefined;
-  while (state !== undefined) {
-    state = NativePatchCore.nextQueryStep(state, text);
-    if (state === undefined) {
-      break;
-    }
-    const step = JSON.parse(state) as QueryStep;
-    if (step.found) {
-      return text;
-    }
-    if (!step.url) {
-      break;
-    }
-    text = await httpRequest(step.url, step.post ? body : undefined);
-  }
-  return undefined;
-}
-
-async function runWithinDeadline(
-  start: () => Promise<void>,
-  deadlineUptimeMs: number,
-): Promise<void> {
-  const remainingMs = deadlineUptimeMs - monotonicNowMs();
-  if (remainingMs <= 0) {
-    throw createPushyError(
-      ERROR_DOWNLOAD_FAILED,
-      'Download phase deadline expired before start',
-    );
-  }
-  let deadlineTimer = 0;
-  const deadlinePromise = new Promise<void>((_, reject) => {
-    deadlineTimer = setTimeout(() => {
-      reject(
-        createPushyError(
-          ERROR_DOWNLOAD_FAILED,
-          'Download phase deadline exceeded',
-        ),
-      );
-    }, remainingMs);
-  });
-  try {
-    // This bounds queueing, HTTP, decompression and native hpatch work from
-    // the orchestrator's perspective. The serialized task may still finish
-    // later, but it can no longer prevent the response cache from settling.
-    await Promise.race([start(), deadlinePromise]);
-  } finally {
-    clearTimeout(deadlineTimer);
-  }
-}
-
-async function performAttempts(
-  context: UpdateContext,
-  attempts: DecisionAttempt[],
-  hash: string,
-  originHash: string,
-): Promise<boolean> {
-  const incrementalDeadline = monotonicNowMs() + DOWNLOAD_PHASE_TIMEOUT_MS;
-  let fullDeadline = 0;
-  for (const attempt of attempts) {
-    const type = attempt.type ?? '';
-    const isFullAttempt =
-      type !== DOWNLOAD_TYPE_DIFF && type !== DOWNLOAD_TYPE_PDIFF;
-    if (isFullAttempt && fullDeadline === 0) {
-      // Preserve a full 10min rescue budget even when diff/pdiff exhausted
-      // their own phase window.
-      fullDeadline = monotonicNowMs() + DOWNLOAD_PHASE_TIMEOUT_MS;
-    }
-    const deadline = isFullAttempt ? fullDeadline : incrementalDeadline;
-    for (const url of attempt.urls ?? []) {
-      if (monotonicNowMs() >= deadline) {
-        if (isFullAttempt) {
-          return false;
-        }
-        break;
-      }
-      try {
-        if (type === DOWNLOAD_TYPE_DIFF) {
-          await runWithinDeadline(
-            () => context.downloadPatchFromPpk(url, hash, originHash, deadline),
-            deadline,
-          );
-        } else if (type === DOWNLOAD_TYPE_PDIFF) {
-          await runWithinDeadline(
-            () => context.downloadPatchFromPackage(url, hash, deadline),
-            deadline,
-          );
-        } else {
-          await runWithinDeadline(
-            () => context.downloadFullUpdate(url, hash, deadline),
-            deadline,
-          );
-        }
-        return true;
-      } catch (e) {
-        logger.warn(TAG, `${type} attempt failed: ${getErrorMessage(e)}`);
-        if (!isMirrorRetryable(e)) {
-          // The bytes arrived but could not be applied: every mirror serves
-          // the same artifact, so move on to the next strategy instead of
-          // re-downloading it (update_flow_core IsMirrorRetryableCode, JS
-          // client.ts isMirrorRetryableCode).
-          break;
-        }
-      }
-    }
-  }
-  return false;
-}
-
-function isMirrorRetryable(error: unknown): boolean {
-  return !(error instanceof PushyError && error.code === ERROR_DELTA_FAILED);
-}