@hot-updater/react-native 1.0.0-rc.2 → 1.0.0-rc.22

package/lib/typescript/module/notifyAppReadyInsights.d.ts

@@ -1,13 +0,0 @@
-import type { HotUpdaterError } from "./error";
-import type { HotUpdaterHttpClient } from "./httpClient";
-import { type NotifyAppReadyResult } from "./native";
-export type NotifyAppReadyOptions = {
-    insights?: boolean;
-    client: HotUpdaterHttpClient;
-    requestHeaders?: Record<string, string>;
-    requestTimeout?: number;
-    onNotifyAppReady?: (result: NotifyAppReadyResult) => void;
-    onError?: (error: HotUpdaterError | Error | unknown) => void;
-};
-export declare const handleNotifyAppReady: (options: NotifyAppReadyOptions) => Promise<void>;
-//# sourceMappingURL=notifyAppReadyInsights.d.ts.map

package/lib/typescript/module/notifyAppReadyInsights.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifyAppReadyInsights.d.ts","sourceRoot":"","sources":["../../../src/notifyAppReadyInsights.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAC/C,OAAO,KAAK,EAAuB,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAC9E,OAAO,EASL,KAAK,oBAAoB,EAE1B,MAAM,UAAU,CAAC;AAElB,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,oBAAoB,CAAC;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IAC1D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,GAAG,KAAK,GAAG,OAAO,KAAK,IAAI,CAAC;CAC9D,CAAC;AA4IF,eAAO,MAAM,oBAAoB,YACtB,qBAAqB,KAC7B,OAAO,CAAC,IAAI,CA2Bd,CAAC"}

package/lib/typescript/module/notifyAppReadyInsights.test-utils.d.ts

@@ -1,8 +0,0 @@
-import type { NotifyAppReadyInsightsEvent, NotifyAppReadyResult } from "./native";
-export declare const createNotifyReadResult: (result?: NotifyAppReadyResult, insightsEvent?: NotifyAppReadyInsightsEvent | null, pending?: boolean) => {
-    insightsEvent: NotifyAppReadyInsightsEvent | null;
-    pending: boolean;
-    result: NotifyAppReadyResult;
-};
-export declare const stubNotifyFrame: () => void;
-//# sourceMappingURL=notifyAppReadyInsights.test-utils.d.ts.map

package/lib/typescript/module/notifyAppReadyInsights.test-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"notifyAppReadyInsights.test-utils.d.ts","sourceRoot":"","sources":["../../../src/notifyAppReadyInsights.test-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,UAAU,CAAC;AAElB,eAAO,MAAM,sBAAsB,YACzB,oBAAoB,kBACb,2BAA2B,GAAG,IAAI,wBAEhD;IACD,aAAa,EAAE,2BAA2B,GAAG,IAAI,CAAC;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,oBAAoB,CAAC;CAK7B,CAAC;AAEH,eAAO,MAAM,eAAe,YAS3B,CAAC"}

package/src/catalogCacheNative.spec.ts

@@ -1,63 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const nativeModule = vi.hoisted(
-  () => ({}) as Record<string, ReturnType<typeof vi.fn>>,
-);
-
-vi.mock("./specs/NativeHotUpdater", () => ({ default: nativeModule }));
-
-import {
-  readNativeReleaseCatalogCache,
-  removeNativeReleaseCatalogCache,
-  writeNativeReleaseCatalogCache,
-} from "./catalogCacheNative";
-
-describe("Release Catalog native cache", () => {
-  beforeEach(() => {
-    for (const key of Object.keys(nativeModule)) delete nativeModule[key];
-  });
-
-  it("fails fast when the v1 native cache API is missing", async () => {
-    await expect(readNativeReleaseCatalogCache("partition")).rejects.toThrow(
-      "Native module is missing 'getReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.",
-    );
-    await expect(
-      writeNativeReleaseCatalogCache("partition", "payload"),
-    ).rejects.toThrow(
-      "Native module is missing 'setReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.",
-    );
-    await expect(removeNativeReleaseCatalogCache("partition")).rejects.toThrow(
-      "Native module is missing 'removeReleaseCatalogCache()'. Rebuild the native app before using Release catalogs.",
-    );
-  });
-
-  it("normalizes an undefined iOS TurboModule cache miss to null", async () => {
-    nativeModule.getReleaseCatalogCache = vi.fn().mockResolvedValue(undefined);
-
-    await expect(
-      readNativeReleaseCatalogCache("partition"),
-    ).resolves.toBeNull();
-  });
-
-  it("treats native cache I/O failures as misses without hiding network work", async () => {
-    nativeModule.getReleaseCatalogCache = vi
-      .fn()
-      .mockRejectedValue(new Error("read"));
-    nativeModule.setReleaseCatalogCache = vi
-      .fn()
-      .mockRejectedValue(new Error("write"));
-    nativeModule.removeReleaseCatalogCache = vi
-      .fn()
-      .mockRejectedValue(new Error("remove"));
-
-    await expect(
-      readNativeReleaseCatalogCache("partition"),
-    ).resolves.toBeNull();
-    await expect(
-      writeNativeReleaseCatalogCache("partition", "payload"),
-    ).resolves.toBe(false);
-    await expect(
-      removeNativeReleaseCatalogCache("partition"),
-    ).resolves.toBeUndefined();
-  });
-});

package/src/checkForUpdate.releaseCatalog.spec.ts

@@ -1,596 +0,0 @@
-import {
-  createReleaseCatalogScopeKey,
-  encodeChannelKey,
-  type PersistedSelectionReceipt,
-  type ReleaseCatalog,
-} from "@hot-updater/core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { HotUpdaterHttpClient } from "./httpClient";
-
-const MINIMUM_RELEASE_ID = "00000000-0000-7000-8000-000000000001";
-const RELEASE_ID = "00000000-0000-7000-8000-000000000002";
-const ACTIVE_RELEASE_ID = "00000000-0000-7000-8000-000000000003";
-const CURRENT_BUNDLE_ID = "00000000-0000-7001-8000-000000000001";
-const TARGET_BUNDLE_ID = "00000000-0000-7001-8000-000000000002";
-const CATALOG_ID = "project-a";
-const CHANNEL = "production";
-const CATALOG_HASH = `sha256:${"a".repeat(64)}`;
-const SCOPE_KEY = createReleaseCatalogScopeKey({
-  channelKey: encodeChannelKey(CHANNEL),
-  platform: "ios",
-  strategy: "APP_VERSION",
-});
-
-const mocks = vi.hoisted(() => ({
-  addListener: vi.fn(() => () => {}),
-  acceptReleaseCatalog: vi.fn(() => true),
-  commitReleaseSelection: vi.fn(async () => true),
-  getActiveUpdateState: vi.fn(() => ({
-    activeSelection: null as PersistedSelectionReceipt | null,
-    highestSeenCatalogs: {},
-    stableSelection: null as PersistedSelectionReceipt | null,
-    verificationPending: false,
-  })),
-  getAppVersion: vi.fn(() => "1.2"),
-  getBundleId: vi.fn(() => CURRENT_BUNDLE_ID),
-  getChannel: vi.fn(() => CHANNEL),
-  getCohort: vi.fn(() => "123"),
-  getCrashHistory: vi.fn(() => []),
-  getDefaultChannel: vi.fn(() => CHANNEL),
-  getFingerprintHash: vi.fn(() => null),
-  getInstallId: vi.fn(() => "install-id"),
-  getMinBundleId: vi.fn(() => MINIMUM_RELEASE_ID),
-  getPersistedUserIdentity: vi.fn(() => ({})),
-  isChannelSwitched: vi.fn(() => false),
-  isReleaseSelectionCurrent: vi.fn(() => true),
-  resetChannel: vi.fn(),
-  updateBundle: vi.fn(async () => true),
-}));
-
-vi.mock("react-native", () => ({ Platform: { OS: "ios" } }));
-
-vi.mock("./native", () => mocks);
-
-const createCatalog = (
-  overrides: Partial<ReleaseCatalog> = {},
-): ReleaseCatalog => ({
-  catalogId: CATALOG_ID,
-  catalogHash: CATALOG_HASH,
-  fallbackPolicy: "BUILTIN_IF_ACTIVE_INELIGIBLE",
-  generation: 2,
-  releases: [
-    {
-      bundleId: TARGET_BUNDLE_ID,
-      kind: "BUNDLE",
-      message: "Release two",
-      releaseId: RELEASE_ID,
-      rolloutCohortCount: 1000,
-      shouldForceUpdate: false,
-      targetCohorts: [],
-    },
-  ],
-  schemaVersion: 1,
-  scopeKey: SCOPE_KEY,
-  ...overrides,
-});
-
-const createClient = (catalog = createCatalog()) => {
-  const fetchReleaseCatalog = vi.fn(async () => catalog);
-  const resolveArtifact = vi.fn(async () => ({
-    fileHash: "bundle-hash",
-    fileUrl: "https://updates.example.com/bundle.zip",
-  }));
-  const sendInsightsEvent = vi.fn(async () => undefined);
-  const session = {
-    fetchReleaseCatalog,
-    resolveArtifact,
-    sendInsightsEvent,
-  };
-  const client: HotUpdaterHttpClient = {
-    createSession: vi.fn(async () => session),
-  };
-  return { client, fetchReleaseCatalog, resolveArtifact, sendInsightsEvent };
-};
-
-describe("checkForUpdate Release catalog protocol", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.stubGlobal("__DEV__", false);
-    mocks.acceptReleaseCatalog.mockReturnValue(true);
-    mocks.getActiveUpdateState.mockReturnValue({
-      activeSelection: null,
-      highestSeenCatalogs: {},
-      stableSelection: null,
-      verificationPending: false,
-    });
-    mocks.isReleaseSelectionCurrent.mockReturnValue(true);
-    mocks.commitReleaseSelection.mockResolvedValue(true);
-    mocks.updateBundle.mockResolvedValue(true);
-  });
-
-  it("selects locally and defers Bundle artifact resolution until install", async () => {
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client, fetchReleaseCatalog, resolveArtifact } = createClient();
-
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      id: TARGET_BUNDLE_ID,
-      releaseId: RELEASE_ID,
-      transitionKind: "INSTALL",
-    });
-    expect(fetchReleaseCatalog).toHaveBeenCalledWith({
-      appVersion: "1.2.0",
-      channel: CHANNEL,
-      fingerprintHash: null,
-      platform: "ios",
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      updateStrategy: "appVersion",
-    });
-    expect(resolveArtifact).not.toHaveBeenCalled();
-
-    await expect(result?.updateBundle()).resolves.toBe(true);
-
-    expect(resolveArtifact).toHaveBeenCalledWith({
-      currentBundleId: CURRENT_BUNDLE_ID,
-      requestHeaders: undefined,
-      requestTimeout: undefined,
-      targetBundleId: TARGET_BUNDLE_ID,
-    });
-    expect(mocks.updateBundle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        bundleId: TARGET_BUNDLE_ID,
-        selection: expect.objectContaining({
-          catalogId: CATALOG_ID,
-          releaseId: RELEASE_ID,
-          scopeKey: SCOPE_KEY,
-        }),
-      }),
-    );
-  });
-
-  it("adopts a newer Release for the same Bundle without resolving bytes", async () => {
-    const active: PersistedSelectionReceipt = {
-      catalogId: CATALOG_ID,
-      bundleId: TARGET_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: MINIMUM_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context",
-    };
-    mocks.getBundleId.mockReturnValueOnce(TARGET_BUNDLE_ID);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const forceCatalog = createCatalog({
-      releases: [
-        {
-          ...createCatalog().releases[0]!,
-          shouldForceUpdate: true,
-        },
-      ],
-    });
-    const { client, resolveArtifact, sendInsightsEvent } =
-      createClient(forceCatalog);
-
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      shouldForceUpdate: false,
-      transitionKind: "ADOPT_RELEASE",
-    });
-    await expect(result?.updateBundle()).resolves.toBe(true);
-    expect(resolveArtifact).not.toHaveBeenCalled();
-    expect(mocks.updateBundle).not.toHaveBeenCalled();
-    expect(sendInsightsEvent).not.toHaveBeenCalled();
-    expect(mocks.commitReleaseSelection).toHaveBeenCalledWith({
-      guard: expect.objectContaining({ generation: 2, scopeKey: SCOPE_KEY }),
-      selection: expect.objectContaining({
-        bundleId: TARGET_BUNDLE_ID,
-        releaseId: RELEASE_ID,
-      }),
-    });
-  });
-
-  it("sends RELEASE_ADOPTED only when insights is enabled", async () => {
-    const active: PersistedSelectionReceipt = {
-      catalogId: CATALOG_ID,
-      bundleId: TARGET_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: MINIMUM_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context",
-    };
-    mocks.getBundleId.mockReturnValueOnce(TARGET_BUNDLE_ID);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client, sendInsightsEvent } = createClient();
-
-    const result = await checkForUpdate({
-      insights: true,
-      client,
-      updateStrategy: "appVersion",
-    });
-    await result?.updateBundle();
-
-    expect(sendInsightsEvent).toHaveBeenCalledWith(
-      expect.objectContaining({
-        fromReleaseId: MINIMUM_RELEASE_ID,
-        toReleaseId: RELEASE_ID,
-        type: "RELEASE_ADOPTED",
-      }),
-    );
-  });
-
-  it("selects a lower-id Release when explicitly switching scopes", async () => {
-    const betaChannel = "beta";
-    const betaScopeKey = createReleaseCatalogScopeKey({
-      channelKey: encodeChannelKey(betaChannel),
-      platform: "ios",
-      strategy: "APP_VERSION",
-    });
-    const active: PersistedSelectionReceipt = {
-      catalogId: CATALOG_ID,
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context",
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const betaCatalog = createCatalog({ scopeKey: betaScopeKey });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient(betaCatalog);
-
-    const result = await checkForUpdate({
-      channel: betaChannel,
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      id: TARGET_BUNDLE_ID,
-      releaseId: RELEASE_ID,
-      status: "UPDATE",
-      transitionKind: "INSTALL",
-    });
-  });
-
-  it("refreshes the same Release receipt when catalog provenance changes", async () => {
-    const active: PersistedSelectionReceipt = {
-      catalogId: CATALOG_ID,
-      bundleId: TARGET_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context",
-    };
-    mocks.getBundleId.mockReturnValueOnce(TARGET_BUNDLE_ID);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client, resolveArtifact } = createClient();
-
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      id: TARGET_BUNDLE_ID,
-      releaseId: RELEASE_ID,
-      transitionKind: "ADOPT_RELEASE",
-    });
-    await expect(result?.updateBundle()).resolves.toBe(true);
-    expect(resolveArtifact).not.toHaveBeenCalled();
-    expect(mocks.updateBundle).not.toHaveBeenCalled();
-    expect(mocks.commitReleaseSelection).toHaveBeenCalledWith({
-      guard: expect.objectContaining({
-        catalogHash: CATALOG_HASH,
-        generation: 2,
-        scopeKey: SCOPE_KEY,
-      }),
-      selection: expect.objectContaining({
-        bundleId: TARGET_BUNDLE_ID,
-        catalogHash: CATALOG_HASH,
-        generation: 2,
-        releaseId: RELEASE_ID,
-      }),
-    });
-  });
-
-  it("rejects a slow artifact completion after a newer catalog wins", async () => {
-    mocks.isReleaseSelectionCurrent
-      .mockReturnValueOnce(true)
-      .mockReturnValueOnce(false);
-    const { StaleReleaseCatalogError } = await import("./error");
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient();
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    await expect(result?.updateBundle()).rejects.toBeInstanceOf(
-      StaleReleaseCatalogError,
-    );
-    expect(mocks.updateBundle).not.toHaveBeenCalled();
-  });
-
-  it("installs an older enabled Release as a forced rollback", async () => {
-    const active: PersistedSelectionReceipt = {
-      catalogId: CATALOG_ID,
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context",
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const catalog = createCatalog({
-      rollbackReleases: [
-        {
-          bundleId: TARGET_BUNDLE_ID,
-          kind: "BUNDLE",
-          message: "Previous Release",
-          releaseId: RELEASE_ID,
-          rolloutCohortCount: 0,
-          shouldForceUpdate: false,
-          targetCohorts: [],
-        },
-      ],
-    });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient(catalog);
-
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      id: TARGET_BUNDLE_ID,
-      releaseId: RELEASE_ID,
-      shouldForceUpdate: true,
-      status: "ROLLBACK",
-      transitionKind: "INSTALL",
-    });
-    await expect(result?.updateBundle()).resolves.toBe(true);
-    expect(mocks.updateBundle).toHaveBeenCalledWith(
-      expect.objectContaining({
-        bundleId: TARGET_BUNDLE_ID,
-        status: "ROLLBACK",
-      }),
-    );
-  });
-
-  it("uses current Bundle identity when migrating an unauthenticated receipt", async () => {
-    const migratedCurrentBundleId = "00000000-0000-7001-8000-000000000003";
-    const active: PersistedSelectionReceipt = {
-      catalogId: null,
-      bundleId: migratedCurrentBundleId,
-      catalogHash: null,
-      channel: CHANNEL,
-      generation: null,
-      kind: "BUNDLE",
-      releaseId: null,
-      scopeKey: null,
-      selectionContextHash: null,
-    };
-    mocks.getBundleId.mockReturnValueOnce(migratedCurrentBundleId);
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const catalog = createCatalog({
-      releases: [],
-      rollbackReleases: [
-        {
-          ...createCatalog().releases[0]!,
-          rolloutCohortCount: 0,
-        },
-      ],
-    });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient(catalog);
-
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      id: TARGET_BUNDLE_ID,
-      shouldForceUpdate: true,
-      status: "ROLLBACK",
-      transitionKind: "INSTALL",
-    });
-  });
-
-  it("returns a forced built-in rollback only for an active OTA", async () => {
-    const active: PersistedSelectionReceipt = {
-      catalogId: CATALOG_ID,
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: SCOPE_KEY,
-      selectionContextHash: "old-context",
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient(
-      createCatalog({ releases: [], rollbackReleases: [] }),
-    );
-
-    const result = await checkForUpdate({
-      client,
-      updateStrategy: "appVersion",
-    });
-
-    expect(result).toMatchObject({
-      id: MINIMUM_RELEASE_ID,
-      releaseId: null,
-      shouldForceUpdate: true,
-      status: "ROLLBACK",
-      transitionKind: "USE_BUILTIN",
-    });
-    await expect(result?.updateBundle()).resolves.toBe(true);
-    expect(mocks.commitReleaseSelection).toHaveBeenCalledWith(
-      expect.objectContaining({
-        selection: expect.objectContaining({
-          kind: "BUILTIN",
-          releaseId: null,
-        }),
-      }),
-    );
-  });
-
-  it("does not surface a rollback when the app already uses built-in bytes", async () => {
-    mocks.getBundleId.mockReturnValueOnce(MINIMUM_RELEASE_ID);
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient(
-      createCatalog({ releases: [], rollbackReleases: [] }),
-    );
-
-    await expect(
-      checkForUpdate({ client, updateStrategy: "appVersion" }),
-    ).resolves.toBeNull();
-    expect(mocks.commitReleaseSelection).not.toHaveBeenCalled();
-  });
-
-  it("reports a rejected generation without selecting or resolving artifacts", async () => {
-    mocks.acceptReleaseCatalog.mockReturnValueOnce(false);
-    const onError = vi.fn();
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client, resolveArtifact } = createClient();
-
-    await expect(
-      checkForUpdate({ client, onError, updateStrategy: "appVersion" }),
-    ).resolves.toBeNull();
-
-    expect(onError).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: "Rejected a stale or inconsistent Release catalog",
-      }),
-    );
-    expect(resolveArtifact).not.toHaveBeenCalled();
-  });
-
-  it("rejects mismatched catalog scope before native catalog state mutates", async () => {
-    const wrongScope = createReleaseCatalogScopeKey({
-      channelKey: encodeChannelKey("beta"),
-      platform: "ios",
-      strategy: "APP_VERSION",
-    });
-    const onError = vi.fn();
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient(createCatalog({ scopeKey: wrongScope }));
-
-    await expect(
-      checkForUpdate({ client, onError, updateStrategy: "appVersion" }),
-    ).resolves.toBeNull();
-
-    expect(onError).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: "Received an invalid Release catalog",
-      }),
-    );
-    expect(mocks.acceptReleaseCatalog).not.toHaveBeenCalled();
-    expect(mocks.commitReleaseSelection).not.toHaveBeenCalled();
-    expect(mocks.updateBundle).not.toHaveBeenCalled();
-  });
-
-  it("rejects an unexpected Catalog identity before accepting catalog state", async () => {
-    const active: PersistedSelectionReceipt = {
-      catalogId: "existing-project",
-      bundleId: CURRENT_BUNDLE_ID,
-      catalogHash: `sha256:${"b".repeat(64)}`,
-      channel: CHANNEL,
-      generation: 1,
-      kind: "BUNDLE",
-      releaseId: ACTIVE_RELEASE_ID,
-      scopeKey: createReleaseCatalogScopeKey({
-        channelKey: encodeChannelKey(CHANNEL),
-        platform: "ios",
-        strategy: "APP_VERSION",
-      }),
-      selectionContextHash: "old-context",
-    };
-    mocks.getActiveUpdateState.mockReturnValueOnce({
-      activeSelection: active,
-      highestSeenCatalogs: {},
-      stableSelection: active,
-      verificationPending: false,
-    });
-    const onError = vi.fn();
-    const { checkForUpdate } = await import("./checkForUpdate");
-    const { client } = createClient();
-
-    await expect(
-      checkForUpdate({ client, onError, updateStrategy: "appVersion" }),
-    ).resolves.toBeNull();
-
-    expect(onError).toHaveBeenCalledWith(
-      expect.objectContaining({
-        message: "Release transition rejected: UNSOLICITED_SCOPE",
-      }),
-    );
-    expect(mocks.acceptReleaseCatalog).not.toHaveBeenCalled();
-  });
-});