@trolleroof/tui 0.2.5 → 0.2.6

package/src/sync/coordinator.test.ts

@@ -0,0 +1,423 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import type { ResultTransport } from "../results/transport.js";
+import { RecordingStore } from "../recording/store.js";
+import { FakeTransport } from "../recording/transport.js";
+import type { IngestAcknowledgment, TraceEventChunk } from "../recording/types.js";
+import type { BackendConfig } from "./config.js";
+import { RecordingSyncCoordinator } from "./coordinator.js";
+import { GameStartQueue } from "./game-start-queue.js";
+
+const roots: string[] = [];
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+const config: BackendConfig = {
+  baseUrl: "https://retro.example",
+  token: "retro_token",
+  meUrl: "https://retro.example/v1/me",
+  eventChunksUrl: "https://retro.example/v1/game-event-chunks",
+  gameResultsUrl: "https://retro.example/v1/game-results",
+};
+
+function chunk(userId: string, suffix: string): TraceEventChunk {
+  return {
+    schema_version: 2,
+    user_id: userId,
+    game_id: `game_${suffix}`,
+    game_type: "2048",
+    game_version: "1",
+    chunk_id: `chk_${suffix}`,
+    chunk_sequence: 1,
+    first_event_sequence: 1,
+    last_event_sequence: 1,
+    event_count: 1,
+    created_at_ms: 1,
+    client: { platform: "tui", application_version: "test", recording_sdk_version: "2" },
+    events: [{
+      schema_version: 2,
+      user_id: userId,
+      game_id: `game_${suffix}`,
+      chunk_id: `chk_${suffix}`,
+      event_id: `evt_${suffix}`,
+      event_sequence: 1,
+      event_version: 1,
+      event_type: "episode_ended",
+      visibility: "policy",
+      client_time_ms: 1,
+      monotonic_time_us: 1,
+      payload: {
+        reason: "user_quit",
+        final_event_sequence: 1,
+        final_score: 0,
+        duration_us: 1,
+        completed: false,
+      },
+    }],
+  };
+}
+
+function ack(value: TraceEventChunk): IngestAcknowledgment {
+  return {
+    accepted: true,
+    duplicate: false,
+    game_id: value.game_id,
+    chunk_id: value.chunk_id,
+    chunk_sequence: value.chunk_sequence,
+    accepted_event_range: { first: 1, last: 1 },
+    queued: true,
+    server_received_at_ms: 2,
+  };
+}
+
+describe("RecordingSyncCoordinator", () => {
+  it("keeps a direct offline launch queued until deferred recovery completes", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-offline-race-"));
+    roots.push(root);
+    const store = new RecordingStore(root);
+    let releaseRecovery!: () => void;
+    const recoveryGate = new Promise<void>((resolve) => { releaseRecovery = resolve; });
+    let recoveryStarted!: () => void;
+    const startedRecovery = new Promise<void>((resolve) => { recoveryStarted = resolve; });
+    let activeDuringRecovery: string[] = [];
+    const coordinator = new RecordingSyncCoordinator(store, {
+      config: null,
+      recoverLocal: async () => {
+        recoveryStarted();
+        await recoveryGate;
+        activeDuringRecovery = store.listActiveGameIds();
+      },
+    });
+    const starts: Array<{ game: string; userId: string | null }> = [];
+    const queue = new GameStartQueue({
+      resolveRecording: () => coordinator.resolveRecordingIdentity("usr_local"),
+      start: (request, recording) => {
+        starts.push({ game: request.game, userId: recording.userId });
+        store.appendEvent("game_live", chunk("usr_local", "live").events[0]!);
+      },
+    });
+
+    const pending = queue.request({ game: "2048", variation: "classic", source: "direct" });
+    await startedRecovery;
+    expect(starts).toEqual([]);
+    expect(store.listActiveGameIds()).toEqual([]);
+    releaseRecovery();
+    await pending;
+    expect(activeDuringRecovery).toEqual([]);
+    expect(starts).toEqual([{ game: "2048", userId: "usr_local" }]);
+    expect(store.listActiveGameIds()).toEqual(["game_live"]);
+  });
+
+  it("keeps an episode unrecorded when local recovery cannot complete", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-recovery-failure-"));
+    roots.push(root);
+    const coordinator = new RecordingSyncCoordinator(new RecordingStore(root), {
+      config: null,
+      recoverLocal: async () => { throw new Error("corrupt local journal"); },
+    });
+
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toEqual({
+      userId: null,
+      remote: false,
+      recordable: false,
+    });
+    expect(coordinator.lastError).toBe("corrupt local journal");
+  });
+
+  it("does not expose the local fallback while configured identity is unresolved", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-race-"));
+    roots.push(root);
+    let finish!: (value: string) => void;
+    const identity = new Promise<string>((resolve) => { finish = resolve; });
+    const coordinator = new RecordingSyncCoordinator(new RecordingStore(root), {
+      config,
+      identityClient: { resolve: async () => identity },
+    });
+
+    const pending = coordinator.resolveRecordingIdentity("usr_local");
+    await Promise.resolve();
+    expect(coordinator.userId).toBeNull();
+    finish("usr_backend");
+    await expect(pending).resolves.toEqual({
+      userId: "usr_backend",
+      remote: true,
+      recordable: true,
+    });
+  });
+
+  it("leaves a failed configured episode unrecorded and retries identity later", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-local-only-"));
+    roots.push(root);
+    const store = new RecordingStore(root);
+    store.persistChunk(chunk("usr_local", "local"));
+    const transport = new FakeTransport(async (persisted) => ack(persisted.chunk as TraceEventChunk));
+    let calls = 0;
+    const coordinator = new RecordingSyncCoordinator(store, {
+      config,
+      chunkTransport: transport,
+      identityClient: {
+        async resolve() {
+          calls++;
+          if (calls === 1) throw new Error("backend offline");
+          return "usr_backend";
+        },
+      },
+    });
+
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toEqual({
+      userId: null,
+      remote: false,
+      recordable: false,
+    });
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toEqual({
+      userId: "usr_backend",
+      remote: true,
+      recordable: true,
+    });
+    await coordinator.requestDrain();
+    expect(calls).toBe(2);
+    expect(transport.requests).toEqual([]);
+    expect(store.listPending()).toHaveLength(1);
+  });
+
+  it("yields before completed-game recovery starts", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-yield-"));
+    roots.push(root);
+    let release!: () => void;
+    const gate = new Promise<void>((resolve) => { release = resolve; });
+    let listCalls = 0;
+    class CountingStore extends RecordingStore {
+      override async *iterateCompletedGamesBatched(
+        options: Parameters<RecordingStore["iterateCompletedGamesBatched"]>[0],
+      ) {
+        listCalls++;
+        yield* super.iterateCompletedGamesBatched(options);
+      }
+    }
+    let localRecoveryCalls = 0;
+    const coordinator = new RecordingSyncCoordinator(new CountingStore(root), {
+      config: null,
+      yieldControl: async () => gate,
+      recoverLocal: () => { localRecoveryCalls++; },
+    });
+
+    const pending = coordinator.bootstrapAndDrain();
+    expect(listCalls).toBe(0);
+    expect(localRecoveryCalls).toBe(0);
+    release();
+    await pending;
+    expect(listCalls).toBe(1);
+    expect(localRecoveryCalls).toBe(1);
+  });
+
+  it("cancels during the second recovery yield before later batches run", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-recovery-cancel-"));
+    roots.push(root);
+    let yieldCount = 0;
+    let releaseSecond!: () => void;
+    let reachedSecond!: () => void;
+    const secondReached = new Promise<void>((resolve) => { reachedSecond = resolve; });
+    const secondGate = new Promise<void>((resolve) => { releaseSecond = resolve; });
+    const processed: number[] = [];
+    const coordinator = new RecordingSyncCoordinator(new RecordingStore(root), {
+      config: null,
+      yieldControl: async () => {
+        yieldCount++;
+        if (yieldCount === 2) {
+          reachedSecond();
+          await secondGate;
+        }
+      },
+      recoverLocal: async (yieldControl, signal) => {
+        for (let batch = 0; batch < 4; batch++) {
+          if (signal.aborted) return;
+          processed.push(batch);
+          await yieldControl();
+        }
+      },
+    });
+
+    const recovery = coordinator.bootstrapAndDrain();
+    await secondReached;
+    coordinator.cancel();
+    releaseSecond();
+    await recovery;
+    expect(processed).toEqual([0]);
+  });
+
+  it("cancels an active drain and leaves work pending for the next launch", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-cancel-"));
+    roots.push(root);
+    const store = new RecordingStore(root);
+    store.persistChunk(chunk("usr_backend", "cancel"));
+    let aborted = false;
+    let started!: () => void;
+    const sending = new Promise<void>((resolve) => { started = resolve; });
+    const transport = {
+      enabled: true,
+      async send(_persisted: unknown, signal?: AbortSignal) {
+        started();
+        await new Promise<void>((resolve) => {
+          signal?.addEventListener("abort", () => {
+            aborted = true;
+            resolve();
+          });
+        });
+        throw new DOMException("aborted", "AbortError");
+      },
+    };
+    const coordinator = new RecordingSyncCoordinator(store, {
+      config,
+      identityClient: { resolve: async () => "usr_backend" },
+      chunkTransport: transport,
+    });
+
+    const draining = coordinator.requestDrain();
+    await sending;
+    coordinator.cancel();
+    await draining;
+    expect(aborted).toBe(true);
+    expect(store.listPending()).toHaveLength(1);
+  });
+
+  it("resolves identity once, stays single-flight, and drains only that user", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-"));
+    roots.push(root);
+    const store = new RecordingStore(root);
+    store.persistChunk(chunk("usr_a", "a"));
+    store.persistChunk(chunk("usr_b", "b"));
+    let identityCalls = 0;
+    const transport = new FakeTransport(async (persisted) => ack(persisted.chunk as TraceEventChunk));
+    const resultTransport: ResultTransport = {
+      async send() {
+        return { accepted: true, personal_best: 0, high_score_updated: false };
+      },
+    };
+    const coordinator = new RecordingSyncCoordinator(store, {
+      config,
+      identityClient: {
+        async resolve() {
+          identityCalls++;
+          await Promise.resolve();
+          return "usr_b";
+        },
+      },
+      chunkTransport: transport,
+      resultTransport,
+    });
+
+    const first = coordinator.bootstrapAndDrain();
+    const second = coordinator.bootstrapAndDrain();
+    expect(first).toBe(second);
+    await first;
+    expect(identityCalls).toBe(1);
+    expect(transport.requests.map((item) =>
+      item.chunk.schema_version === 2 ? item.chunk.user_id : null
+    )).toEqual(["usr_b"]);
+    expect(store.listPending().map((item) => item.chunk.game_id)).toEqual(["game_a"]);
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toEqual({
+      userId: "usr_b",
+      remote: true,
+      recordable: true,
+    });
+  });
+
+  it("reloads rotated backend credentials before a later game", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-rotation-"));
+    roots.push(root);
+    let current = { ...config, token: "token_a" };
+    const authorizations: string[] = [];
+    const coordinator = new RecordingSyncCoordinator(new RecordingStore(root), {
+      config: null,
+      configProvider: () => current,
+      fetch: async (_input, init) => {
+        const authorization = new Headers(init?.headers).get("Authorization") ?? "";
+        authorizations.push(authorization);
+        const userId = authorization === "Bearer token_a" ? "usr_a" : "usr_b";
+        return new Response(JSON.stringify({ user_id: userId }), { status: 200 });
+      },
+    });
+
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toMatchObject({
+      userId: "usr_a",
+      recordable: true,
+    });
+    current = { ...config, token: "token_b" };
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toMatchObject({
+      userId: "usr_b",
+      recordable: true,
+    });
+    expect(authorizations).toEqual(["Bearer token_a", "Bearer token_b"]);
+  });
+
+  it("never mixes a rotated token into an in-flight user's drain", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-rotation-drain-"));
+    roots.push(root);
+    const store = new RecordingStore(root);
+    store.persistChunk(chunk("usr_a", "rotation"));
+    let current = { ...config, token: "token_a" };
+    let releaseChunk!: () => void;
+    const chunkGate = new Promise<void>((resolve) => { releaseChunk = resolve; });
+    let markChunkStarted!: () => void;
+    const chunkStarted = new Promise<void>((resolve) => { markChunkStarted = resolve; });
+    const resultAuthorizations: string[] = [];
+    const coordinator = new RecordingSyncCoordinator(store, {
+      config: null,
+      configProvider: () => current,
+      fetch: async (input, init) => {
+        const url = String(input);
+        const authorization = new Headers(init?.headers).get("Authorization") ?? "";
+        if (url.endsWith("/v1/me")) {
+          const userId = authorization === "Bearer token_a" ? "usr_a" : "usr_b";
+          return new Response(JSON.stringify({ user_id: userId }), { status: 200 });
+        }
+        if (url.endsWith("/v1/game-event-chunks")) {
+          markChunkStarted();
+          await chunkGate;
+          return new Response(JSON.stringify(ack(chunk("usr_a", "rotation"))), { status: 202 });
+        }
+        resultAuthorizations.push(authorization);
+        return new Response(JSON.stringify({
+          accepted: true,
+          personal_best: 1,
+          high_score_updated: true,
+        }), { status: 200 });
+      },
+    });
+    coordinator.results.persist("usr_a", {
+      result_id: "res_rotation",
+      game_id: "game_rotation",
+      game_type: "2048",
+      score: 1,
+      completed_at: "2026-01-01T00:00:00.000Z",
+    });
+
+    await coordinator.resolveRecordingIdentity("usr_local");
+    await chunkStarted;
+    current = { ...config, token: "token_b" };
+    await coordinator.resolveRecordingIdentity("usr_local");
+    releaseChunk();
+    await coordinator.requestDrain();
+    expect(resultAuthorizations).toEqual([]);
+    expect(coordinator.results.listPending("usr_a")).toHaveLength(1);
+  });
+
+  it("keeps offline recording available without backend configuration", async () => {
+    const root = mkdtempSync(join(tmpdir(), "gamepigeon-sync-offline-"));
+    roots.push(root);
+    const store = new RecordingStore(root);
+    const coordinator = new RecordingSyncCoordinator(store, {
+      config: null,
+    });
+    await coordinator.bootstrapAndDrain();
+    expect(coordinator.userId).toBeNull();
+    await expect(coordinator.resolveRecordingIdentity("usr_local")).resolves.toEqual({
+      userId: "usr_local",
+      remote: false,
+      recordable: true,
+    });
+  });
+});

package/src/sync/coordinator.ts

@@ -0,0 +1,277 @@
+import { recoverCompletedResultsBatched } from "../results/completion.js";
+import { enqueueCompletedResult } from "../results/completion.js";
+import { ResultStore } from "../results/store.js";
+import { HttpResultTransport, type ResultTransport } from "../results/transport.js";
+import { ResultUploader } from "../results/uploader.js";
+import { RecordingStore } from "../recording/store.js";
+import { HttpTransport, type ChunkTransport } from "../recording/transport.js";
+import { ChunkUploader } from "../recording/uploader.js";
+import type { InteractionTraceRecorder } from "../recording/trace-recorder.js";
+import type { BackendConfig } from "./config.js";
+import { IdentityClient } from "./identity-client.js";
+
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+
+export interface RecordingSyncCoordinatorOptions {
+  resultStore?: ResultStore;
+  config: BackendConfig | null;
+  configProvider?: () => BackendConfig | null;
+  fetch?: Fetch;
+  identityClient?: Pick<IdentityClient, "resolve">;
+  chunkTransport?: ChunkTransport;
+  resultTransport?: ResultTransport;
+  yieldControl?: () => Promise<void>;
+  recoverLocal?: (
+    yieldControl: () => Promise<void>,
+    signal: AbortSignal,
+    batchSize: number,
+  ) => void | Promise<void>;
+  recoveryBatchSize?: number;
+}
+
+export interface RecordingIdentity {
+  userId: string | null;
+  remote: boolean;
+  recordable: boolean;
+}
+
+export class RecordingSyncCoordinator {
+  readonly results: ResultStore;
+  private readonly configProvider: () => BackendConfig | null;
+  private readonly request: Fetch;
+  private readonly providedIdentity: Pick<IdentityClient, "resolve"> | undefined;
+  private readonly providedChunkTransport: ChunkTransport | undefined;
+  private readonly providedResultTransport: ResultTransport | undefined;
+  private readonly yieldControl: () => Promise<void>;
+  private readonly recoverLocal: (
+    yieldControl: () => Promise<void>,
+    signal: AbortSignal,
+    batchSize: number,
+  ) => void | Promise<void>;
+  private readonly recoveryBatchSize: number;
+  private readonly cancellation = new AbortController();
+  private config: BackendConfig | null = null;
+  private configFingerprint: string | null = null;
+  private identity: Pick<IdentityClient, "resolve"> | null = null;
+  private chunks: ChunkUploader | null = null;
+  private resultUploader: ResultUploader | null = null;
+  private backendGeneration = 0;
+  private currentDrain: Promise<void> | null = null;
+  private bootstrapPromise: Promise<void> | null = null;
+  private recoveryPromise: Promise<void> | null = null;
+  private identityResolution: Promise<string | null> | null = null;
+  private drainRequested = false;
+  private recoverySucceeded = false;
+  private verifiedUserId: string | null = null;
+  private error: string | null = null;
+
+  constructor(private readonly recordings: RecordingStore, options: RecordingSyncCoordinatorOptions) {
+    this.results = options.resultStore ?? new ResultStore(recordings.root);
+    this.configProvider = options.configProvider ?? (() => options.config);
+    this.request = options.fetch ?? globalThis.fetch;
+    this.providedIdentity = options.identityClient;
+    this.providedChunkTransport = options.chunkTransport;
+    this.providedResultTransport = options.resultTransport;
+    this.yieldControl = options.yieldControl ?? (() =>
+      new Promise<void>((resolve) => setTimeout(resolve, 0))
+    );
+    this.recoverLocal = options.recoverLocal ?? (() => undefined);
+    this.recoveryBatchSize = Math.max(1, options.recoveryBatchSize ?? 16);
+  }
+
+  get userId(): string | null {
+    return this.verifiedUserId;
+  }
+
+  get lastError(): string | null {
+    return this.error;
+  }
+
+  async resolveRecordingIdentity(localUserId: string): Promise<RecordingIdentity> {
+    await this.ready();
+    if (this.cancellation.signal.aborted) {
+      return { userId: null, remote: false, recordable: false };
+    }
+    if (!this.recoverySucceeded) {
+      return { userId: null, remote: false, recordable: false };
+    }
+    if (!this.refreshBackend()) {
+      return { userId: localUserId, remote: false, recordable: true };
+    }
+    const remoteUserId = await this.resolveVerifiedIdentity();
+    if (!remoteUserId) return { userId: null, remote: false, recordable: false };
+    void this.requestDrain();
+    return { userId: remoteUserId, remote: true, recordable: true };
+  }
+
+  bootstrapAndDrain(): Promise<void> {
+    this.bootstrapPromise ??= this.bootstrap();
+    return this.bootstrapPromise;
+  }
+
+  cancel(): void {
+    this.drainRequested = false;
+    this.cancellation.abort();
+  }
+
+  enqueueCompletedGame(
+    recorder: InteractionTraceRecorder,
+    score: number,
+    completedAtMs: number,
+  ): boolean {
+    try {
+      enqueueCompletedResult({
+        store: this.results,
+        recorder,
+        score,
+        completedAtMs,
+      });
+      void this.requestDrain();
+      return true;
+    } catch (error) {
+      this.error = error instanceof Error ? error.message : String(error);
+      return false;
+    }
+  }
+
+  requestDrain(): Promise<void> {
+    if (this.cancellation.signal.aborted) {
+      return Promise.resolve();
+    }
+    this.drainRequested = true;
+    if (this.currentDrain) return this.currentDrain;
+    this.currentDrain = this.drainLoop().finally(() => {
+      this.currentDrain = null;
+      if (this.drainRequested) void this.requestDrain();
+    });
+    return this.currentDrain;
+  }
+
+  private async drainLoop(): Promise<void> {
+    try {
+      while (this.drainRequested && !this.cancellation.signal.aborted) {
+        this.drainRequested = false;
+        if (!this.refreshBackend()) return;
+        if (!this.identity || !this.chunks || !this.resultUploader) return;
+        const generation = this.backendGeneration;
+        const chunks = this.chunks;
+        const resultUploader = this.resultUploader;
+        const userId = await this.resolveVerifiedIdentity();
+        if (
+          !userId || this.cancellation.signal.aborted ||
+          generation !== this.backendGeneration
+        ) return;
+        await chunks.uploadPending(userId, this.cancellation.signal);
+        if (generation !== this.backendGeneration) return;
+        await resultUploader.uploadPending(userId, this.cancellation.signal);
+        if (!this.cancellation.signal.aborted) this.error = null;
+      }
+    } catch (error) {
+      if (!this.cancellation.signal.aborted) {
+        this.error = error instanceof Error ? error.message : String(error);
+      }
+    }
+  }
+
+  private async bootstrap(): Promise<void> {
+    await this.ready();
+    if (this.cancellation.signal.aborted) return;
+    await this.yieldControl();
+    if (this.cancellation.signal.aborted) return;
+    await this.requestDrain();
+  }
+
+  private ready(): Promise<void> {
+    this.recoveryPromise ??= this.recover();
+    return this.recoveryPromise;
+  }
+
+  private async recover(): Promise<void> {
+    await this.yieldControl();
+    if (this.cancellation.signal.aborted) return;
+    try {
+      await this.recoverLocal(
+        this.yieldControl,
+        this.cancellation.signal,
+        this.recoveryBatchSize,
+      );
+      if (this.cancellation.signal.aborted) return;
+      await recoverCompletedResultsBatched(this.recordings, this.results, {
+        batchSize: this.recoveryBatchSize,
+        yieldControl: this.yieldControl,
+        signal: this.cancellation.signal,
+      });
+      if (this.cancellation.signal.aborted) return;
+      this.recoverySucceeded = true;
+    } catch (error) {
+      this.error = error instanceof Error ? error.message : String(error);
+    }
+  }
+
+  private refreshBackend(): BackendConfig | null {
+    let next: BackendConfig | null;
+    try {
+      next = this.configProvider();
+    } catch (error) {
+      this.error = error instanceof Error ? error.message : String(error);
+      next = null;
+    }
+    const fingerprint = next ? `${next.baseUrl}\0${next.token}` : null;
+    if (fingerprint === this.configFingerprint) return this.config;
+    this.backendGeneration++;
+    this.config = next;
+    this.configFingerprint = fingerprint;
+    this.verifiedUserId = null;
+    this.identityResolution = null;
+    if (!next) {
+      this.identity = null;
+      this.chunks = null;
+      this.resultUploader = null;
+      return null;
+    }
+    this.identity = this.providedIdentity ?? new IdentityClient(next, this.request);
+    this.chunks = new ChunkUploader(
+      this.recordings,
+      this.providedChunkTransport ?? new HttpTransport(next.eventChunksUrl, {
+        token: next.token,
+        fetch: this.request,
+      }),
+    );
+    this.resultUploader = new ResultUploader(
+      this.results,
+      this.providedResultTransport ?? new HttpResultTransport(
+        next.gameResultsUrl,
+        next.token,
+        this.request,
+      ),
+    );
+    return next;
+  }
+
+  private resolveVerifiedIdentity(): Promise<string | null> {
+    if (!this.identity || this.cancellation.signal.aborted) {
+      return Promise.resolve(null);
+    }
+    if (this.verifiedUserId) return Promise.resolve(this.verifiedUserId);
+    if (this.identityResolution) return this.identityResolution;
+    const identity = this.identity;
+    const generation = this.backendGeneration;
+    const resolution = identity.resolve(this.cancellation.signal)
+      .then((userId) => {
+        if (this.cancellation.signal.aborted || generation !== this.backendGeneration) return null;
+        this.verifiedUserId = userId;
+        return userId;
+      })
+      .catch((error: unknown) => {
+        if (!this.cancellation.signal.aborted) {
+          this.error = error instanceof Error ? error.message : String(error);
+        }
+        return null;
+      })
+      .finally(() => {
+        if (this.identityResolution === resolution) this.identityResolution = null;
+      });
+    this.identityResolution = resolution;
+    return resolution;
+  }
+}