@hot-updater/react-native 1.0.0-rc.4 → 1.0.0-rc.41

package/src/releaseCatalogCache.ts

@@ -1,17 +1,16 @@
 import {
-  MAX_TARGET_COHORTS_PER_RELEASE,
-  MAX_COMPILED_CATALOG_BYTES,
-  MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE,
-  NUMERIC_COHORT_SIZE,
-  isUUIDv7,
-  parseReleaseCatalogScopeKey,
+  type ExpectedReleaseCatalogScope,
+  getUtf8ByteLength,
+  MAX_RELEASE_CATALOG_WIRE_BYTES,
+  parseReleaseCatalog,
   type ReleaseCatalog,
-} from "@hot-updater/core";
+} from "@hot-updater/protocol";
+
+import { fetchUpdateResponse, type UpdateRequest } from "./fetchUpdateResponse";
+import { InvalidUpdateResponseError, UpdateHttpError } from "./updateError";
 
 const CACHE_FORMAT_VERSION = "1";
 const MAX_ETAG_BYTES = 1024;
-export const MAX_RELEASE_CATALOG_WIRE_BYTES =
-  MAX_COMPILED_CATALOG_BYTES * 2 + 4 * 1024;
 export const MAX_RELEASE_CATALOG_CACHE_ENTRY_BYTES =
   MAX_RELEASE_CATALOG_WIRE_BYTES + MAX_ETAG_BYTES + 3;
 
@@ -46,137 +45,13 @@ let lastParsedCache:
     })
   | null = null;
 
-export type ExpectedReleaseCatalogScope = {
-  readonly channelKey: string;
-  readonly platform: "ios" | "android";
-} & (
-  | {
-      readonly strategy: "APP_VERSION";
-      readonly fingerprintHash?: never;
-    }
-  | {
-      readonly strategy: "FINGERPRINT";
-      readonly fingerprintHash: string;
-    }
-);
-
 type FetchReleaseCatalogInput = {
   readonly baseURL: string;
   readonly expectedScope: ExpectedReleaseCatalogScope;
   readonly requestHeaders?: Record<string, string>;
   readonly requestTimeout?: number;
   readonly url: string;
-};
-
-const getUtf8ByteLength = (value: string): number => {
-  let bytes = 0;
-  for (let index = 0; index < value.length; index += 1) {
-    const code = value.charCodeAt(index);
-    if (code <= 0x7f) {
-      bytes += 1;
-    } else if (code <= 0x7ff) {
-      bytes += 2;
-    } else if (
-      code >= 0xd800 &&
-      code <= 0xdbff &&
-      index + 1 < value.length &&
-      value.charCodeAt(index + 1) >= 0xdc00 &&
-      value.charCodeAt(index + 1) <= 0xdfff
-    ) {
-      bytes += 4;
-      index += 1;
-    } else {
-      bytes += 3;
-    }
-  }
-  return bytes;
-};
-
-const isStringArray = (value: unknown): value is readonly string[] =>
-  Array.isArray(value) && value.every((entry) => typeof entry === "string");
-
-const isValidReleaseDescriptor = (value: unknown): boolean => {
-  if (value === null || typeof value !== "object") return false;
-  const descriptor = value as Record<string, unknown>;
-
-  return (
-    isUUIDv7(descriptor.releaseId) &&
-    (descriptor.kind === "BUNDLE" || descriptor.kind === "EMBEDDED") &&
-    ((descriptor.kind === "BUNDLE" &&
-      typeof descriptor.bundleId === "string") ||
-      (descriptor.kind === "EMBEDDED" && descriptor.bundleId === null)) &&
-    Number.isSafeInteger(descriptor.rolloutCohortCount) &&
-    (descriptor.rolloutCohortCount as number) >= 0 &&
-    (descriptor.rolloutCohortCount as number) <= NUMERIC_COHORT_SIZE &&
-    isStringArray(descriptor.targetCohorts) &&
-    descriptor.targetCohorts.length <= MAX_TARGET_COHORTS_PER_RELEASE &&
-    typeof descriptor.shouldForceUpdate === "boolean" &&
-    (descriptor.message === null || typeof descriptor.message === "string")
-  );
-};
-
-export const hasExpectedReleaseCatalogScope = (
-  catalog: ReleaseCatalog,
-  expected: ExpectedReleaseCatalogScope,
-): boolean => {
-  try {
-    const parsed = parseReleaseCatalogScopeKey(catalog.scopeKey);
-    return (
-      parsed.channelKey === expected.channelKey &&
-      parsed.platform === expected.platform &&
-      parsed.strategy === expected.strategy &&
-      (parsed.strategy === "APP_VERSION" ||
-        (expected.strategy === "FINGERPRINT" &&
-          parsed.fingerprintHash === expected.fingerprintHash))
-    );
-  } catch {
-    return false;
-  }
-};
-
-const parseValidatedCatalog = (
-  value: string,
-  expectedScope: ExpectedReleaseCatalogScope,
-): ReleaseCatalog | null => {
-  if (getUtf8ByteLength(value) > MAX_RELEASE_CATALOG_WIRE_BYTES) return null;
-
-  try {
-    const catalog = JSON.parse(value) as Partial<ReleaseCatalog>;
-    if (
-      catalog.schemaVersion !== 1 ||
-      typeof catalog.catalogId !== "string" ||
-      catalog.catalogId.length === 0 ||
-      typeof catalog.scopeKey !== "string" ||
-      !Number.isSafeInteger(catalog.generation) ||
-      (catalog.generation ?? 0) < 1 ||
-      typeof catalog.catalogHash !== "string" ||
-      !/^sha256:[0-9a-f]{64}$/.test(catalog.catalogHash) ||
-      catalog.fallbackPolicy !== "BUILTIN_IF_ACTIVE_INELIGIBLE" ||
-      !Array.isArray(catalog.releases) ||
-      !catalog.releases.every(isValidReleaseDescriptor) ||
-      (catalog.rollbackReleases !== undefined &&
-        (!Array.isArray(catalog.rollbackReleases) ||
-          !catalog.rollbackReleases.every(isValidReleaseDescriptor)))
-    ) {
-      return null;
-    }
-    if (
-      !hasExpectedReleaseCatalogScope(catalog as ReleaseCatalog, expectedScope)
-    ) {
-      return null;
-    }
-    const distinctTargetCohorts = new Set(
-      [...catalog.releases, ...(catalog.rollbackReleases ?? [])].flatMap(
-        (release) => release.targetCohorts,
-      ),
-    );
-    if (distinctTargetCohorts.size > MAX_DISTINCT_TARGET_COHORTS_PER_SCOPE) {
-      return null;
-    }
-    return catalog as ReleaseCatalog;
-  } catch {
-    return null;
-  }
+  readonly onResponse?: UpdateRequest["onResponse"];
 };
 
 const isValidETag = (value: string | null): value is string =>
@@ -214,7 +89,7 @@ const parseCache = (
   const etag = value.slice(versionEnd + 1, etagEnd);
   const body = value.slice(etagEnd + 1);
   if (!isValidETag(etag)) return null;
-  const catalog = parseValidatedCatalog(body, expectedScope);
+  const catalog = parseReleaseCatalog(body, expectedScope);
   if (catalog === null) return null;
   const parsed = { catalog, etag, partition, serialized: value };
   lastParsedCache = parsed;
@@ -240,36 +115,24 @@ export const createReleaseCatalogCachePartition = (
     version: 2,
   });
 
-const fetchCatalogResponse = async (
+const isEmptyCatalogResponse = (response: Response) =>
+  response.status === 404 &&
+  response.headers.get("x-hot-updater-catalog")?.trim().toLowerCase() ===
+    "none";
+
+const fetchCatalogResponse = (
   input: FetchReleaseCatalogInput,
   etag?: string,
-): Promise<Response> => {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(
-    () => controller.abort(),
-    input.requestTimeout ?? 5000,
-  );
-
-  try {
-    const headers = new Headers(input.requestHeaders);
-    headers.set("Accept", "application/json");
-    if (etag === undefined) {
-      headers.delete("If-None-Match");
-    } else {
-      headers.set("If-None-Match", etag);
-    }
-    return await fetch(input.url, {
-      headers,
-      signal: controller.signal,
-    });
-  } catch (error: unknown) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error("Request timed out");
-    }
-    throw error;
-  } finally {
-    clearTimeout(timeoutId);
-  }
+) => {
+  const headers = new Headers(input.requestHeaders);
+  headers.set("Accept", "application/json");
+  if (etag === undefined) headers.delete("If-None-Match");
+  else headers.set("If-None-Match", etag);
+  return fetchUpdateResponse({
+    ...input,
+    resource: "catalog",
+    requestHeaders: Object.fromEntries(headers.entries()),
+  });
 };
 
 const readValidatedCache = async (
@@ -287,24 +150,28 @@ const readValidatedCache = async (
 };
 
 const consumeSuccessfulResponse = async (
-  response: Response,
+  { response, body }: Awaited<ReturnType<typeof fetchCatalogResponse>>,
   input: FetchReleaseCatalogInput,
   partition: string,
-): Promise<ReleaseCatalog> => {
+): Promise<ReleaseCatalog | null> => {
+  // The server marks the 404 of a scope that has no catalog yet: no update,
+  // not a failure. Any other 404 is a wrong baseURL or route.
+  if (isEmptyCatalogResponse(response)) {
+    return null;
+  }
   if (response.status !== 200) {
-    throw new Error(response.statusText);
+    throw new UpdateHttpError(response.status, response.statusText);
   }
 
-  const body = await response.text();
-  const catalog = parseValidatedCatalog(body, input.expectedScope);
+  const catalog = parseReleaseCatalog(body!, input.expectedScope);
   if (catalog === null) {
     await removeNativeReleaseCatalogCache(partition);
-    throw new Error("Received an invalid Release catalog");
+    throw new InvalidUpdateResponseError("Received an invalid Release catalog");
   }
 
   const etag = response.headers.get("etag");
   if (isValidETag(etag)) {
-    const serialized = serializeCache(etag, body);
+    const serialized = serializeCache(etag, body!);
     if (getUtf8ByteLength(serialized) > MAX_RELEASE_CATALOG_CACHE_ENTRY_BYTES) {
       await removeNativeReleaseCatalogCache(partition);
       return catalog;
@@ -323,14 +190,18 @@ const consumeSuccessfulResponse = async (
   return catalog;
 };
 
+/**
+ * Fetches a scope's catalog, or null when the server answers that the scope
+ * has none (a 404 with `x-hot-updater-catalog: none`).
+ */
 export const fetchReleaseCatalogWithCache = async (
   input: FetchReleaseCatalogInput,
-): Promise<ReleaseCatalog> => {
+): Promise<ReleaseCatalog | null> => {
   const partition = createReleaseCatalogCachePartition(input);
   const cached = await readValidatedCache(partition, input.expectedScope);
   const response = await fetchCatalogResponse(input, cached?.etag);
 
-  if (response.status === 304) {
+  if (response.response.status === 304) {
     if (cached !== null) return cached.catalog;
 
     const repairResponse = await fetchCatalogResponse(input);

package/src/sdkVersion.ts

@@ -1 +1 @@
-export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.4";
+export const HOT_UPDATER_SDK_VERSION = "1.0.0-rc.41";

package/src/specs/NativeHotUpdater.ts

@@ -2,48 +2,21 @@ import type { TurboModule } from "react-native";
 import { TurboModuleRegistry } from "react-native";
 import type { UnsafeObject } from "react-native/Libraries/Types/CodegenTypes";
 
-export interface ChangedAsset {
-  file?: {
-    compression?: "br" | null;
-    url: string;
-  } | null;
-  fileHash: string;
-  patch?: {
-    algorithm: "bsdiff";
-    baseBundleId: string;
-    baseFileHash: string;
-    patchFileHash: string;
-    patchUrl: string;
-  } | null;
-}
-
 export interface UpdateBundleParams {
   bundleId: string;
   channel?: string;
-  fileUrl: string | null;
   /**
-   * File hash for integrity/signature verification.
-   *
-   * Format depends on signing configuration:
-   * - Signed: `sig:<base64_signature>` - Native will verify signature (and implicitly hash)
-   * - Unsigned: `<hex_hash>` - Native will verify SHA256 hash only
-   *
-   * Native determines verification mode by checking for "sig:" prefix.
+   * Signed manifest URL for installation.
    */
-  fileHash: string | null;
-  /**
-   * Optional signed manifest URL for manifest-driven installation.
-   */
-  manifestUrl?: string | null;
+  manifestUrl: string;
   /**
    * File hash/signature for the manifest file itself.
    */
-  manifestFileHash?: string | null;
-  /**
-   * Per-file URLs for assets that must be downloaded instead of reused from
-   * the currently active bundle.
-   */
-  changedAssets?: UnsafeObject | null;
+  manifestFileHash: string;
+  /** Optional tar.br URL; integrity and sizes come from the verified manifest. */
+  archiveUrl?: string | null;
+  /** Full protocol v1 target file descriptor map. */
+  assets: UnsafeObject;
   /** Full Release Catalog selection receipt committed with the staged Bundle. */
   selection?: UnsafeObject | null;
 }
@@ -61,18 +34,21 @@ export interface Spec extends TurboModule {
    * Downloads and applies a bundle update.
    *
    * @param params - Update bundle parameters
-   * @returns Promise that resolves to true if successful
+   * @returns Promise that resolves, once the bundle is staged, to how it
+   *   arrived: `{ delivery, patchFallback }`. `delivery` is "patch" when a
+   *   bsdiff patch produced a file, "manifest" when only changed files were
+   *   downloaded, or "archive" for the full archive; `patchFallback` is true
+   *   when a patch was tried but the file or archive was downloaded instead.
    * @throws {HotUpdaterErrorCode} Rejects with one of the following error codes:
    *
    *   Parameter validation:
    *   - MISSING_BUNDLE_ID: Missing or empty bundleId
-   *   - INVALID_FILE_URL: Invalid fileUrl provided
+   *   - INVALID_FILE_URL: Invalid manifest or asset URL provided
    *
    *   Bundle storage:
    *   - DIRECTORY_CREATION_FAILED: Failed to create bundle directory
    *   - DOWNLOAD_FAILED: Failed to download bundle
    *   - INCOMPLETE_DOWNLOAD: Download incomplete (size mismatch)
-   *   - EXTRACTION_FORMAT_ERROR: Invalid or corrupted archive format
    *   - INVALID_BUNDLE: Bundle missing required platform files
    *   - INSUFFICIENT_DISK_SPACE: Insufficient disk space
    *   - MOVE_OPERATION_FAILED: Failed to move bundle files
@@ -87,8 +63,20 @@ export interface Spec extends TurboModule {
    *
    *   Note: iOS normalizes rare signature/storage errors to SIGNATURE_VERIFICATION_FAILED
    *   or UNKNOWN_ERROR to keep the JS error surface small.
+   *
+   *   A rejection from the download or install also carries `userInfo`
+   *   `{ stage, reason, resource?, httpStatus?, transport?, originCode? }`:
+   *   `stage` is "download" (transfer and verification) or "install" (patch,
+   *   extract, move into place); `reason` is one of "network", "http",
+   *   "invalid_response", "hash_mismatch", "signature", "patch", "extract",
+   *   "storage", or "unknown"; `resource` is what was being fetched or
+   *   applied: "manifest", "file", "patch", or "archive". `httpStatus` is
+   *   present when `reason` is "http", with `originCode`, the storage
+   *   origin's XML error `<Code>` when the body names one. `transport` is
+   *   present when no response arrived: "timeout", "dns", "tls",
+   *   "connection", "offline", or "cancelled".
    */
-  updateBundle(params: UpdateBundleParams): Promise<boolean>;
+  updateBundle(params: UpdateBundleParams): Promise<UnsafeObject>;
 
   /** Accepts and durably advances the catalog high-water for a scope. */
   acceptReleaseCatalog(params: UnsafeObject): boolean;
@@ -192,24 +180,22 @@ export interface Spec extends TurboModule {
   getCohort: () => string;
 
   /**
-   * Gets the persisted install id for this app installation.
+   * Gets the install id: a random id native creates once per app
+   * installation and keeps out of device backups.
    */
   getInstallId: () => string;
 
   /**
-   * Gets the persisted nullable user id associated with this installation.
-   */
-  getUserId: () => string | null;
-
-  /**
-   * Gets the persisted nullable username associated with this installation.
+   * Reads a value from the SDK's persistent key-value store, which native
+   * keeps out of device backups. Returns null when the key has no value.
    */
-  getUsername: () => string | null;
+  getStorageItem: (key: string) => string | null;
 
   /**
-   * Persists nullable user identity fields associated with this installation.
+   * Writes a value to the SDK's persistent key-value store; null removes the
+   * key.
    */
-  setUser: (userId: string | null, username: string | null) => void;
+  setStorageItem: (key: string, value: string | null) => void;
 
   // EventEmitter
   addListener(eventName: string): void;

package/src/store.ts

@@ -9,10 +9,8 @@ import { addListener } from "./native";
 
 export type HotUpdaterState = {
   progress: number;
-  downloadedBytes: number | undefined;
-  totalBytes: number | undefined;
   isUpdateDownloaded: boolean;
-  artifactType: "archive" | "diff" | null;
+  artifactType: "diff" | null;
   details: HotUpdaterDiffProgressDetails | null;
 };
 
@@ -56,8 +54,6 @@ const areDiffDetailsEqual = (
 const areStatesEqual = (left: HotUpdaterState, right: HotUpdaterState) => {
   return (
     left.progress === right.progress &&
-    left.downloadedBytes === right.downloadedBytes &&
-    left.totalBytes === right.totalBytes &&
     left.isUpdateDownloaded === right.isUpdateDownloaded &&
     left.artifactType === right.artifactType &&
     areDiffDetailsEqual(left.details, right.details)
@@ -78,8 +74,6 @@ const normalizeDownloadPath = (value: string | undefined) => {
 const createHotUpdaterStore = () => {
   let state: HotUpdaterState = {
     progress: 0,
-    downloadedBytes: undefined,
-    totalBytes: undefined,
     isUpdateDownloaded: false,
     artifactType: null,
     details: null,
@@ -165,10 +159,6 @@ const createHotUpdaterStore = () => {
       nextState.details = state.details;
     }
 
-    if (nextState.artifactType !== "diff") {
-      nextState.details = null;
-    }
-
     if (areStatesEqual(state, nextState)) {
       return;
     }
@@ -180,19 +170,8 @@ const createHotUpdaterStore = () => {
   const applyProgressEvent = (event: HotUpdaterProgressEvent) => {
     setState({
       artifactType: event.artifactType,
-      details:
-        event.artifactType === "diff"
-          ? normalizeDiffDetails(event.details)
-          : null,
-      downloadedBytes:
-        event.artifactType === "archive"
-          ? normalizeByteCount(event.downloadedBytes)
-          : undefined,
+      details: normalizeDiffDetails(event.details),
       progress: event.progress,
-      totalBytes:
-        event.artifactType === "archive"
-          ? normalizeByteCount(event.totalBytes)
-          : undefined,
     });
   };
 

package/src/types.ts

@@ -1,4 +1,4 @@
-export type HotUpdaterBaseURL = string | (() => string | Promise<string>);
+export type { HotUpdaterBaseURL } from "@hot-updater/protocol";
 
 /**
  * Information about a signature verification failure.

package/src/updateError.ts

@@ -0,0 +1,167 @@
+import type {
+  UpdateError,
+  UpdateErrorReason,
+  UpdateErrorResource,
+  UpdateErrorStage,
+  UpdateErrorTransport,
+} from "./clientPlugin";
+import { HotUpdaterError } from "./error";
+
+/**
+ * A response the SDK cannot use: a malformed or stale catalog, an artifact
+ * in another protocol, or an invalid URL.
+ */
+export class InvalidUpdateResponseError extends HotUpdaterError {
+  constructor(message: string, options?: { cause?: unknown }) {
+    super(message);
+    this.name = "InvalidUpdateResponseError";
+    if (options?.cause !== undefined) this.cause = options.cause;
+  }
+}
+
+/** A request the server answered with a status the SDK does not accept. */
+export class UpdateHttpError extends HotUpdaterError {
+  constructor(
+    readonly status: number,
+    statusText: string,
+  ) {
+    super(
+      `Request failed with HTTP ${status}${statusText ? ` ${statusText}` : ""}`,
+    );
+    this.name = "UpdateHttpError";
+  }
+}
+
+const STAGES: readonly UpdateErrorStage[] = ["check", "download", "install"];
+const REASONS: readonly UpdateErrorReason[] = [
+  "network",
+  "http",
+  "invalid_response",
+  "hash_mismatch",
+  "signature",
+  "patch",
+  "extract",
+  "storage",
+  "unknown",
+];
+const RESOURCES: readonly UpdateErrorResource[] = [
+  "catalog",
+  "artifact",
+  "manifest",
+  "file",
+  "patch",
+  "archive",
+];
+const TRANSPORTS: readonly UpdateErrorTransport[] = [
+  "timeout",
+  "dns",
+  "tls",
+  "connection",
+  "offline",
+  "cancelled",
+];
+/** An S3, R2, or GCS error code: letters, digits, and punctuation only. */
+const ORIGIN_CODE = /^[A-Za-z0-9._-]{1,64}$/;
+/** Expo's iOS and Android names for a fetch canceled before its response. */
+const EXPO_FETCH_CANCELED =
+  /FetchRequestCanceledException|Fetch request has been canceled|The operation was aborted/;
+
+type Classification = Pick<
+  UpdateError,
+  "stage" | "reason" | "resource" | "httpStatus" | "originCode" | "transport"
+>;
+
+const oneOf = <T extends string>(
+  values: readonly T[],
+  value: unknown,
+): value is T => values.includes(value as T);
+
+const readNativeClassification = (
+  error: object,
+): Classification | null | undefined => {
+  if (!("code" in error) || typeof error.code !== "string") return undefined;
+  const userInfo =
+    "userInfo" in error && typeof error.userInfo === "object"
+      ? (error.userInfo as Record<string, unknown> | null)
+      : null;
+  const { stage, reason, resource, transport, originCode } = userInfo ?? {};
+  // Native classifies every failure of its download and install; a rejection
+  // without it, such as a stale selection, is not an update failure.
+  if (!oneOf(STAGES, stage) || !oneOf(REASONS, reason)) return null;
+  const httpStatus = Number(userInfo?.httpStatus);
+  return {
+    stage,
+    reason,
+    ...(oneOf(RESOURCES, resource) ? { resource } : {}),
+    ...(reason === "http" && Number.isSafeInteger(httpStatus)
+      ? { httpStatus }
+      : {}),
+    ...(reason === "http" &&
+    typeof originCode === "string" &&
+    ORIGIN_CODE.test(originCode)
+      ? { originCode }
+      : {}),
+    ...(reason === "network" && oneOf(TRANSPORTS, transport)
+      ? { transport }
+      : {}),
+  };
+};
+
+/**
+ * Where and why an update failed, or null when the error is not an update
+ * failure. Native rejections carry their own classification; an error the
+ * SDK's JavaScript raised happened in `stage`, fetching `resource` when one
+ * is given.
+ */
+export const classifyUpdateError = (
+  error: unknown,
+  stage: UpdateErrorStage,
+  resource?: UpdateErrorResource,
+): Classification | null => {
+  if (typeof error === "object" && error !== null) {
+    const native = readNativeClassification(error);
+    if (native !== undefined) return native;
+  }
+  const scope = {
+    stage,
+    ...(resource === undefined ? {} : { resource }),
+  };
+  // Names, not classes, so an error from another copy of a module still
+  // classifies, as it does across test module resets.
+  const name = error instanceof Error ? error.name : null;
+  // A selection that became stale is a race between checks, not a failure.
+  if (name === "StaleReleaseCatalogError") return null;
+  if (name === "UpdateHttpError") {
+    return {
+      ...scope,
+      reason: "http",
+      httpStatus: (error as UpdateHttpError).status,
+    };
+  }
+  if (name === "InvalidUpdateResponseError" || name === "SyntaxError") {
+    return { ...scope, reason: "invalid_response" };
+  }
+  if (error instanceof Error && error.message === "Request timed out") {
+    return { ...scope, reason: "network", transport: "timeout" };
+  }
+  if (name === "AbortError") {
+    return { ...scope, reason: "network", transport: "cancelled" };
+  }
+  // Expo's fetch rejects with "fetch failed: <native exception>" when no
+  // response arrives, and names a canceled request.
+  if (error instanceof Error && error.message.startsWith("fetch failed:")) {
+    return {
+      ...scope,
+      reason: "network",
+      ...(EXPO_FETCH_CANCELED.test(error.message)
+        ? { transport: "cancelled" }
+        : {}),
+    };
+  }
+  if (name === "TypeError") {
+    // fetch rejects with a TypeError when no response arrives, without
+    // saying why.
+    return { ...scope, reason: "network" };
+  }
+  return { ...scope, reason: "unknown" };
+};