rn-update 1.0.0

package/src/context.ts

@@ -0,0 +1,102 @@
+/**
+ * [INPUT]: 依赖 React Context/hooks、client 的客户端类型、i18n 与 type 的检查结果和进度模型
+ * [OUTPUT]: 对外提供 defaultContext、UpdateContext、ProgressContext、异步成功确认及 useUpdateProgress/useUpdate/usePakta hooks
+ * [POS]: src 的 React 状态读取边界，将高频进度与低频更新状态隔离，由 Provider 写入并由业务组件消费
+ */
+import { createContext, useContext, useMemo } from 'react';
+import type { Pakta } from './client';
+import i18n from './i18n';
+import type { CheckResult, ProgressData, UpdateTestPayload } from './type';
+
+const noop = () => {};
+const asyncNoop = () => Promise.resolve(undefined);
+
+/**
+ * What UpdateProvider puts into UpdateContext (and useUpdate() returns, plus
+ * `progress`). The signatures mirror the provider's callbacks: the `info`
+ * parameters default to the last check result, `checkUpdate` accepts request
+ * extras, and the mutations resolve once the client is done.
+ */
+export interface UpdateContextValue {
+  checkUpdate: (params?: {
+    extra?: Partial<{ toHash: string }>;
+  }) => Promise<undefined | CheckResult>;
+  /** Resolves true once the native reload was requested; false when skipped. */
+  switchVersion: (info?: CheckResult) => Promise<boolean | undefined>;
+  switchVersionLater: (info?: CheckResult) => Promise<void>;
+  markSuccess: () => Promise<boolean | undefined>;
+  dismissError: () => void;
+  downloadUpdate: (info?: CheckResult) => Promise<boolean | undefined>;
+  downloadAndInstallApk: (url: string) => Promise<void>;
+  // @deprecated use currentVersionInfo instead
+  getCurrentVersionInfo: () => Promise<{
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+  }>;
+  currentVersionInfo: {
+    name?: string;
+    description?: string;
+    metaInfo?: string;
+  } | null;
+  parseTestQrCode: (code: string | UpdateTestPayload) => boolean;
+  restartApp: () => Promise<void>;
+  resetToPackagedBundle: (options?: {
+    restart?: boolean;
+  }) => Promise<boolean | undefined>;
+  currentHash: string;
+  packageVersion: string;
+  client?: Pakta;
+  updateInfo?: CheckResult;
+  lastError?: Error;
+}
+
+export const defaultContext: UpdateContextValue = {
+  checkUpdate: asyncNoop,
+  switchVersion: asyncNoop,
+  switchVersionLater: asyncNoop,
+  markSuccess: asyncNoop,
+  dismissError: noop,
+  downloadUpdate: asyncNoop,
+  downloadAndInstallApk: asyncNoop,
+  restartApp: asyncNoop,
+  resetToPackagedBundle: asyncNoop,
+  getCurrentVersionInfo: () => Promise.resolve({}),
+  parseTestQrCode: () => false,
+  currentHash: '',
+  packageVersion: '',
+  currentVersionInfo: {},
+};
+
+export const UpdateContext = createContext<UpdateContextValue>(defaultContext);
+
+// Download progress ticks at high frequency, so it lives in its own context;
+// otherwise every tick would re-render all useUpdate() consumers even when
+// they never read progress.
+export const ProgressContext = createContext<ProgressData | undefined>(
+  undefined
+);
+
+/**
+ * Subscribe to download progress only. Components that render a progress bar
+ * should prefer this over useUpdate() so the rest of the tree is not
+ * re-rendered on every progress event.
+ */
+export const useUpdateProgress = () => useContext(ProgressContext);
+
+export const useUpdate = (): UpdateContextValue & {
+  progress?: ProgressData;
+} => {
+  const context = useContext(UpdateContext);
+  const progress = useContext(ProgressContext);
+
+  if (__DEV__ && !context.client) {
+    // 检查是否在 UpdateProvider 内部使用
+    throw new Error(i18n.t('error_use_update_outside_provider'));
+  }
+
+  return useMemo(() => ({ ...context, progress }), [context, progress]);
+};
+
+/** Pakta-flavoured name for the shared update context hook. */
+export const usePakta = useUpdate;

package/src/core.ts

@@ -0,0 +1,190 @@
+/**
+ * [INPUT]: 依赖 react-native 的 NativeModules/NativeEventEmitter/Platform、Codegen NativePakta、错误与国际化服务及空模块工具
+ * [OUTPUT]: 对外提供 PaktaModule/UpdateModule、原生版本常量、bundle hash/版本信息访问器、事件发射器与设备上报信息 cInfo
+ * [POS]: src 的原生桥接适配器，屏蔽 TurboModule 与旧桥差异，为 client 提供稳定且平台无关的运行时状态
+ */
+import { NativeEventEmitter, NativeModules, Platform } from 'react-native';
+import { UpdateError } from './error';
+import i18n from './i18n';
+import { emptyModule, error, log } from './utils';
+
+/* eslint-disable @react-native/no-deep-imports */
+const {
+  version: v,
+} = require('react-native/Libraries/Core/ReactNativeVersion');
+const RNVersion = `${v.major}.${v.minor}.${v.patch}`;
+const isTurboModuleEnabled =
+  // https://github.com/facebook/react-native/pull/48362
+  (global as any).__turboModuleProxy || (global as any).RN$Bridgeless;
+
+const isWebPlatform = Platform.OS === 'web';
+
+export const PaktaModule = isWebPlatform
+  ? emptyModule
+  : isTurboModuleEnabled
+    ? require('./NativePakta').default
+    : NativeModules.Pakta;
+
+export const UpdateModule = PaktaModule;
+
+if (!PaktaModule) {
+  throw new UpdateError(
+    'Failed to load rn-update native module, please try to recompile',
+    'MODULE_NOT_LOADED'
+  );
+}
+
+// On web PaktaModule is a Proxy whose every property is a noop function, so
+// reading the constants off it would make each of them a function:
+// `isRolledBack` true (a fake rollback report on every page load), a uuid of
+// "() => {}", JSON.parse failing on currentVersionInfo. Web has no native
+// state at all, so its constants are the explicit empty ones.
+const PaktaConstants: Record<string, any> = isWebPlatform
+  ? {
+      downloadRootDir: '',
+      packageVersion: '',
+      currentVersion: '',
+      isFirstTime: false,
+      rolledBackVersion: '',
+      buildTime: '',
+      channel: 'default',
+      uuid: '',
+      currentVersionInfo: '',
+      supportedDiffVersion: 0,
+      currentBundleSha256: '',
+    }
+  : isTurboModuleEnabled
+    ? PaktaModule.getConstants()
+    : PaktaModule;
+
+export const downloadRootDir: string = PaktaConstants.downloadRootDir;
+export const packageVersion: string = PaktaConstants.packageVersion;
+export const currentVersion: string = PaktaConstants.currentVersion;
+
+export function setLocalHashInfo(
+  hash: string,
+  info: Record<string, any>
+): Promise<void> {
+  // Always a promise so callers can await native persistence (the legacy
+  // bridge returns undefined when no promise is exposed).
+  return Promise.resolve(
+    PaktaModule.setLocalHashInfo(hash, JSON.stringify(info))
+  );
+}
+
+const currentVersionInfoString: string = PaktaConstants.currentVersionInfo;
+let _currentVersionInfo: Record<string, any> = {};
+let isDebugChannel = false;
+if (currentVersionInfoString) {
+  try {
+    _currentVersionInfo = JSON.parse(currentVersionInfoString);
+    if (_currentVersionInfo.debugChannel) {
+      isDebugChannel = true;
+      delete _currentVersionInfo.debugChannel;
+      setLocalHashInfo(currentVersion, _currentVersionInfo).catch((e) => {
+        error('failed to persist version info', e);
+      });
+    }
+  } catch {
+    error(
+      i18n.t('error_parse_version_info', { info: currentVersionInfoString })
+    );
+  }
+}
+export const currentVersionInfo = _currentVersionInfo;
+/** SHA-256 of the running hot-update bundle from its install record; '' when unknown. */
+export const currentBundleSha256: string =
+  typeof PaktaConstants.currentBundleSha256 === 'string'
+    ? PaktaConstants.currentBundleSha256
+    : '';
+
+export const isFirstTime: boolean = PaktaConstants.isFirstTime;
+export const isFirstTimeDebug: boolean = isFirstTime && isDebugChannel;
+export const rolledBackVersion: string = PaktaConstants.rolledBackVersion;
+export const isRolledBack: boolean = !!rolledBackVersion;
+
+export const buildTime: string = PaktaConstants.buildTime;
+/** Immutable distribution channel declared by the native binary. */
+export const channel: string =
+  typeof PaktaConstants.channel === 'string' && PaktaConstants.channel
+    ? PaktaConstants.channel
+    : 'default';
+// 原生 patch 内核可消费的 diff 轨道版本(2 = hdiffv2 轨道:HBC 变换 +
+// 流式容器);旧原生无此常量时为 0(不上报,服务端只发 baseline)
+export const supportedDiffVersion: number =
+  PaktaConstants.supportedDiffVersion || 0;
+let uuid = PaktaConstants.uuid;
+
+// bundleHash = sha256 of the JS bundle embedded in the binary (the pdiff
+// source). Content identity for the server's pdiff-applicability check,
+// replacing the buildTime heuristic. Natively lazy-computed and cached;
+// prefetched fire-and-forget at module load so the value is usually settled
+// before the first checkUpdate builds its body. Until then (first install,
+// slow device) getBundleHash returns '' and the field is simply omitted — the
+// server falls back to the buildTime heuristic and the next check carries it.
+// Deliberately synchronous at read time: checkUpdate must not await anything
+// between its dedup window and the fetch, and a hash is never worth delaying
+// a check for.
+let bundleHash = '';
+// The JS layer can arrive via hot update onto an older binary whose native
+// module predates the method, hence the feature detect (on web the noop Proxy
+// would pass it, so web is excluded explicitly).
+if (!isWebPlatform && typeof PaktaModule.getBundleHash === 'function') {
+  Promise.resolve(PaktaModule.getBundleHash())
+    .then((hash: unknown) => {
+      bundleHash = String(hash || '');
+    })
+    .catch((e: any) => {
+      log('getBundleHash failed:', e?.message || e);
+    });
+}
+
+/** '' while unknown (not yet computed, debug build, no embedded bundle, older native). */
+export const getBundleHash = (): string => bundleHash;
+
+// Natives resolve null/'' when no record exists for the hash (only a record
+// that exists and is not a JSON object rejects with INVALID_HASH_INFO).
+async function getLocalHashInfo(hash: string) {
+  const raw = await PaktaModule.getLocalHashInfo(hash);
+  return raw ? JSON.parse(raw) : null;
+}
+
+// @deprecated use currentVersionInfo instead
+export async function getCurrentVersionInfo(): Promise<{
+  name?: string;
+  description?: string;
+  metaInfo?: string;
+}> {
+  return currentVersion ? (await getLocalHashInfo(currentVersion)) || {} : {};
+}
+
+export const paktaNativeEventEmitter = new NativeEventEmitter(PaktaModule);
+
+if (!uuid) {
+  uuid = require('nanoid/non-secure').nanoid();
+  // If persisting fails the uuid drifts on every launch, which skews gray
+  // release bucketing and inflates stats — log it instead of failing silently.
+  // Web has nowhere to persist it (nothing runs there anyway).
+  if (!isWebPlatform) {
+    Promise.resolve(PaktaModule.setUuid(uuid)).catch((e: any) => {
+      log('setUuid error:', e?.message || e);
+    });
+  }
+}
+
+export const cInfo = {
+  rnu: require('../package.json').version,
+  rn: RNVersion,
+  os: `${Platform.OS} ${Platform.Version}`,
+  uuid,
+};
+
+log('bootup status', {
+  packageVersion,
+  currentVersion,
+  currentVersionInfo,
+  isFirstTime,
+  isFirstTimeDebug,
+  isDebugChannel,
+  cInfo,
+});

package/src/endpoint.ts

@@ -0,0 +1,204 @@
+/**
+ * [INPUT]: 依赖 UpdateError 统一失败语义，并依赖 updateFlowCore 的端点去重与候选排序纯规则
+ * [OUTPUT]: 对外提供端点尝试结果类型、DEFAULT_HEDGE_DELAY_MS、最快成功选择器、dedupeEndpoints 与 executeEndpointFallback
+ * [POS]: src 的网络韧性适配层，在业务请求外包裹并发 hedge、超时、失败聚合与确定性回退，主要由 client 消费
+ */
+import { UpdateError } from './error';
+import i18n from './i18n';
+import { dedupeEndpoints, orderEndpointCandidates } from './updateFlowCore';
+
+export { dedupeEndpoints };
+
+export interface EndpointAttemptSuccess<T> {
+  endpoint: string;
+  value: T;
+  duration: number;
+}
+
+export interface EndpointAttemptFailure {
+  endpoint: string;
+  error: Error;
+}
+
+export interface ExecuteEndpointFallbackOptions<T> {
+  configuredEndpoints: string[];
+  getRemoteEndpoints?: () => Promise<string[]>;
+  tryEndpoint: (endpoint: string, signal?: AbortSignal) => Promise<T>;
+  random?: () => number;
+  now?: () => number;
+  hedgeDelayMs?: number;
+  onFirstFailure?: (failure: EndpointAttemptFailure) => void | Promise<void>;
+}
+
+const normalizeError = (error: unknown) => {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+};
+
+export const DEFAULT_HEDGE_DELAY_MS = 250;
+
+/**
+ * Hedged race over the candidate endpoints: the first candidate starts
+ * immediately, each following one is only started after `hedgeDelayMs` of
+ * silence (or immediately when a previous attempt failed). The first
+ * successful response wins and every other in-flight request is aborted, so
+ * one slow endpoint never gates a fast one, and healthy rounds send a single
+ * request instead of blasting every candidate at once.
+ */
+export function selectFastestSuccessfulEndpoint<T>(
+  endpoints: string[],
+  tryEndpoint: (endpoint: string, signal?: AbortSignal) => Promise<T>,
+  now: () => number = Date.now,
+  hedgeDelayMs: number = DEFAULT_HEDGE_DELAY_MS
+): Promise<{
+  success?: EndpointAttemptSuccess<T>;
+  failures: EndpointAttemptFailure[];
+}> {
+  return new Promise((resolve) => {
+    if (!endpoints.length) {
+      resolve({ failures: [] });
+      return;
+    }
+
+    const failures: EndpointAttemptFailure[] = [];
+    const controllers: AbortController[] = [];
+    let nextIndex = 0;
+    let pending = 0;
+    let settled = false;
+    let hedgeTimer: ReturnType<typeof setTimeout> | undefined;
+
+    const finish = (success?: EndpointAttemptSuccess<T>) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (hedgeTimer) {
+        clearTimeout(hedgeTimer);
+      }
+      for (const controller of controllers) {
+        controller.abort();
+      }
+      resolve({ success, failures });
+    };
+
+    const launchNext = () => {
+      if (hedgeTimer) {
+        clearTimeout(hedgeTimer);
+        hedgeTimer = undefined;
+      }
+      if (settled || nextIndex >= endpoints.length) {
+        return;
+      }
+      const endpoint = endpoints[nextIndex++];
+      const controller =
+        typeof AbortController === 'undefined'
+          ? undefined
+          : new AbortController();
+      if (controller) {
+        controllers.push(controller);
+      }
+      pending++;
+      const start = now();
+      tryEndpoint(endpoint, controller?.signal)
+        .then((value) => {
+          if (controller) {
+            // Only the losing requests get aborted, not the winner's own
+            // (already settled) one.
+            const index = controllers.indexOf(controller);
+            if (index >= 0) {
+              controllers.splice(index, 1);
+            }
+          }
+          finish({ endpoint, value, duration: now() - start });
+        })
+        .catch((error) => {
+          pending--;
+          if (settled) {
+            // Losers cancelled after a win must not count as failures.
+            return;
+          }
+          failures.push({ endpoint, error: normalizeError(error) });
+          if (nextIndex < endpoints.length) {
+            // A failure frees its slot: hedge the next candidate right away
+            // instead of waiting out the stagger.
+            launchNext();
+          } else if (pending === 0) {
+            finish(undefined);
+          }
+        });
+      if (!settled && nextIndex < endpoints.length) {
+        hedgeTimer = setTimeout(launchNext, hedgeDelayMs);
+      }
+    };
+
+    launchNext();
+  });
+}
+
+export async function executeEndpointFallback<T>({
+  configuredEndpoints,
+  getRemoteEndpoints,
+  tryEndpoint,
+  random = Math.random,
+  now = Date.now,
+  hedgeDelayMs = DEFAULT_HEDGE_DELAY_MS,
+  onFirstFailure,
+}: ExecuteEndpointFallbackOptions<T>): Promise<EndpointAttemptSuccess<T>> {
+  const excludedEndpoints = new Set<string>();
+  // The candidate ordering (random first pick, configured order as fallback)
+  // is pure policy; this side only executes it.
+  let candidates = orderEndpointCandidates(configuredEndpoints, random());
+
+  if (!candidates.length) {
+    throw new UpdateError(i18n.t('error_no_endpoints'), 'NO_ENDPOINTS');
+  }
+
+  const firstEndpoint = candidates[0];
+
+  try {
+    return {
+      endpoint: firstEndpoint,
+      value: await tryEndpoint(firstEndpoint),
+      duration: 0,
+    };
+  } catch (error) {
+    const firstFailure = {
+      endpoint: firstEndpoint,
+      error: normalizeError(error),
+    };
+    excludedEndpoints.add(firstEndpoint);
+    await onFirstFailure?.(firstFailure);
+    let lastError = firstFailure.error;
+
+    while (true) {
+      const remoteEndpoints = getRemoteEndpoints
+        ? await getRemoteEndpoints().catch(() => [])
+        : [];
+      candidates = dedupeEndpoints([...candidates, ...remoteEndpoints]).filter(
+        (endpoint) => !excludedEndpoints.has(endpoint)
+      );
+
+      if (!candidates.length) {
+        throw lastError;
+      }
+
+      const { success, failures } = await selectFastestSuccessfulEndpoint(
+        candidates,
+        tryEndpoint,
+        now,
+        hedgeDelayMs
+      );
+
+      if (success) {
+        return success;
+      }
+
+      for (const failure of failures) {
+        excludedEndpoints.add(failure.endpoint);
+        lastError = failure.error;
+      }
+    }
+  }
+}

package/src/error.ts

@@ -0,0 +1,168 @@
+/**
+ * [INPUT]: 依赖共享原生错误码约定与 JavaScript Error/cause 语义，不依赖 UI 或网络实现
+ * [OUTPUT]: 对外提供 UpdateErrorCode、asUpdateErrorCode、UpdateError 与 toUpdateError 归一化入口
+ * [POS]: src 的跨层错误语义边界，把平台异常转换为可稳定聚合、上报和分支处理的机器码
+ */
+/**
+ * Stable, machine-readable error codes. Unlike messages (which are localized
+ * and vary across platforms), codes are safe to aggregate on in a logger.
+ *
+ * The native-originated codes (second group) are defined in
+ * cpp/patch_core/error_codes.h — the single source of truth shared by the
+ * Android/iOS/Harmony modules — and flow through promise rejections onto the
+ * `code` property, which toUpdateError() preserves.
+ */
+export type UpdateErrorCode =
+  // JS-layer codes
+  | 'MODULE_NOT_LOADED'
+  | 'APPKEY_REQUIRED'
+  | 'NO_ENDPOINTS'
+  | 'HTTP_STATUS'
+  // A 2xx check response that is not a check verdict (schema gate).
+  | 'INVALID_RESPONSE'
+  | 'CHECK_FAILED'
+  | 'DOWNLOAD_FAILED'
+  | 'SWITCH_VERSION_FAILED'
+  | 'MARK_SUCCESS_FAILED'
+  | 'APK_INSTALL_PENDING'
+  | 'APK_DOWNLOAD_FAILED'
+  // A throw from a user-provided hook (e.g. beforeReload) — not an update
+  // pipeline failure, and excluded from server-side patch-health telemetry.
+  | 'USER_HOOK_ERROR'
+  // A second client/provider in the same process — a hard integration error;
+  // the SDK is a process-level singleton.
+  | 'SINGLETON_VIOLATION'
+  // Native codes (see cpp/patch_core/error_codes.h)
+  | 'INVALID_OPTIONS'
+  | 'PATCH_FAILED'
+  | 'FILE_OPERATION_FAILED'
+  | 'RESTART_FAILED'
+  | 'RESET_FAILED'
+  | 'INVALID_HASH_INFO'
+  | 'UNSUPPORTED_PLATFORM'
+  | 'APK_INSTALL_PERMISSION_REQUIRED'
+  | 'APK_INSTALL_FAILED';
+
+const KNOWN_CODES = new Set<string>([
+  'MODULE_NOT_LOADED',
+  'APPKEY_REQUIRED',
+  'NO_ENDPOINTS',
+  'HTTP_STATUS',
+  'INVALID_RESPONSE',
+  'CHECK_FAILED',
+  'DOWNLOAD_FAILED',
+  'SWITCH_VERSION_FAILED',
+  'MARK_SUCCESS_FAILED',
+  'APK_INSTALL_PENDING',
+  'APK_DOWNLOAD_FAILED',
+  'USER_HOOK_ERROR',
+  'SINGLETON_VIOLATION',
+  'INVALID_OPTIONS',
+  'PATCH_FAILED',
+  'FILE_OPERATION_FAILED',
+  'RESTART_FAILED',
+  'RESET_FAILED',
+  'INVALID_HASH_INFO',
+  'UNSUPPORTED_PLATFORM',
+  'APK_INSTALL_PERMISSION_REQUIRED',
+  'APK_INSTALL_FAILED',
+]);
+
+/**
+ * Narrow an arbitrary `code` property (axios' ERR_NETWORK, Node's
+ * ECONNREFUSED, RN's default EUNSPECIFIED, ...) to our stable set; anything
+ * else is treated as absent so it never leaks into telemetry aggregation.
+ */
+export const asUpdateErrorCode = (
+  code: unknown
+): UpdateErrorCode | undefined =>
+  typeof code === 'string' && KNOWN_CODES.has(code)
+    ? (code as UpdateErrorCode)
+    : undefined;
+
+// A bridge that cannot put the code on the rejection's `code` property
+// (Harmony's TurboModule rejections carry only a message) prefixes the
+// message with it instead: `[PATCH_FAILED] copiesCrc mismatch`.
+const CODED_MESSAGE = /^\[([A-Z_]+)\] /;
+
+/**
+ * The stable code a thrown value carries, if any, and its message with the
+ * `[CODE] ` prefix (see CODED_MESSAGE) stripped. A `code` property wins over
+ * the prefix; an unknown code in either place counts as absent.
+ */
+export const readErrorCode = (
+  e: unknown
+): { code?: UpdateErrorCode; message: string } => {
+  const source =
+    e !== null && typeof e === 'object'
+      ? (e as { code?: unknown; message?: unknown })
+      : undefined;
+  const raw =
+    typeof e === 'string'
+      ? e
+      : typeof source?.message === 'string'
+        ? source.message
+        : '';
+  const match = CODED_MESSAGE.exec(raw);
+  const prefixed = match ? asUpdateErrorCode(match[1]) : undefined;
+  return {
+    code: asUpdateErrorCode(source?.code) ?? prefixed,
+    message: prefixed && match ? raw.slice(match[0].length) : raw,
+  };
+};
+
+export class UpdateError extends Error {
+  code: UpdateErrorCode;
+  cause?: unknown;
+  extra?: Record<string, string | number>;
+
+  constructor(
+    message: string,
+    code: UpdateErrorCode,
+    options?: { cause?: unknown; extra?: Record<string, string | number> }
+  ) {
+    super(message);
+    this.name = 'UpdateError';
+    this.code = code;
+    this.cause = options?.cause;
+    this.extra = options?.extra;
+  }
+}
+
+/**
+ * Attach a code to an unknown thrown value. An existing Error keeps its
+ * identity (message, stack, and any known code already assigned upstream) so
+ * callers comparing the caught error to the original still match; non-Error
+ * values are wrapped. A code carried as a `[CODE] ` message prefix is moved
+ * onto the `code` property (and off the message) exactly as if the bridge
+ * had set it. A foreign `code` (axios/system errors) is overwritten with
+ * ours; a frozen/sealed Error that rejects the assignment is wrapped instead
+ * (identity is lost only in that edge case).
+ */
+export const toUpdateError = (
+  e: unknown,
+  code: UpdateErrorCode
+): UpdateError => {
+  if (e instanceof Error) {
+    const err = e as UpdateError;
+    if (!asUpdateErrorCode(err.code)) {
+      const parsed = readErrorCode(err);
+      const resolved = parsed.code ?? code;
+      try {
+        err.code = resolved;
+        if (parsed.code) {
+          err.message = parsed.message;
+        }
+      } catch {}
+      if (err.code !== resolved) {
+        return new UpdateError(parsed.message, resolved, { cause: err });
+      }
+    }
+    return err;
+  }
+  const parsed = readErrorCode(e);
+  return new UpdateError(
+    parsed.code ? parsed.message : String(e ?? code),
+    parsed.code ?? code
+  );
+};