@hot-updater/react-native 1.0.0-rc.14 → 1.0.0-rc.16

package/src/httpClient.spec.ts

@@ -1,7 +1,12 @@
-import type { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
-import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  isUUIDv7,
+  type ArtifactInfo,
+  type ReleaseCatalog,
+} from "@hot-updater/core";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { createHttpClient } from "./httpClient";
+import { FetchJSONResponseError } from "./fetchJSON";
+import { createHttpClient, type InsightsEventParams } from "./httpClient";
 
 const mocks = vi.hoisted(() => {
   Reflect.set(globalThis, "HotUpdater", {
@@ -18,12 +23,28 @@ vi.mock("./releaseCatalogCache", () => ({
 }));
 
 vi.mock("./fetchJSON", () => ({
+  FetchJSONResponseError: class FetchJSONResponseError extends Error {
+    constructor(
+      readonly status: number,
+      statusText: string,
+    ) {
+      super(statusText);
+    }
+  },
   fetchJSON: mocks.fetchJSON,
 }));
 
 const artifact: ArtifactInfo = {
-  fileHash: "bundle-hash",
-  fileUrl: "/storage/bundle.zip",
+  artifactProtocolVersion: 1,
+  assets: {
+    "index.ios.bundle": {
+      file: { url: "/storage/index.bundle.br" },
+      fileHash: "bundle-hash",
+    },
+  },
+  manifestFileHash: "manifest-hash",
+  manifestUrl: "/storage/manifest.json",
+  archiveUrl: "/storage/bundle.tar.br",
 };
 
 const catalog: ReleaseCatalog = {
@@ -93,14 +114,24 @@ describe("private HotUpdater HTTP client", () => {
       }),
     ).resolves.toEqual({
       ...artifact,
-      fileUrl: "https://first.example.com/hot-updater/storage/bundle.zip",
+      assets: {
+        "index.ios.bundle": {
+          file: {
+            url: "https://first.example.com/hot-updater/storage/index.bundle.br",
+          },
+          fileHash: "bundle-hash",
+        },
+      },
+      manifestUrl:
+        "https://first.example.com/hot-updater/storage/manifest.json",
+      archiveUrl: "https://first.example.com/hot-updater/storage/bundle.tar.br",
     });
 
     expect(resolveBaseURL).toHaveBeenCalledOnce();
     expect(mocks.fetchJSON).toHaveBeenCalledWith({
       requestHeaders: undefined,
       requestTimeout: undefined,
-      url: "https://first.example.com/hot-updater/artifacts/target/from/current",
+      url: "https://first.example.com/hot-updater/artifacts/v1/target/from/current",
     });
 
     await client.createSession();
@@ -110,7 +141,12 @@ describe("private HotUpdater HTTP client", () => {
   it("rejects non-storage relative artifact URLs", async () => {
     mocks.fetchJSON.mockResolvedValue({
       ...artifact,
-      fileUrl: "/private/bundle.zip",
+      assets: {
+        "index.ios.bundle": {
+          file: { url: "/private/index.bundle.br" },
+          fileHash: "bundle-hash",
+        },
+      },
     });
     const session = await createHttpClient(
       "https://updates.example.com",
@@ -124,9 +160,254 @@ describe("private HotUpdater HTTP client", () => {
     ).rejects.toThrow("client-relative storage paths");
   });
 
+  it("rejects a legacy artifact response", async () => {
+    mocks.fetchJSON.mockResolvedValue({
+      fileHash: "archive-hash",
+      fileUrl: "/storage/bundle.zip",
+    });
+    const session = await createHttpClient(
+      "https://updates.example.com",
+    ).createSession();
+
+    await expect(
+      session.resolveArtifact({
+        currentBundleId: "current",
+        targetBundleId: "target",
+      }),
+    ).rejects.toThrow("does not support artifact protocol 1");
+  });
+
+  it("reports an old server without the v1 endpoint explicitly", async () => {
+    mocks.fetchJSON.mockRejectedValue(
+      new FetchJSONResponseError(404, "Not Found"),
+    );
+    const session = await createHttpClient(
+      "https://updates.example.com",
+    ).createSession();
+
+    await expect(
+      session.resolveArtifact({
+        currentBundleId: "current",
+        targetBundleId: "target",
+      }),
+    ).rejects.toThrow("does not support artifact protocol 1");
+  });
+
   it("requires a functional baseURL to resolve to a non-empty string", async () => {
     await expect(createHttpClient(() => "").createSession()).rejects.toThrow(
       "baseURL function must return a non-empty string",
     );
   });
 });
+
+const unchangedEvent: InsightsEventParams = {
+  appVersion: "1.0.0",
+  channel: "production",
+  cohort: "123",
+  fingerprintHash: null,
+  fromBundleId: null,
+  installId: "install-id",
+  platform: "ios",
+  toBundleId: "bundle-id",
+  type: "UNCHANGED",
+  updateStrategy: null,
+};
+
+/** Answers each POST /events with the next response, then 204. */
+const stubEventsEndpoint = (...responses: (number | Response | Error)[]) => {
+  const fetchMock = vi.fn<typeof fetch>(async () => {
+    const next = responses.shift() ?? 204;
+    if (next instanceof Error) throw next;
+    return typeof next === "number"
+      ? new Response(null, { status: next })
+      : next;
+  });
+  vi.stubGlobal("fetch", fetchMock);
+  const sentEvents = () =>
+    fetchMock.mock.calls.map(
+      ([, request]) =>
+        JSON.parse(String(request?.body)) as {
+          eventId: string;
+          type: string;
+        },
+    );
+  return { fetchMock, sentEvents };
+};
+
+describe("Insights event delivery", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    // No jitter: the first retry waits exactly 1 s and the second 2 s.
+    vi.spyOn(Math, "random").mockReturnValue(0.5);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  const createSession = () =>
+    createHttpClient("https://updates.example.com").createSession();
+
+  it("retries a 503 in the background under the same UUIDv7 eventId", async () => {
+    const { fetchMock, sentEvents } = stubEventsEndpoint(503, 204);
+    const session = await createSession();
+
+    // Settles after the failed first attempt, without waiting for the retry.
+    await session.sendInsightsEvent(unchangedEvent);
+    expect(fetchMock).toHaveBeenCalledOnce();
+
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const [first, second] = sentEvents();
+    expect(isUUIDv7(first?.eventId)).toBe(true);
+    expect(second?.eventId).toBe(first?.eventId);
+  });
+
+  it("waits for a 429's Retry-After before the next attempt", async () => {
+    const { fetchMock } = stubEventsEndpoint(
+      new Response(null, { headers: { "Retry-After": "7" }, status: 429 }),
+    );
+    const session = await createSession();
+
+    await session.sendInsightsEvent(unchangedEvent);
+    await vi.advanceTimersByTimeAsync(6_999);
+    expect(fetchMock).toHaveBeenCalledOnce();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("caps a server's Retry-After at 30 seconds", async () => {
+    const { fetchMock } = stubEventsEndpoint(
+      new Response(null, { headers: { "Retry-After": "3600" }, status: 503 }),
+    );
+    const session = await createSession();
+
+    await session.sendInsightsEvent(unchangedEvent);
+    await vi.advanceTimersByTimeAsync(29_999);
+    expect(fetchMock).toHaveBeenCalledOnce();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not retry a 400", async () => {
+    const { fetchMock } = stubEventsEndpoint(400);
+    const session = await createSession();
+
+    await expect(session.sendInsightsEvent(unchangedEvent)).rejects.toThrow(
+      "Expected HTTP 204 from /events, received 400",
+    );
+    await vi.runAllTimersAsync();
+    expect(fetchMock).toHaveBeenCalledOnce();
+  });
+
+  it("stops after three attempts and warns once", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const { fetchMock } = stubEventsEndpoint(
+      500,
+      new Error("network unavailable"),
+      503,
+    );
+    const session = await createSession();
+
+    await session.sendInsightsEvent(unchangedEvent);
+    await vi.runAllTimersAsync();
+
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+    expect(warn).toHaveBeenCalledExactlyOnceWith(
+      "[HotUpdater] Insights UNCHANGED event was not delivered:",
+      expect.objectContaining({
+        message: "Expected HTTP 204 from /events, received 503",
+      }),
+    );
+  });
+
+  it("gives each attempt its own timeout", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const fetchMock = vi.fn<typeof fetch>(
+      (_input, request) =>
+        new Promise((_resolve, reject) => {
+          request?.signal?.addEventListener("abort", () => {
+            reject(Object.assign(new Error("aborted"), { name: "AbortError" }));
+          });
+        }),
+    );
+    vi.stubGlobal("fetch", fetchMock);
+    const session = await createSession();
+
+    const sent = session.sendInsightsEvent({
+      ...unchangedEvent,
+      requestTimeout: 2_000,
+    });
+    await vi.advanceTimersByTimeAsync(2_000);
+    await sent;
+    // The second attempt starts after a 1 s backoff and gets a full 2 s.
+    await vi.advanceTimersByTimeAsync(1_000);
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const secondSignal = fetchMock.mock.calls[1]?.[1]?.signal;
+    await vi.advanceTimersByTimeAsync(1_999);
+    expect(secondSignal?.aborted).toBe(false);
+    await vi.advanceTimersByTimeAsync(1);
+    expect(secondSignal?.aborted).toBe(true);
+    await vi.runAllTimersAsync();
+
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+    expect(warn).toHaveBeenCalledExactlyOnceWith(
+      "[HotUpdater] Insights UNCHANGED event was not delivered:",
+      expect.objectContaining({ message: "Request timed out" }),
+    );
+  });
+
+  it("sends a later event after an earlier event's retries without holding its caller", async () => {
+    const { fetchMock, sentEvents } = stubEventsEndpoint(503);
+    const session = await createSession();
+
+    await session.sendInsightsEvent(unchangedEvent);
+    await session.sendInsightsEvent({
+      ...unchangedEvent,
+      fromBundleId: "bundle-id",
+      toBundleId: "next-bundle-id",
+      type: "UPDATE_DOWNLOADED",
+      updateStrategy: "appVersion",
+    });
+    expect(fetchMock).toHaveBeenCalledOnce();
+
+    await vi.runAllTimersAsync();
+    const [first, retry, later] = sentEvents();
+    expect([first?.type, retry?.type, later?.type]).toEqual([
+      "UNCHANGED",
+      "UNCHANGED",
+      "UPDATE_DOWNLOADED",
+    ]);
+    expect(retry?.eventId).toBe(first?.eventId);
+    expect(later?.eventId).not.toBe(first?.eventId);
+  });
+
+  it("keeps sending events after one fails outside its requests", async () => {
+    vi.spyOn(console, "warn").mockImplementation(() => {
+      throw new Error("console unavailable");
+    });
+    const { fetchMock, sentEvents } = stubEventsEndpoint(500, 500, 500);
+    const session = await createSession();
+
+    await session.sendInsightsEvent(unchangedEvent);
+    await vi.runAllTimersAsync();
+    expect(fetchMock).toHaveBeenCalledTimes(3);
+
+    // A queue left rejected would never send this event or settle its caller.
+    await session.sendInsightsEvent({
+      ...unchangedEvent,
+      fromBundleId: "bundle-id",
+      toBundleId: "next-bundle-id",
+      type: "UPDATE_DOWNLOADED",
+      updateStrategy: "appVersion",
+    });
+    expect(sentEvents().map(({ type }) => type)).toEqual([
+      "UNCHANGED",
+      "UNCHANGED",
+      "UNCHANGED",
+      "UPDATE_DOWNLOADED",
+    ]);
+  });
+});

package/src/httpClient.ts

@@ -1,14 +1,16 @@
 import {
+  ARTIFACT_PROTOCOL_VERSION,
   encodeChannelKey,
   type ArtifactInfo,
   type ReleaseCatalog,
 } from "@hot-updater/core";
 import { canonicalizeAppVersion } from "@hot-updater/plugin-core";
 
-import { fetchJSON } from "./fetchJSON";
+import { fetchJSON, FetchJSONResponseError } from "./fetchJSON";
 import { fetchReleaseCatalogWithCache } from "./releaseCatalogCache";
 import { HOT_UPDATER_SDK_VERSION } from "./sdkVersion";
 import type { HotUpdaterBaseURL } from "./types";
+import { createUUIDv7 } from "./uuidv7";
 
 export interface ReleaseCatalogRequest {
   readonly platform: "ios" | "android";
@@ -65,6 +67,12 @@ export interface HotUpdaterHttpSession {
     params: ReleaseCatalogRequest,
   ) => Promise<ReleaseCatalog>;
   resolveArtifact: (params: ArtifactRequest) => Promise<ArtifactInfo>;
+  /**
+   * Posts an Insights event under a client `eventId`, retrying a network
+   * error, timeout, 429 or 5xx for up to three attempts in all. Resolves once
+   * the event is delivered or left to background retries; rejects when its
+   * first attempt fails for good, such as with a 400.
+   */
   sendInsightsEvent: (params: InsightsEventParams) => Promise<void>;
 }
 
@@ -101,56 +109,101 @@ const resolveArtifactUrls = (
   info: ArtifactInfo,
 ): ArtifactInfo => ({
   ...info,
-  fileUrl:
-    info.fileUrl === null ? null : resolveArtifactUrl(baseURL, info.fileUrl),
-  ...(info.manifestUrl === undefined
-    ? {}
-    : {
-        manifestUrl:
-          info.manifestUrl === null
-            ? null
-            : resolveArtifactUrl(baseURL, info.manifestUrl),
-      }),
-  ...(info.changedAssets === undefined
-    ? {}
-    : {
-        changedAssets:
-          info.changedAssets === null
-            ? null
-            : Object.fromEntries(
-                Object.entries(info.changedAssets).map(([path, asset]) => [
-                  path,
-                  {
-                    ...asset,
-                    ...(asset.file
-                      ? {
-                          file: {
-                            ...asset.file,
-                            url: resolveArtifactUrl(baseURL, asset.file.url),
-                          },
-                        }
-                      : {}),
-                    ...(asset.patch
-                      ? {
-                          patch: {
-                            ...asset.patch,
-                            patchUrl: resolveArtifactUrl(
-                              baseURL,
-                              asset.patch.patchUrl,
-                            ),
-                          },
-                        }
-                      : {}),
-                  },
-                ]),
-              ),
-      }),
+  manifestUrl: resolveArtifactUrl(baseURL, info.manifestUrl),
+  ...(info.archiveUrl
+    ? { archiveUrl: resolveArtifactUrl(baseURL, info.archiveUrl) }
+    : {}),
+  assets: Object.fromEntries(
+    Object.entries(info.assets).map(([path, asset]) => [
+      path,
+      {
+        ...asset,
+        file: {
+          ...asset.file,
+          url: resolveArtifactUrl(baseURL, asset.file.url),
+        },
+        ...(asset.patch
+          ? {
+              patch: {
+                ...asset.patch,
+                patchUrl: resolveArtifactUrl(baseURL, asset.patch.patchUrl),
+              },
+            }
+          : {}),
+      },
+    ]),
+  ),
 });
 
-const sendInsightsEvent = async (
+const requireArtifactProtocolV1 = (info: ArtifactInfo): ArtifactInfo => {
+  if (
+    info.artifactProtocolVersion !== ARTIFACT_PROTOCOL_VERSION ||
+    !info.assets ||
+    !info.manifestUrl ||
+    !info.manifestFileHash ||
+    (info.archiveUrl !== undefined && typeof info.archiveUrl !== "string")
+  ) {
+    throw new Error(
+      `Server does not support artifact protocol ${ARTIFACT_PROTOCOL_VERSION}.`,
+    );
+  }
+  for (const asset of Object.values(info.assets)) {
+    if (!asset.file?.url || !asset.fileHash) {
+      throw new Error(
+        "Artifact protocol 1 requires an original file for every asset.",
+      );
+    }
+  }
+  return info;
+};
+
+/** Attempts per Insights event, the first one included. */
+const INSIGHTS_MAX_ATTEMPTS = 3;
+/** Wait before the second attempt; it doubles for each later attempt. */
+const INSIGHTS_RETRY_BASE_DELAY_MS = 1000;
+/** Longest wait between attempts, a server's `Retry-After` included. */
+const INSIGHTS_RETRY_MAX_DELAY_MS = 30000;
+
+type InsightsAttemptFailure = {
+  readonly error: Error;
+  /** A network error, timeout, 429 or 5xx may pass on a later attempt. */
+  readonly retryable: boolean;
+  readonly retryAfterMs: number | null;
+};
+
+/**
+ * Reads `Retry-After` as delay-seconds, the form a server under load sends;
+ * an HTTP-date falls back to the backoff.
+ */
+const parseRetryAfterMs = (value: string | null): number | null => {
+  const seconds = value?.trim();
+  return seconds && /^\d+$/.test(seconds) ? Number(seconds) * 1000 : null;
+};
+
+const getRetryDelayMs = (
+  failedAttempt: number,
+  retryAfterMs: number | null,
+): number =>
+  Math.min(
+    retryAfterMs ??
+      // Jitter spreads the retries of installations that failed together.
+      INSIGHTS_RETRY_BASE_DELAY_MS *
+        2 ** (failedAttempt - 1) *
+        (0.5 + Math.random()),
+    INSIGHTS_RETRY_MAX_DELAY_MS,
+  );
+
+const wait = (ms: number) =>
+  new Promise<void>((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+/** Makes one POST, with its own timeout, and settles with its failure. */
+const postInsightsEvent = async (
   baseURL: string,
   params: InsightsEventParams,
-): Promise<void> => {
+  eventId: string,
+): Promise<InsightsAttemptFailure | null> => {
   const controller = new AbortController();
   const timeoutId = setTimeout(() => {
     controller.abort();
@@ -162,6 +215,7 @@ const sendInsightsEvent = async (
         appVersion: params.appVersion,
         channel: params.channel,
         cohort: params.cohort,
+        eventId,
         fingerprintHash: params.fingerprintHash,
         fromBundleId: params.fromBundleId,
         ...(params.fromReleaseId === undefined
@@ -187,22 +241,109 @@ const sendInsightsEvent = async (
       signal: controller.signal,
     });
 
-    if (response.status !== 204) {
-      throw new Error(
+    if (response.status === 204) return null;
+    return {
+      error: new Error(
         `Expected HTTP 204 from /events, received ${response.status}`,
-      );
-    }
+      ),
+      retryable: response.status === 429 || response.status >= 500,
+      retryAfterMs: parseRetryAfterMs(response.headers.get("Retry-After")),
+    };
   } catch (error: unknown) {
-    if (error instanceof Error && error.name === "AbortError") {
-      throw new Error("Request timed out");
-    }
-    throw error;
+    // fetch rejects only when no response arrived (a timeout or a network
+    // error), so a later attempt may still get through.
+    return {
+      error:
+        error instanceof Error && error.name === "AbortError"
+          ? new Error("Request timed out")
+          : error instanceof Error
+            ? error
+            : new Error(String(error)),
+      retryable: true,
+      retryAfterMs: null,
+    };
   } finally {
     clearTimeout(timeoutId);
   }
 };
 
-const createSession = (baseURL: string): HotUpdaterHttpSession => ({
+type InsightsEventSender = (
+  baseURL: string,
+  params: InsightsEventParams,
+) => Promise<void>;
+
+/**
+ * Sends Insights events one at a time and retries each in the background.
+ *
+ * The server keeps an installation's latest report by arrival, so a later
+ * event waits behind an earlier one's retries; otherwise a retried
+ * UPDATE_APPLIED could land after the UPDATE_DOWNLOADED that followed it.
+ * Callers still wait only for first attempts, as they did before retries, so
+ * startup, readiness and `updateBundle()` never wait out a backoff: once an
+ * event backs off, every waiting caller is released, and a failure after that
+ * only warns.
+ */
+const createInsightsEventSender = (): InsightsEventSender => {
+  let queue = Promise.resolve();
+  let retrying = false;
+  const waiting = new Set<() => void>();
+
+  return (baseURL, params) => {
+    // One ID for every attempt, so the server counts a retried POST once.
+    const eventId = createUUIDv7();
+
+    return new Promise<void>((resolve, reject) => {
+      let released = false;
+      const release = () => {
+        released = true;
+        waiting.delete(release);
+        resolve();
+      };
+      if (retrying) release();
+      else waiting.add(release);
+
+      queue = queue.then(async () => {
+        try {
+          for (let attempt = 1; ; attempt += 1) {
+            const failure = await postInsightsEvent(baseURL, params, eventId);
+            if (failure === null) {
+              release();
+              break;
+            }
+            if (!failure.retryable || attempt === INSIGHTS_MAX_ATTEMPTS) {
+              waiting.delete(release);
+              if (released) {
+                console.warn(
+                  `[HotUpdater] Insights ${params.type} event was not delivered:`,
+                  failure.error,
+                );
+              } else {
+                reject(failure.error);
+              }
+              break;
+            }
+            retrying = true;
+            for (const releaseWaiting of waiting) releaseWaiting();
+            await wait(getRetryDelayMs(attempt, failure.retryAfterMs));
+          }
+        } catch (error: unknown) {
+          // A failed request settles in postInsightsEvent, so only a bug gets
+          // here. A rejected queue would leave every later event, and a caller
+          // such as `updateBundle()` waiting on one, pending forever.
+          waiting.delete(release);
+          if (!released) reject(error);
+        } finally {
+          retrying = false;
+        }
+      });
+    });
+  };
+};
+
+const createSession = (
+  baseURL: string,
+  sendInsightsEvent: InsightsEventSender,
+): HotUpdaterHttpSession => ({
   fetchReleaseCatalog: async (params): Promise<ReleaseCatalog> => {
     const channelKey = encodeChannelKey(params.channel);
     let strategyValue: string;
@@ -241,14 +382,25 @@ const createSession = (baseURL: string): HotUpdaterHttpSession => ({
     });
   },
   resolveArtifact: async (params): Promise<ArtifactInfo> => {
-    const info = await fetchJSON<ArtifactInfo>({
-      requestHeaders: params.requestHeaders,
-      requestTimeout: params.requestTimeout,
-      url: `${baseURL}/artifacts/${encodeURIComponent(
-        params.targetBundleId,
-      )}/from/${encodeURIComponent(params.currentBundleId)}`,
-    });
-    return resolveArtifactUrls(baseURL, info);
+    let info: ArtifactInfo;
+    try {
+      info = await fetchJSON<ArtifactInfo>({
+        requestHeaders: params.requestHeaders,
+        requestTimeout: params.requestTimeout,
+        url: `${baseURL}/artifacts/v1/${encodeURIComponent(
+          params.targetBundleId,
+        )}/from/${encodeURIComponent(params.currentBundleId)}`,
+      });
+    } catch (error) {
+      if (error instanceof FetchJSONResponseError && error.status === 404) {
+        throw new Error(
+          `Server does not support artifact protocol ${ARTIFACT_PROTOCOL_VERSION}.`,
+          { cause: error },
+        );
+      }
+      throw error;
+    }
+    return resolveArtifactUrls(baseURL, requireArtifactProtocolV1(info));
   },
   sendInsightsEvent: (params) => sendInsightsEvent(baseURL, params),
 });
@@ -256,6 +408,11 @@ const createSession = (baseURL: string): HotUpdaterHttpSession => ({
 /** Creates the private HTTP client used by HotUpdater.init and HotUpdater.wrap. */
 export const createHttpClient = (
   baseURL: HotUpdaterBaseURL,
-): HotUpdaterHttpClient => ({
-  createSession: async () => createSession(await resolveBaseURL(baseURL)),
-});
+): HotUpdaterHttpClient => {
+  // Shared by every session, since each report opens its own session.
+  const sendInsightsEvent = createInsightsEventSender();
+  return {
+    createSession: async () =>
+      createSession(await resolveBaseURL(baseURL), sendInsightsEvent),
+  };
+};