Method refresh

packages/shared/pr-context-live.ts:207–281

(
    url: string,
    ref: PRRef,
    reason: PRContextRefreshReason,
    options?: {
      readonly force?: boolean;
      readonly queueAfterInflight?: boolean;
    },
  )

  }

  private refresh(
    url: string,
    ref: PRRef,
    reason: PRContextRefreshReason,
    options?: {
      readonly force?: boolean;
      readonly queueAfterInflight?: boolean;
    },
  ): Promise<PRContext> {
    const entry = this.ensureEntry(url, ref);
    if (entry.inflight) {
      if (options?.queueAfterInflight) entry.refreshAfterInflight = true;
      return entry.inflight;
    }

    const now = this.now();
    if (!options?.force && now < entry.nextAllowedRefreshAt) {
      if (entry.context) return Promise.resolve(entry.context);
      return Promise.reject(new Error(entry.error ?? "PR context refresh is paused"));
    }

    this.clearScheduledTimer(entry);
    this.broadcast(entry, { type: "loading", url, version: entry.version });

    const promise = Promise.resolve()
      .then(() => this.fetchContext(ref))
      .then((context) => {
        entry.context = context;
        entry.error = null;
        entry.lastSuccessAt = this.now();
        entry.nextAllowedRefreshAt = 0;
        entry.version += 1;
        this.broadcast(entry, {
          type: "updated",
          url,
          version: entry.version,
          context,
          stale: false,
        });
        return context;
      })
      .catch((cause: unknown) => {
        const message = messageFromUnknown(cause);
        const retryAt = this.now() + this.failureCooldownMs;
        entry.error = message;
        entry.nextAllowedRefreshAt = retryAt;
        entry.version += 1;
        this.broadcast(entry, {
          type: "error",
          url,
          version: entry.version,
          error: message,
          stale: entry.context !== null,
          retryAt,
        });
        throw cause;
      })
      .finally(() => {