@oxy.so/core 4.5.0-oxy-one.1 → 4.5.0

package/src/api/privacy.ts

@@ -27,9 +27,17 @@ export class PrivacyApi {
   }
 
   /** Update privacy settings (default: the signed-in user's). */
-  async updateSettings(settings: Partial<PrivacySettings>, userId?: string): Promise<PrivacySettings> {
+  async updateSettings(
+    settings: Partial<PrivacySettings>,
+    userId?: string,
+  ): Promise<PrivacySettings> {
     const id = await this.resolveUserId(userId);
-    const res = await this.ctx.request<PrivacySettings>('PATCH', `/privacy/${id}/privacy`, settings, { cache: false });
+    const res = await this.ctx.request<PrivacySettings>(
+      'PATCH',
+      `/privacy/${id}/privacy`,
+      settings,
+      { cache: false },
+    );
     // Privacy settings ride the user DTO, so every identity read goes stale too.
     evictOxyIdentityCache(this.ctx.http, id);
     this.ctx.oxy.cache.delete(`GET:/privacy/${id}/privacy`);
@@ -40,13 +48,21 @@ export class PrivacyApi {
 
   /** The signed-in user's blocked users. */
   async blocked(): Promise<BlockedUser[]> {
-    return this.ctx.request<BlockedUser[]>('GET', '/privacy/blocked', undefined, { cache: true, cacheTTL: LIST_TTL });
+    return this.ctx.request<BlockedUser[]>('GET', '/privacy/blocked', undefined, {
+      cache: true,
+      cacheTTL: LIST_TTL,
+    });
   }
 
   /** Block a user. */
   async block(userId: string): Promise<{ message: string }> {
     requireId(userId);
-    const res = await this.ctx.request<{ message: string }>('POST', `/privacy/blocked/${userId}`, undefined, { cache: false });
+    const res = await this.ctx.request<{ message: string }>(
+      'POST',
+      `/privacy/blocked/${userId}`,
+      undefined,
+      { cache: false },
+    );
     this.invalidate('GET:/privacy/blocked');
     return res;
   }
@@ -54,7 +70,12 @@ export class PrivacyApi {
   /** Unblock a user. */
   async unblock(userId: string): Promise<{ message: string }> {
     requireId(userId);
-    const res = await this.ctx.request<{ message: string }>('DELETE', `/privacy/blocked/${userId}`, undefined, { cache: false });
+    const res = await this.ctx.request<{ message: string }>(
+      'DELETE',
+      `/privacy/blocked/${userId}`,
+      undefined,
+      { cache: false },
+    );
     this.invalidate('GET:/privacy/blocked');
     return res;
   }
@@ -73,13 +94,21 @@ export class PrivacyApi {
 
   /** The signed-in user's restricted users. */
   async restricted(): Promise<RestrictedUser[]> {
-    return this.ctx.request<RestrictedUser[]>('GET', '/privacy/restricted', undefined, { cache: true, cacheTTL: LIST_TTL });
+    return this.ctx.request<RestrictedUser[]>('GET', '/privacy/restricted', undefined, {
+      cache: true,
+      cacheTTL: LIST_TTL,
+    });
   }
 
   /** Restrict a user: limit their interactions without blocking them. */
   async restrict(userId: string): Promise<{ message: string }> {
     requireId(userId);
-    const res = await this.ctx.request<{ message: string }>('POST', `/privacy/restricted/${userId}`, undefined, { cache: false });
+    const res = await this.ctx.request<{ message: string }>(
+      'POST',
+      `/privacy/restricted/${userId}`,
+      undefined,
+      { cache: false },
+    );
     this.invalidate('GET:/privacy/restricted');
     return res;
   }
@@ -87,7 +116,12 @@ export class PrivacyApi {
   /** Lift a restriction. */
   async unrestrict(userId: string): Promise<{ message: string }> {
     requireId(userId);
-    const res = await this.ctx.request<{ message: string }>('DELETE', `/privacy/restricted/${userId}`, undefined, { cache: false });
+    const res = await this.ctx.request<{ message: string }>(
+      'DELETE',
+      `/privacy/restricted/${userId}`,
+      undefined,
+      { cache: false },
+    );
     this.invalidate('GET:/privacy/restricted');
     return res;
   }

package/src/api/reputation.ts

@@ -53,7 +53,9 @@ export class ReputationApi {
     const mine = !userId;
     const id = userId || this.ctx.oxy.session.userId;
     if (!id) {
-      throw new OxyAuthenticationError('Reading your own reputation balance requires a signed-in user');
+      throw new OxyAuthenticationError(
+        'Reading your own reputation balance requires a signed-in user',
+      );
     }
     const balance = await this.ctx.request<ReputationBalanceView>(
       'GET',
@@ -82,10 +84,15 @@ export class ReputationApi {
 
   /** The enabled rules: what earns and what costs reputation. */
   async rules(): Promise<ReputationRule[]> {
-    const res = await this.ctx.request<{ rules?: ReputationRule[] }>('GET', '/reputation/rules', undefined, {
-      cache: true,
-      cacheTTL: EXTRA_LONG,
-    });
+    const res = await this.ctx.request<{ rules?: ReputationRule[] }>(
+      'GET',
+      '/reputation/rules',
+      undefined,
+      {
+        cache: true,
+        cacheTTL: EXTRA_LONG,
+      },
+    );
     return res.rules ?? [];
   }
 
@@ -109,7 +116,10 @@ export class ReputationApi {
    * user's). Auth required.
    * @param context - The weight axis (server default: `default`).
    */
-  async influence(userId?: string, context?: ReputationInfluenceContext): Promise<ReputationInfluenceResult> {
+  async influence(
+    userId?: string,
+    context?: ReputationInfluenceContext,
+  ): Promise<ReputationInfluenceResult> {
     const id = this.resolveUserId(userId);
     return this.ctx.request<ReputationInfluenceResult>(
       'GET',
@@ -121,7 +131,8 @@ export class ReputationApi {
 
   protected resolveUserId(userId?: string): string {
     const id = userId || this.ctx.oxy.session.userId;
-    if (!id) throw new OxyAuthenticationError('A user id is required (none given and not signed in)');
+    if (!id)
+      throw new OxyAuthenticationError('A user id is required (none given and not signed in)');
     return id;
   }
 }

package/src/api/session.ts

@@ -140,7 +140,13 @@ export class SessionApi {
     if (!provider) return null;
     try {
       const proof = await provider();
-      if (proof && typeof proof.deviceId === 'string' && proof.deviceId && typeof proof.deviceSecret === 'string' && proof.deviceSecret) {
+      if (
+        proof &&
+        typeof proof.deviceId === 'string' &&
+        proof.deviceId &&
+        typeof proof.deviceSecret === 'string' &&
+        proof.deviceSecret
+      ) {
         return { deviceId: proof.deviceId, deviceSecret: proof.deviceSecret };
       }
       return null;
@@ -155,7 +161,10 @@ export class SessionApi {
   async validateToken(): Promise<boolean> {
     if (!this.isAuthenticated) return false;
     try {
-      const res = await this.ctx.request<{ valid: boolean }>('GET', '/auth/validate', undefined, { cache: false, retry: false });
+      const res = await this.ctx.request<{ valid: boolean }>('GET', '/auth/validate', undefined, {
+        cache: false,
+        retry: false,
+      });
       return res.valid === true;
     } catch {
       return false;
@@ -171,7 +180,12 @@ export class SessionApi {
     if (options.deviceFingerprint) params.deviceFingerprint = options.deviceFingerprint;
     if (options.useHeaderValidation) params.useHeaderValidation = 'true';
     try {
-      const validation = await this.ctx.request<SessionValidation>('GET', `/session/validate/${sessionId}`, params, { cache: false });
+      const validation = await this.ctx.request<SessionValidation>(
+        'GET',
+        `/session/validate/${sessionId}`,
+        params,
+        { cache: false },
+      );
       return { ...validation, user: normalizeUserIdentity(validation.user) };
     } catch (error) {
       // The session is gone: drop any user cached for it (#196).
@@ -182,12 +196,16 @@ export class SessionApi {
 
   /** The sessions that belong with `sessionId` (same account set). */
   async list(sessionId: string): Promise<ClientSession[]> {
-    return this.ctx.request<ClientSession[]>('GET', `/session/sessions/${sessionId}`, undefined, { cache: false });
+    return this.ctx.request<ClientSession[]>('GET', `/session/sessions/${sessionId}`, undefined, {
+      cache: false,
+    });
   }
 
   /** Sign out `sessionId`, or — with `targetSessionId` — one of the sessions beside it. */
   async logout(sessionId: string, targetSessionId?: string): Promise<void> {
-    const url = targetSessionId ? `/session/logout/${sessionId}/${targetSessionId}` : `/session/logout/${sessionId}`;
+    const url = targetSessionId
+      ? `/session/logout/${sessionId}/${targetSessionId}`
+      : `/session/logout/${sessionId}`;
     await this.ctx.request('POST', url, undefined, { cache: false });
   }
 

package/src/api/store.ts

@@ -227,7 +227,6 @@ function queryOf<T extends object>(params: T): string {
   return rendered ? `?${rendered}` : '';
 }
 
-
 /** `oxy.store.reviews` — what people say about an app, and the caller's own review. */
 export class StoreReviewsApi {
   constructor(private readonly ctx: OxyContext) {}
@@ -245,9 +244,14 @@ export class StoreReviewsApi {
 
   /** The caller's own review of an app, or `null` if they have not written one. */
   async mine(slug: string): Promise<StoreOwnReview | null> {
-    const res = await this.ctx.request<{ data: StoreOwnReview | null }>('GET', reviewPath(slug), undefined, {
-      cache: false,
-    });
+    const res = await this.ctx.request<{ data: StoreOwnReview | null }>(
+      'GET',
+      reviewPath(slug),
+      undefined,
+      {
+        cache: false,
+      },
+    );
     return res.data ?? null;
   }
 
@@ -259,7 +263,9 @@ export class StoreReviewsApi {
    * hidden when its author edits it.
    */
   async write(slug: string, input: WriteStoreReviewInput): Promise<StoreOwnReview> {
-    const res = await this.ctx.request<{ data: StoreOwnReview }>('PUT', reviewPath(slug), input, { cache: false });
+    const res = await this.ctx.request<{ data: StoreOwnReview }>('PUT', reviewPath(slug), input, {
+      cache: false,
+    });
     return res.data;
   }
 
@@ -275,7 +281,9 @@ export class ListingScreenshotsApi {
 
   /** Every picture on the listing, in the author's order. */
   async list(applicationId: string): Promise<StoreScreenshot[]> {
-    return this.ctx.request<StoreScreenshot[]>('GET', screenshotsPath(applicationId), undefined, { cache: false });
+    return this.ctx.request<StoreScreenshot[]>('GET', screenshotsPath(applicationId), undefined, {
+      cache: false,
+    });
   }
 
   /**
@@ -286,11 +294,17 @@ export class ListingScreenshotsApi {
    * one the caller is entitled to.
    */
   async add(applicationId: string, input: AddScreenshotInput): Promise<StoreScreenshot> {
-    return this.ctx.request<StoreScreenshot>('POST', screenshotsPath(applicationId), input, { cache: false });
+    return this.ctx.request<StoreScreenshot>('POST', screenshotsPath(applicationId), input, {
+      cache: false,
+    });
   }
 
   /** Edit a picture's caption or the frame it was taken in. Order is `reorder`. */
-  async update(applicationId: string, screenshotId: string, input: UpdateScreenshotInput): Promise<StoreScreenshot> {
+  async update(
+    applicationId: string,
+    screenshotId: string,
+    input: UpdateScreenshotInput,
+  ): Promise<StoreScreenshot> {
     return this.ctx.request<StoreScreenshot>(
       'PATCH',
       `${screenshotsPath(applicationId)}/${enc(screenshotId)}`,
@@ -301,9 +315,14 @@ export class ListingScreenshotsApi {
 
   /** Remove a picture. The uploaded file stays — it may be in use elsewhere. */
   async delete(applicationId: string, screenshotId: string): Promise<void> {
-    await this.ctx.request<void>('DELETE', `${screenshotsPath(applicationId)}/${enc(screenshotId)}`, undefined, {
-      cache: false,
-    });
+    await this.ctx.request<void>(
+      'DELETE',
+      `${screenshotsPath(applicationId)}/${enc(screenshotId)}`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 
   /**
@@ -314,9 +333,14 @@ export class ListingScreenshotsApi {
    * pictures it omits at their old positions, interleaved with the new ones.
    */
   async reorder(applicationId: string, screenshotIds: string[]): Promise<StoreScreenshot[]> {
-    return this.ctx.request<StoreScreenshot[]>('PUT', `${screenshotsPath(applicationId)}/order`, { screenshotIds }, {
-      cache: false,
-    });
+    return this.ctx.request<StoreScreenshot[]>(
+      'PUT',
+      `${screenshotsPath(applicationId)}/order`,
+      { screenshotIds },
+      {
+        cache: false,
+      },
+    );
   }
 }
 
@@ -331,7 +355,9 @@ export class StoreListingApi {
 
   /** The application's store page in whatever state, or `null` if it has none. */
   async get(applicationId: string): Promise<PublisherListing | null> {
-    return this.ctx.request<PublisherListing | null>('GET', listingPath(applicationId), undefined, { cache: false });
+    return this.ctx.request<PublisherListing | null>('GET', listingPath(applicationId), undefined, {
+      cache: false,
+    });
   }
 
   /**
@@ -341,14 +367,21 @@ export class StoreListingApi {
    * it live, and fixing a rejected one does not re-submit it.
    */
   async write(applicationId: string, input: WriteListingInput): Promise<PublisherListing> {
-    return this.ctx.request<PublisherListing>('PUT', listingPath(applicationId), input, { cache: false });
+    return this.ctx.request<PublisherListing>('PUT', listingPath(applicationId), input, {
+      cache: false,
+    });
   }
 
   /** Hand the page to the store for review. From a draft, or a rejected page once fixed. */
   async submit(applicationId: string): Promise<PublisherListing> {
-    return this.ctx.request<PublisherListing>('POST', `${listingPath(applicationId)}/submit`, undefined, {
-      cache: false,
-    });
+    return this.ctx.request<PublisherListing>(
+      'POST',
+      `${listingPath(applicationId)}/submit`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 
   /**
@@ -359,9 +392,14 @@ export class StoreListingApi {
    * them.
    */
   async unpublish(applicationId: string): Promise<PublisherListing> {
-    return this.ctx.request<PublisherListing>('POST', `${listingPath(applicationId)}/unpublish`, undefined, {
-      cache: false,
-    });
+    return this.ctx.request<PublisherListing>(
+      'POST',
+      `${listingPath(applicationId)}/unpublish`,
+      undefined,
+      {
+        cache: false,
+      },
+    );
   }
 }
 
@@ -380,10 +418,15 @@ export class StoreApi {
 
   /** The shelves, in the order the store curates them. */
   async categories(): Promise<StoreCategory[]> {
-    const res = await this.ctx.request<{ data: StoreCategory[] }>('GET', '/store/categories', undefined, {
-      cache: true,
-      cacheTTL: MEDIUM_TTL,
-    });
+    const res = await this.ctx.request<{ data: StoreCategory[] }>(
+      'GET',
+      '/store/categories',
+      undefined,
+      {
+        cache: true,
+        cacheTTL: MEDIUM_TTL,
+      },
+    );
     return res.data ?? [];
   }
 
@@ -395,7 +438,9 @@ export class StoreApi {
    *
    * @param options - `category` is a category slug; `limit` defaults to 24.
    */
-  async apps(options: StorePageOptions & { category?: string } = {}): Promise<StorePage<StoreListingSummary>> {
+  async apps(
+    options: StorePageOptions & { category?: string } = {},
+  ): Promise<StorePage<StoreListingSummary>> {
     const res = await this.ctx.request<PaginatedResponse<StoreListingSummary>>(
       'GET',
       `/store/apps${queryOf(options)}`,
@@ -414,10 +459,15 @@ export class StoreApi {
    * @param slug - The listing's public slug, not an application id.
    */
   async app(slug: string): Promise<StoreListingDetail> {
-    const res = await this.ctx.request<{ data: StoreListingDetail }>('GET', `/store/apps/${enc(slug)}`, undefined, {
-      cache: true,
-      cacheTTL: SHORT_TTL,
-    });
+    const res = await this.ctx.request<{ data: StoreListingDetail }>(
+      'GET',
+      `/store/apps/${enc(slug)}`,
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SHORT_TTL,
+      },
+    );
     return res.data;
   }
 }

package/src/api/topics.ts

@@ -43,13 +43,18 @@ export class TopicsApi {
   async search(query: string, limit?: number): Promise<TopicData[]> {
     const params: Record<string, string | number> = { q: query };
     if (limit) params.limit = limit;
-    const res = await this.ctx.request<{ topics?: TopicData[] }>('GET', '/topics/search', params, { cache: false });
+    const res = await this.ctx.request<{ topics?: TopicData[] }>('GET', '/topics/search', params, {
+      cache: false,
+    });
     return res.topics ?? [];
   }
 
   /** One topic by slug. */
   async get(slug: string): Promise<TopicData> {
-    return this.ctx.request<TopicData>('GET', `/topics/${slug}`, undefined, { cache: true, cacheTTL: LONG });
+    return this.ctx.request<TopicData>('GET', `/topics/${slug}`, undefined, {
+      cache: true,
+      cacheTTL: LONG,
+    });
   }
 
   /** The top-level categories, optionally translated. */
@@ -65,9 +70,14 @@ export class TopicsApi {
 
   /** Resolve names to topics, creating the missing ones. Staff or service only. */
   async resolveNames(names: Array<{ name: string; type: string }>): Promise<TopicData[]> {
-    const res = await this.ctx.request<{ topics?: Record<string, TopicData> }>('POST', '/topics/resolve', { names }, {
-      cache: false,
-    });
+    const res = await this.ctx.request<{ topics?: Record<string, TopicData> }>(
+      'POST',
+      '/topics/resolve',
+      { names },
+      {
+        cache: false,
+      },
+    );
     return Object.values(res.topics ?? {});
   }
 
@@ -76,7 +86,9 @@ export class TopicsApi {
     slug: string,
     data: { description?: string; translations?: Record<string, TopicTranslation> },
   ): Promise<TopicData> {
-    const topic = await this.ctx.request<TopicData>('PATCH', `/topics/${slug}`, data, { cache: false });
+    const topic = await this.ctx.request<TopicData>('PATCH', `/topics/${slug}`, data, {
+      cache: false,
+    });
     this.ctx.oxy.cache.delete(`GET:/topics/${slug}`);
     return topic;
   }

package/src/api/users.ts

@@ -103,7 +103,12 @@ export class UsersApi {
         try {
           const users = service
             ? await service.request<User[]>('POST', '/users/by-ids', { ids: chunk })
-            : await this.ctx.request<User[]>('POST', '/users/by-ids', { ids: chunk }, { cache: false });
+            : await this.ctx.request<User[]>(
+                'POST',
+                '/users/by-ids',
+                { ids: chunk },
+                { cache: false },
+              );
           return Array.isArray(users) ? users.map((user) => normalizeUserIdentity(user)) : [];
         } catch (error: unknown) {
           logger.warn('users.getMany: chunk failed, continuing with remaining chunks', {
@@ -121,27 +126,40 @@ export class UsersApi {
   }
 
   /** The signed-in user. Cached 1 minute. */
-  async me(options?: {cache?: boolean}): Promise<User> {
-    const user = await this.ctx.request<User>('GET', '/users/me', undefined, { cache: options?.cache ?? true, cacheTTL: ME_TTL });
+  async me(options?: { cache?: boolean }): Promise<User> {
+    const user = await this.ctx.request<User>('GET', '/users/me', undefined, {
+      cache: options?.cache ?? true,
+      cacheTTL: ME_TTL,
+    });
     return normalizeUserIdentity(user);
   }
 
   /** A profile by username. Cached 5 minutes; `{ cache: false }` as in `get`. */
   async byUsername(username: string, options?: { cache?: boolean }): Promise<User> {
-    const user = await this.ctx.request<User>('GET', `/profiles/username/${encodeURIComponent(username)}`, undefined, {
-      cache: options?.cache ?? true,
-      cacheTTL: PROFILE_TTL,
-    });
+    const user = await this.ctx.request<User>(
+      'GET',
+      `/profiles/username/${encodeURIComponent(username)}`,
+      undefined,
+      {
+        cache: options?.cache ?? true,
+        cacheTTL: PROFILE_TTL,
+      },
+    );
     return normalizeUserIdentity(user);
   }
 
   /** The user owning a public key. Public (pre-session): sends no bearer. */
   async byPublicKey(publicKey: string): Promise<User> {
-    const user = await this.ctx.request<User>('GET', `/auth/user/${encodeURIComponent(publicKey)}`, undefined, {
-      cache: true,
-      cacheTTL: SESSION_USER_TTL,
-      skipAuth: true,
-    });
+    const user = await this.ctx.request<User>(
+      'GET',
+      `/auth/user/${encodeURIComponent(publicKey)}`,
+      undefined,
+      {
+        cache: true,
+        cacheTTL: SESSION_USER_TTL,
+        skipAuth: true,
+      },
+    );
     return normalizeUserIdentity(user);
   }
 
@@ -205,22 +223,32 @@ export class UsersApi {
    */
   async resolveHandle(handle: string): Promise<User | null> {
     try {
-      const result = await this.ctx.request<User | null>('GET', '/profiles/resolve', { handle }, {
-        cache: true,
-        cacheTTL: PROFILE_TTL,
-      });
+      const result = await this.ctx.request<User | null>(
+        'GET',
+        '/profiles/resolve',
+        { handle },
+        {
+          cache: true,
+          cacheTTL: PROFILE_TTL,
+        },
+      );
       return normalizeUserIdentityOrNull(result);
     } catch (error: unknown) {
       // A 404 (absent) and an upstream failure both return null; the log keeps
       // them distinguishable without turning expected misses into noise.
       const status = extractErrorStatus(error);
-      logger.debug(status === 404 ? 'users.resolveHandle: handle not found' : 'users.resolveHandle: discovery failed', {
-        method: 'users.resolveHandle',
-        handle,
-        status,
-        notFound: status === 404,
-        error: error instanceof Error ? error.message : String(error),
-      });
+      logger.debug(
+        status === 404
+          ? 'users.resolveHandle: handle not found'
+          : 'users.resolveHandle: discovery failed',
+        {
+          method: 'users.resolveHandle',
+          handle,
+          status,
+          notFound: status === 404,
+          error: error instanceof Error ? error.message : String(error),
+        },
+      );
       return null;
     }
   }
@@ -236,11 +264,19 @@ export class UsersApi {
 
   /** Profiles similar to `userId`, by co-follower overlap. Cached 5 minutes. */
   async similar(userId: string, limitOrPagination?: number | PaginationParams): Promise<User[]> {
-    const pagination = typeof limitOrPagination === 'number' ? { limit: limitOrPagination } : limitOrPagination ?? {};
-    const users = await this.ctx.request<User[]>('GET', `/profiles/${userId}/similar`, buildQueryParams(pagination), {
-      cache: true,
-      cacheTTL: PROFILE_TTL,
-    });
+    const pagination =
+      typeof limitOrPagination === 'number'
+        ? { limit: limitOrPagination }
+        : (limitOrPagination ?? {});
+    const users = await this.ctx.request<User[]>(
+      'GET',
+      `/profiles/${userId}/similar`,
+      buildQueryParams(pagination),
+      {
+        cache: true,
+        cacheTTL: PROFILE_TTL,
+      },
+    );
     return users.map((user) => normalizeUserIdentity(user));
   }
 
@@ -266,7 +302,12 @@ export class UsersApi {
     try {
       if (scored && options) {
         const body = recommendationRequestSchema.parse(options);
-        return await this.ctx.request<RecommendationItem[]>('POST', '/profiles/recommendations', body, { cache: true });
+        return await this.ctx.request<RecommendationItem[]>(
+          'POST',
+          '/profiles/recommendations',
+          body,
+          { cache: true },
+        );
       }
       const params: Record<string, string> = {};
       if (options?.excludeTypes?.length) params.excludeTypes = options.excludeTypes.join(',');
@@ -306,7 +347,9 @@ export class UsersApi {
   async updateMe(updates: UserProfileUpdate): Promise<User> {
     let result: User;
     try {
-      result = normalizeUserIdentity(await this.ctx.request<User>('PUT', '/users/me', updates, { cache: false }));
+      result = normalizeUserIdentity(
+        await this.ctx.request<User>('PUT', '/users/me', updates, { cache: false }),
+      );
     } catch (error) {
       if (extractErrorStatus(error) === 401 && !this.ctx.oxy.session.isAuthenticated) {
         throw new Error('AUTH_REQUIRED_OFFLINE_SESSION: Session needs to be synced to get a token');
@@ -325,8 +368,16 @@ export class UsersApi {
   }
 
   /** Ask for the verified badge. */
-  async requestVerification(reason: string, evidence?: string): Promise<{ message: string; requestId: string }> {
-    return this.ctx.request('POST', '/users/verify/request', { reason, evidence }, { cache: false });
+  async requestVerification(
+    reason: string,
+    evidence?: string,
+  ): Promise<{ message: string; requestId: string }> {
+    return this.ctx.request(
+      'POST',
+      '/users/verify/request',
+      { reason, evidence },
+      { cache: false },
+    );
   }
 
   /**
@@ -335,7 +386,12 @@ export class UsersApi {
    */
   async deleteMe(confirmText: string, proof: DeleteAccountProof): Promise<{ message: string }> {
     if ('reauth' in proof) {
-      return this.ctx.request('DELETE', '/users/me', { confirmText, reauth: proof.reauth }, { cache: false });
+      return this.ctx.request(
+        'DELETE',
+        '/users/me',
+        { confirmText, reauth: proof.reauth },
+        { cache: false },
+      );
     }
 
     // Loaded on demand: only a Commons account deleting from its own device
@@ -343,14 +399,21 @@ export class UsersApi {
     const { KeyManager, SignatureService } = await import('../crypto/internal');
     const publicKey = await KeyManager.getPublicKey();
     if (!publicKey) {
-      throw new Error('No identity found on this device. Account deletion requires the device that holds your identity key.');
+      throw new Error(
+        'No identity found on this device. Account deletion requires the device that holds your identity key.',
+      );
     }
     const timestamp = Date.now();
     const signature = await SignatureService.sign(`delete:${publicKey}:${timestamp}`);
     return this.ctx.request(
       'DELETE',
       '/users/me',
-      { signature, timestamp, confirmText, ...(proof.totpCode ? { totpCode: proof.totpCode } : {}) },
+      {
+        signature,
+        timestamp,
+        confirmText,
+        ...(proof.totpCode ? { totpCode: proof.totpCode } : {}),
+      },
       { cache: false },
     );
   }