chore: run formatter

analysis_options.yaml

···
   errors:
     invalid_annotation_target: ignore
 
+formatter:
+  page_width: 99
+
 linter:
   rules:
     - prefer_single_quotes

lib/src/app/providers.g.dart

···
 @ProviderFor(appDatabase)
 final appDatabaseProvider = AppDatabaseProvider._();
 
-final class AppDatabaseProvider
-    extends $FunctionalProvider<AppDatabase, AppDatabase, AppDatabase>
+final class AppDatabaseProvider extends $FunctionalProvider<AppDatabase, AppDatabase, AppDatabase>
     with $Provider<AppDatabase> {
   AppDatabaseProvider._()
     : super(
···
 
 /// Provides the app's [GoRouter] instance.
 
-final class GoRouterProvider
-    extends $FunctionalProvider<GoRouter, GoRouter, GoRouter>
+final class GoRouterProvider extends $FunctionalProvider<GoRouter, GoRouter, GoRouter>
     with $Provider<GoRouter> {
   /// Provides the app's [GoRouter] instance.
   GoRouterProvider._()
···
 
   @$internal
   @override
-  $ProviderElement<GoRouter> $createElement($ProviderPointer pointer) =>
-      $ProviderElement(pointer);
+  $ProviderElement<GoRouter> $createElement($ProviderPointer pointer) => $ProviderElement(pointer);
 
   @override
   GoRouter create(Ref ref) {
···
 
   /// {@macro riverpod.override_with_value}
   Override overrideWithValue(GoRouter value) {
-    return $ProviderOverride(
-      origin: this,
-      providerOverride: $SyncValueProvider<GoRouter>(value),
-    );
+    return $ProviderOverride(origin: this, providerOverride: $SyncValueProvider<GoRouter>(value));
   }
 }
 

lib/src/features/auth/application/auth_providers.g.dart

···
 final secureStorageProvider = SecureStorageProvider._();
 
 final class SecureStorageProvider
-    extends
-        $FunctionalProvider<
-          FlutterSecureStorage,
-          FlutterSecureStorage,
-          FlutterSecureStorage
-        >
+    extends $FunctionalProvider<FlutterSecureStorage, FlutterSecureStorage, FlutterSecureStorage>
     with $Provider<FlutterSecureStorage> {
   SecureStorageProvider._()
     : super(
···
 
   @$internal
   @override
-  $ProviderElement<FlutterSecureStorage> $createElement(
-    $ProviderPointer pointer,
-  ) => $ProviderElement(pointer);
+  $ProviderElement<FlutterSecureStorage> $createElement($ProviderPointer pointer) =>
+      $ProviderElement(pointer);
 
   @override
   FlutterSecureStorage create(Ref ref) {
···
 final identityRepositoryProvider = IdentityRepositoryProvider._();
 
 final class IdentityRepositoryProvider
-    extends
-        $FunctionalProvider<
-          IdentityRepository,
-          IdentityRepository,
-          IdentityRepository
-        >
+    extends $FunctionalProvider<IdentityRepository, IdentityRepository, IdentityRepository>
     with $Provider<IdentityRepository> {
   IdentityRepositoryProvider._()
     : super(
···
 
   @$internal
   @override
-  $ProviderElement<IdentityRepository> $createElement(
-    $ProviderPointer pointer,
-  ) => $ProviderElement(pointer);
+  $ProviderElement<IdentityRepository> $createElement($ProviderPointer pointer) =>
+      $ProviderElement(pointer);
 
   @override
   IdentityRepository create(Ref ref) {
···
   }
 }
 
-String _$identityRepositoryHash() =>
-    r'38ca9e5b495eecbd5c25af2f3968a92b89f90c30';
+String _$identityRepositoryHash() => r'38ca9e5b495eecbd5c25af2f3968a92b89f90c30';
 
 @ProviderFor(oauthClient)
 final oauthClientProvider = OauthClientProvider._();
 
-final class OauthClientProvider
-    extends $FunctionalProvider<OAuthClient, OAuthClient, OAuthClient>
+final class OauthClientProvider extends $FunctionalProvider<OAuthClient, OAuthClient, OAuthClient>
     with $Provider<OAuthClient> {
   OauthClientProvider._()
     : super(
···
 
   @$internal
   @override
-  $ProviderElement<ServerMetadataRepository> $createElement(
-    $ProviderPointer pointer,
-  ) => $ProviderElement(pointer);
+  $ProviderElement<ServerMetadataRepository> $createElement($ProviderPointer pointer) =>
+      $ProviderElement(pointer);
 
   @override
   ServerMetadataRepository create(Ref ref) {
···
   }
 }
 
-String _$serverMetadataRepositoryHash() =>
-    r'8a4213bf3952ed89db571088d94fa6998211f96e';
+String _$serverMetadataRepositoryHash() => r'8a4213bf3952ed89db571088d94fa6998211f96e';
 
 @ProviderFor(authRepository)
 final authRepositoryProvider = AuthRepositoryProvider._();
···
 @ProviderFor(AuthNotifier)
 final authProvider = AuthNotifierProvider._();
 
-final class AuthNotifierProvider
-    extends $NotifierProvider<AuthNotifier, AuthState> {
+final class AuthNotifierProvider extends $NotifierProvider<AuthNotifier, AuthState> {
   AuthNotifierProvider._()
     : super(
         from: null,
···
 
   /// {@macro riverpod.override_with_value}
   Override overrideWithValue(AuthState value) {
-    return $ProviderOverride(
-      origin: this,
-      providerOverride: $SyncValueProvider<AuthState>(value),
-    );
+    return $ProviderOverride(origin: this, providerOverride: $SyncValueProvider<AuthState>(value));
   }
 }
 

lib/src/features/dms/presentation/dms_screen.dart

···
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-            Icon(
-              Icons.mail_outlined,
-              size: 64,
-              color: theme.colorScheme.primary,
-            ),
+            Icon(Icons.mail_outlined, size: 64, color: theme.colorScheme.primary),
             const SizedBox(height: 16),
             Text('Direct Messages', style: theme.textTheme.headlineSmall),
             const SizedBox(height: 8),

lib/src/features/notifications/presentation/notifications_screen.dart

···
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-            Icon(
-              Icons.notifications_outlined,
-              size: 64,
-              color: theme.colorScheme.primary,
-            ),
+            Icon(Icons.notifications_outlined, size: 64, color: theme.colorScheme.primary),
             const SizedBox(height: 16),
             Text('Notifications', style: theme.textTheme.headlineSmall),
             const SizedBox(height: 8),

lib/src/features/profile/presentation/profile_screen.dart

···
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-            Icon(
-              Icons.person_outlined,
-              size: 64,
-              color: theme.colorScheme.primary,
-            ),
+            Icon(Icons.person_outlined, size: 64, color: theme.colorScheme.primary),
             const SizedBox(height: 16),
             Text('Your Profile', style: theme.textTheme.headlineSmall),
             const SizedBox(height: 8),

lib/src/features/search/presentation/search_screen.dart

···
         child: Column(
           mainAxisAlignment: MainAxisAlignment.center,
           children: [
-            Icon(
-              Icons.search_outlined,
-              size: 64,
-              color: theme.colorScheme.primary,
-            ),
+            Icon(Icons.search_outlined, size: 64, color: theme.colorScheme.primary),
             const SizedBox(height: 16),
             Text('Search', style: theme.textTheme.headlineSmall),
             const SizedBox(height: 8),

lib/src/features/thread/application/thread_notifier.g.dart

···
 @ProviderFor(ThreadNotifier)
 final threadProvider = ThreadNotifierFamily._();
 
-final class ThreadNotifierProvider
-    extends $AsyncNotifierProvider<ThreadNotifier, ThreadViewPost> {
+final class ThreadNotifierProvider extends $AsyncNotifierProvider<ThreadNotifier, ThreadViewPost> {
   ThreadNotifierProvider._({
     required ThreadNotifierFamily super.from,
     required String super.argument,

lib/src/features/thread/application/thread_providers.g.dart

···
 final threadRepositoryProvider = ThreadRepositoryProvider._();
 
 final class ThreadRepositoryProvider
-    extends
-        $FunctionalProvider<
-          ThreadRepository,
-          ThreadRepository,
-          ThreadRepository
-        >
+    extends $FunctionalProvider<ThreadRepository, ThreadRepository, ThreadRepository>
     with $Provider<ThreadRepository> {
   ThreadRepositoryProvider._()
     : super(

lib/src/features/timeline/application/timeline_notifier.g.dart

···
 
 String _$timelineNotifierHash() => r'b218d4a4bc374d2a1bf64542694cf6ba26611206';
 
-abstract class _$TimelineNotifier
-    extends $StreamNotifier<List<TimelineFeedItem>> {
+abstract class _$TimelineNotifier extends $StreamNotifier<List<TimelineFeedItem>> {
   Stream<List<TimelineFeedItem>> build();
   @$mustCallSuper
   @override
   void runBuild() {
-    final ref =
-        this.ref
-            as $Ref<AsyncValue<List<TimelineFeedItem>>, List<TimelineFeedItem>>;
+    final ref = this.ref as $Ref<AsyncValue<List<TimelineFeedItem>>, List<TimelineFeedItem>>;
     final element =
         ref.element
             as $ClassProviderElement<
-              AnyNotifier<
-                AsyncValue<List<TimelineFeedItem>>,
-                List<TimelineFeedItem>
-              >,
+              AnyNotifier<AsyncValue<List<TimelineFeedItem>>, List<TimelineFeedItem>>,
               AsyncValue<List<TimelineFeedItem>>,
               Object?,
               Object?

lib/src/features/timeline/application/timeline_providers.g.dart

···
 final timelineRepositoryProvider = TimelineRepositoryProvider._();
 
 final class TimelineRepositoryProvider
-    extends
-        $FunctionalProvider<
-          TimelineRepository,
-          TimelineRepository,
-          TimelineRepository
-        >
+    extends $FunctionalProvider<TimelineRepository, TimelineRepository, TimelineRepository>
     with $Provider<TimelineRepository> {
   TimelineRepositoryProvider._()
     : super(
···
 
   @$internal
   @override
-  $ProviderElement<TimelineRepository> $createElement(
-    $ProviderPointer pointer,
-  ) => $ProviderElement(pointer);
+  $ProviderElement<TimelineRepository> $createElement($ProviderPointer pointer) =>
+      $ProviderElement(pointer);
 
   @override
   TimelineRepository create(Ref ref) {
···
   }
 }
 
-String _$timelineRepositoryHash() =>
-    r'8d3030173e5f8b599de955cf3b0d4c6da8cfe88d';
+String _$timelineRepositoryHash() => r'8d3030173e5f8b599de955cf3b0d4c6da8cfe88d';

lib/src/infrastructure/db/app_database.g.dart

···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
-  static const VerificationMeta _authorDidMeta = const VerificationMeta(
-    'authorDid',
-  );
+  static const VerificationMeta _authorDidMeta = const VerificationMeta('authorDid');
   @override
   late final GeneratedColumn<String> authorDid = GeneratedColumn<String>(
     'author_did',
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
-  static const VerificationMeta _indexedAtMeta = const VerificationMeta(
-    'indexedAt',
-  );
+  static const VerificationMeta _indexedAtMeta = const VerificationMeta('indexedAt');
   @override
   late final GeneratedColumn<DateTime> indexedAt = GeneratedColumn<DateTime>(
     'indexed_at',
···
     type: DriftSqlType.dateTime,
     requiredDuringInsert: false,
   );
-  static const VerificationMeta _replyCountMeta = const VerificationMeta(
-    'replyCount',
-  );
+  static const VerificationMeta _replyCountMeta = const VerificationMeta('replyCount');
   @override
   late final GeneratedColumn<int> replyCount = GeneratedColumn<int>(
     'reply_count',
···
     requiredDuringInsert: false,
     defaultValue: const Constant(0),
   );
-  static const VerificationMeta _repostCountMeta = const VerificationMeta(
-    'repostCount',
-  );
+  static const VerificationMeta _repostCountMeta = const VerificationMeta('repostCount');
   @override
   late final GeneratedColumn<int> repostCount = GeneratedColumn<int>(
     'repost_count',
···
     requiredDuringInsert: false,
     defaultValue: const Constant(0),
   );
-  static const VerificationMeta _likeCountMeta = const VerificationMeta(
-    'likeCount',
-  );
+  static const VerificationMeta _likeCountMeta = const VerificationMeta('likeCount');
   @override
   late final GeneratedColumn<int> likeCount = GeneratedColumn<int>(
     'like_count',
···
   String get actualTableName => $name;
   static const String $name = 'posts';
   @override
-  VerificationContext validateIntegrity(
-    Insertable<Post> instance, {
-    bool isInserting = false,
-  }) {
+  VerificationContext validateIntegrity(Insertable<Post> instance, {bool isInserting = false}) {
     final context = VerificationContext();
     final data = instance.toColumns(true);
     if (data.containsKey('uri')) {
-      context.handle(
-        _uriMeta,
-        uri.isAcceptableOrUnknown(data['uri']!, _uriMeta),
-      );
+      context.handle(_uriMeta, uri.isAcceptableOrUnknown(data['uri']!, _uriMeta));
     } else if (isInserting) {
       context.missing(_uriMeta);
     }
     if (data.containsKey('cid')) {
-      context.handle(
-        _cidMeta,
-        cid.isAcceptableOrUnknown(data['cid']!, _cidMeta),
-      );
+      context.handle(_cidMeta, cid.isAcceptableOrUnknown(data['cid']!, _cidMeta));
     } else if (isInserting) {
       context.missing(_cidMeta);
     }
···
       context.missing(_authorDidMeta);
     }
     if (data.containsKey('record')) {
-      context.handle(
-        _recordMeta,
-        record.isAcceptableOrUnknown(data['record']!, _recordMeta),
-      );
+      context.handle(_recordMeta, record.isAcceptableOrUnknown(data['record']!, _recordMeta));
     } else if (isInserting) {
       context.missing(_recordMeta);
     }
···
     if (data.containsKey('repost_count')) {
       context.handle(
         _repostCountMeta,
-        repostCount.isAcceptableOrUnknown(
-          data['repost_count']!,
-          _repostCountMeta,
-        ),
+        repostCount.isAcceptableOrUnknown(data['repost_count']!, _repostCountMeta),
       );
     }
     if (data.containsKey('like_count')) {
···
   Post map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return Post(
-      uri: attachedDatabase.typeMapping.read(
-        DriftSqlType.string,
-        data['${effectivePrefix}uri'],
-      )!,
-      cid: attachedDatabase.typeMapping.read(
-        DriftSqlType.string,
-        data['${effectivePrefix}cid'],
-      )!,
+      uri: attachedDatabase.typeMapping.read(DriftSqlType.string, data['${effectivePrefix}uri'])!,
+      cid: attachedDatabase.typeMapping.read(DriftSqlType.string, data['${effectivePrefix}cid'])!,
       authorDid: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}author_did'],
···
       cid: Value(cid),
       authorDid: Value(authorDid),
       record: Value(record),
-      indexedAt: indexedAt == null && nullToAbsent
-          ? const Value.absent()
-          : Value(indexedAt),
+      indexedAt: indexedAt == null && nullToAbsent ? const Value.absent() : Value(indexedAt),
       replyCount: Value(replyCount),
       repostCount: Value(repostCount),
       likeCount: Value(likeCount),
     );
   }
 
-  factory Post.fromJson(
-    Map<String, dynamic> json, {
-    ValueSerializer? serializer,
-  }) {
+  factory Post.fromJson(Map<String, dynamic> json, {ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return Post(
       uri: serializer.fromJson<String>(json['uri']),
···
       authorDid: data.authorDid.present ? data.authorDid.value : this.authorDid,
       record: data.record.present ? data.record.value : this.record,
       indexedAt: data.indexedAt.present ? data.indexedAt.value : this.indexedAt,
-      replyCount: data.replyCount.present
-          ? data.replyCount.value
-          : this.replyCount,
-      repostCount: data.repostCount.present
-          ? data.repostCount.value
-          : this.repostCount,
+      replyCount: data.replyCount.present ? data.replyCount.value : this.replyCount,
+      repostCount: data.repostCount.present ? data.repostCount.value : this.repostCount,
       likeCount: data.likeCount.present ? data.likeCount.value : this.likeCount,
     );
   }
···
   }
 
   @override
-  int get hashCode => Object.hash(
-    uri,
-    cid,
-    authorDid,
-    record,
-    indexedAt,
-    replyCount,
-    repostCount,
-    likeCount,
-  );
+  int get hashCode =>
+      Object.hash(uri, cid, authorDid, record, indexedAt, replyCount, repostCount, likeCount);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
-  static const VerificationMeta _displayNameMeta = const VerificationMeta(
-    'displayName',
-  );
+  static const VerificationMeta _displayNameMeta = const VerificationMeta('displayName');
   @override
   late final GeneratedColumn<String> displayName = GeneratedColumn<String>(
     'display_name',
···
     type: DriftSqlType.string,
     requiredDuringInsert: false,
   );
-  static const VerificationMeta _descriptionMeta = const VerificationMeta(
-    'description',
-  );
+  static const VerificationMeta _descriptionMeta = const VerificationMeta('description');
   @override
   late final GeneratedColumn<String> description = GeneratedColumn<String>(
     'description',
···
     type: DriftSqlType.string,
     requiredDuringInsert: false,
   );
-  static const VerificationMeta _indexedAtMeta = const VerificationMeta(
-    'indexedAt',
-  );
+  static const VerificationMeta _indexedAtMeta = const VerificationMeta('indexedAt');
   @override
   late final GeneratedColumn<DateTime> indexedAt = GeneratedColumn<DateTime>(
     'indexed_at',
···
   String get actualTableName => $name;
   static const String $name = 'profiles';
   @override
-  VerificationContext validateIntegrity(
-    Insertable<Profile> instance, {
-    bool isInserting = false,
-  }) {
+  VerificationContext validateIntegrity(Insertable<Profile> instance, {bool isInserting = false}) {
     final context = VerificationContext();
     final data = instance.toColumns(true);
     if (data.containsKey('did')) {
-      context.handle(
-        _didMeta,
-        did.isAcceptableOrUnknown(data['did']!, _didMeta),
-      );
+      context.handle(_didMeta, did.isAcceptableOrUnknown(data['did']!, _didMeta));
     } else if (isInserting) {
       context.missing(_didMeta);
     }
     if (data.containsKey('handle')) {
-      context.handle(
-        _handleMeta,
-        handle.isAcceptableOrUnknown(data['handle']!, _handleMeta),
-      );
+      context.handle(_handleMeta, handle.isAcceptableOrUnknown(data['handle']!, _handleMeta));
     } else if (isInserting) {
       context.missing(_handleMeta);
     }
     if (data.containsKey('display_name')) {
       context.handle(
         _displayNameMeta,
-        displayName.isAcceptableOrUnknown(
-          data['display_name']!,
-          _displayNameMeta,
-        ),
+        displayName.isAcceptableOrUnknown(data['display_name']!, _displayNameMeta),
       );
     }
     if (data.containsKey('description')) {
       context.handle(
         _descriptionMeta,
-        description.isAcceptableOrUnknown(
-          data['description']!,
-          _descriptionMeta,
-        ),
+        description.isAcceptableOrUnknown(data['description']!, _descriptionMeta),
       );
     }
     if (data.containsKey('avatar')) {
-      context.handle(
-        _avatarMeta,
-        avatar.isAcceptableOrUnknown(data['avatar']!, _avatarMeta),
-      );
+      context.handle(_avatarMeta, avatar.isAcceptableOrUnknown(data['avatar']!, _avatarMeta));
     }
     if (data.containsKey('banner')) {
-      context.handle(
-        _bannerMeta,
-        banner.isAcceptableOrUnknown(data['banner']!, _bannerMeta),
-      );
+      context.handle(_bannerMeta, banner.isAcceptableOrUnknown(data['banner']!, _bannerMeta));
     }
     if (data.containsKey('indexed_at')) {
       context.handle(
···
   Profile map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return Profile(
-      did: attachedDatabase.typeMapping.read(
-        DriftSqlType.string,
-        data['${effectivePrefix}did'],
-      )!,
+      did: attachedDatabase.typeMapping.read(DriftSqlType.string, data['${effectivePrefix}did'])!,
       handle: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}handle'],
···
     return ProfilesCompanion(
       did: Value(did),
       handle: Value(handle),
-      displayName: displayName == null && nullToAbsent
-          ? const Value.absent()
-          : Value(displayName),
-      description: description == null && nullToAbsent
-          ? const Value.absent()
-          : Value(description),
-      avatar: avatar == null && nullToAbsent
-          ? const Value.absent()
-          : Value(avatar),
-      banner: banner == null && nullToAbsent
-          ? const Value.absent()
-          : Value(banner),
-      indexedAt: indexedAt == null && nullToAbsent
-          ? const Value.absent()
-          : Value(indexedAt),
+      displayName: displayName == null && nullToAbsent ? const Value.absent() : Value(displayName),
+      description: description == null && nullToAbsent ? const Value.absent() : Value(description),
+      avatar: avatar == null && nullToAbsent ? const Value.absent() : Value(avatar),
+      banner: banner == null && nullToAbsent ? const Value.absent() : Value(banner),
+      indexedAt: indexedAt == null && nullToAbsent ? const Value.absent() : Value(indexedAt),
     );
   }
 
-  factory Profile.fromJson(
-    Map<String, dynamic> json, {
-    ValueSerializer? serializer,
-  }) {
+  factory Profile.fromJson(Map<String, dynamic> json, {ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return Profile(
       did: serializer.fromJson<String>(json['did']),
···
     return Profile(
       did: data.did.present ? data.did.value : this.did,
       handle: data.handle.present ? data.handle.value : this.handle,
-      displayName: data.displayName.present
-          ? data.displayName.value
-          : this.displayName,
-      description: data.description.present
-          ? data.description.value
-          : this.description,
+      displayName: data.displayName.present ? data.displayName.value : this.displayName,
+      description: data.description.present ? data.description.value : this.description,
       avatar: data.avatar.present ? data.avatar.value : this.avatar,
       banner: data.banner.present ? data.banner.value : this.banner,
       indexedAt: data.indexedAt.present ? data.indexedAt.value : this.indexedAt,
···
   }
 
   @override
-  int get hashCode => Object.hash(
-    did,
-    handle,
-    displayName,
-    description,
-    avatar,
-    banner,
-    indexedAt,
-  );
+  int get hashCode =>
+      Object.hash(did, handle, displayName, description, avatar, banner, indexedAt);
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
···
   }
 }
 
-class $TimelineItemsTable extends TimelineItems
-    with TableInfo<$TimelineItemsTable, TimelineItem> {
+class $TimelineItemsTable extends TimelineItems with TableInfo<$TimelineItemsTable, TimelineItem> {
   @override
   final GeneratedDatabase attachedDatabase;
   final String? _alias;
   $TimelineItemsTable(this.attachedDatabase, [this._alias]);
-  static const VerificationMeta _feedKeyMeta = const VerificationMeta(
-    'feedKey',
-  );
+  static const VerificationMeta _feedKeyMeta = const VerificationMeta('feedKey');
   @override
   late final GeneratedColumn<String> feedKey = GeneratedColumn<String>(
     'feed_key',
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
-  static const VerificationMeta _postUriMeta = const VerificationMeta(
-    'postUri',
-  );
+  static const VerificationMeta _postUriMeta = const VerificationMeta('postUri');
   @override
   late final GeneratedColumn<String> postUri = GeneratedColumn<String>(
     'post_uri',
···
     false,
     type: DriftSqlType.string,
     requiredDuringInsert: true,
-    defaultConstraints: GeneratedColumn.constraintIsAlways(
-      'REFERENCES posts (uri)',
-    ),
+    defaultConstraints: GeneratedColumn.constraintIsAlways('REFERENCES posts (uri)'),
   );
   static const VerificationMeta _reasonMeta = const VerificationMeta('reason');
   @override
···
     type: DriftSqlType.string,
     requiredDuringInsert: false,
   );
-  static const VerificationMeta _sortKeyMeta = const VerificationMeta(
-    'sortKey',
-  );
+  static const VerificationMeta _sortKeyMeta = const VerificationMeta('sortKey');
   @override
   late final GeneratedColumn<String> sortKey = GeneratedColumn<String>(
     'sort_key',
···
     final context = VerificationContext();
     final data = instance.toColumns(true);
     if (data.containsKey('feed_key')) {
-      context.handle(
-        _feedKeyMeta,
-        feedKey.isAcceptableOrUnknown(data['feed_key']!, _feedKeyMeta),
-      );
+      context.handle(_feedKeyMeta, feedKey.isAcceptableOrUnknown(data['feed_key']!, _feedKeyMeta));
     } else if (isInserting) {
       context.missing(_feedKeyMeta);
     }
     if (data.containsKey('post_uri')) {
-      context.handle(
-        _postUriMeta,
-        postUri.isAcceptableOrUnknown(data['post_uri']!, _postUriMeta),
-      );
+      context.handle(_postUriMeta, postUri.isAcceptableOrUnknown(data['post_uri']!, _postUriMeta));
     } else if (isInserting) {
       context.missing(_postUriMeta);
     }
     if (data.containsKey('reason')) {
-      context.handle(
-        _reasonMeta,
-        reason.isAcceptableOrUnknown(data['reason']!, _reasonMeta),
-      );
+      context.handle(_reasonMeta, reason.isAcceptableOrUnknown(data['reason']!, _reasonMeta));
     }
     if (data.containsKey('sort_key')) {
-      context.handle(
-        _sortKeyMeta,
-        sortKey.isAcceptableOrUnknown(data['sort_key']!, _sortKeyMeta),
-      );
+      context.handle(_sortKeyMeta, sortKey.isAcceptableOrUnknown(data['sort_key']!, _sortKeyMeta));
     } else if (isInserting) {
       context.missing(_sortKeyMeta);
     }
···
     return TimelineItemsCompanion(
       feedKey: Value(feedKey),
       postUri: Value(postUri),
-      reason: reason == null && nullToAbsent
-          ? const Value.absent()
-          : Value(reason),
+      reason: reason == null && nullToAbsent ? const Value.absent() : Value(reason),
       sortKey: Value(sortKey),
     );
   }
 
-  factory TimelineItem.fromJson(
-    Map<String, dynamic> json, {
-    ValueSerializer? serializer,
-  }) {
+  factory TimelineItem.fromJson(Map<String, dynamic> json, {ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return TimelineItem(
       feedKey: serializer.fromJson<String>(json['feedKey']),
···
   String get actualTableName => $name;
   static const String $name = 'accounts';
   @override
-  VerificationContext validateIntegrity(
-    Insertable<Account> instance, {
-    bool isInserting = false,
-  }) {
+  VerificationContext validateIntegrity(Insertable<Account> instance, {bool isInserting = false}) {
     final context = VerificationContext();
     final data = instance.toColumns(true);
     if (data.containsKey('did')) {
-      context.handle(
-        _didMeta,
-        did.isAcceptableOrUnknown(data['did']!, _didMeta),
-      );
+      context.handle(_didMeta, did.isAcceptableOrUnknown(data['did']!, _didMeta));
     } else if (isInserting) {
       context.missing(_didMeta);
     }
     if (data.containsKey('handle')) {
-      context.handle(
-        _handleMeta,
-        handle.isAcceptableOrUnknown(data['handle']!, _handleMeta),
-      );
+      context.handle(_handleMeta, handle.isAcceptableOrUnknown(data['handle']!, _handleMeta));
     } else if (isInserting) {
       context.missing(_handleMeta);
     }
     if (data.containsKey('pds_url')) {
-      context.handle(
-        _pdsUrlMeta,
-        pdsUrl.isAcceptableOrUnknown(data['pds_url']!, _pdsUrlMeta),
-      );
+      context.handle(_pdsUrlMeta, pdsUrl.isAcceptableOrUnknown(data['pds_url']!, _pdsUrlMeta));
     } else if (isInserting) {
       context.missing(_pdsUrlMeta);
     }
···
   Account map(Map<String, dynamic> data, {String? tablePrefix}) {
     final effectivePrefix = tablePrefix != null ? '$tablePrefix.' : '';
     return Account(
-      did: attachedDatabase.typeMapping.read(
-        DriftSqlType.string,
-        data['${effectivePrefix}did'],
-      )!,
+      did: attachedDatabase.typeMapping.read(DriftSqlType.string, data['${effectivePrefix}did'])!,
       handle: attachedDatabase.typeMapping.read(
         DriftSqlType.string,
         data['${effectivePrefix}handle'],
···
   final String did;
   final String handle;
   final String pdsUrl;
-  const Account({
-    required this.did,
-    required this.handle,
-    required this.pdsUrl,
-  });
+  const Account({required this.did, required this.handle, required this.pdsUrl});
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
···
   }
 
   AccountsCompanion toCompanion(bool nullToAbsent) {
-    return AccountsCompanion(
-      did: Value(did),
-      handle: Value(handle),
-      pdsUrl: Value(pdsUrl),
-    );
+    return AccountsCompanion(did: Value(did), handle: Value(handle), pdsUrl: Value(pdsUrl));
   }
 
-  factory Account.fromJson(
-    Map<String, dynamic> json, {
-    ValueSerializer? serializer,
-  }) {
+  factory Account.fromJson(Map<String, dynamic> json, {ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return Account(
       did: serializer.fromJson<String>(json['did']),
···
     };
   }
 
-  Account copyWith({String? did, String? handle, String? pdsUrl}) => Account(
-    did: did ?? this.did,
-    handle: handle ?? this.handle,
-    pdsUrl: pdsUrl ?? this.pdsUrl,
-  );
+  Account copyWith({String? did, String? handle, String? pdsUrl}) =>
+      Account(did: did ?? this.did, handle: handle ?? this.handle, pdsUrl: pdsUrl ?? this.pdsUrl);
   Account copyWithCompanion(AccountsCompanion data) {
     return Account(
       did: data.did.present ? data.did.value : this.did,
···
   }
 }
 
-class $FeedCursorsTable extends FeedCursors
-    with TableInfo<$FeedCursorsTable, FeedCursor> {
+class $FeedCursorsTable extends FeedCursors with TableInfo<$FeedCursorsTable, FeedCursor> {
   @override
   final GeneratedDatabase attachedDatabase;
   final String? _alias;
   $FeedCursorsTable(this.attachedDatabase, [this._alias]);
-  static const VerificationMeta _feedKeyMeta = const VerificationMeta(
-    'feedKey',
-  );
+  static const VerificationMeta _feedKeyMeta = const VerificationMeta('feedKey');
   @override
   late final GeneratedColumn<String> feedKey = GeneratedColumn<String>(
     'feed_key',
···
     type: DriftSqlType.string,
     requiredDuringInsert: true,
   );
-  static const VerificationMeta _lastUpdatedMeta = const VerificationMeta(
-    'lastUpdated',
-  );
+  static const VerificationMeta _lastUpdatedMeta = const VerificationMeta('lastUpdated');
   @override
   late final GeneratedColumn<DateTime> lastUpdated = GeneratedColumn<DateTime>(
     'last_updated',
···
     final context = VerificationContext();
     final data = instance.toColumns(true);
     if (data.containsKey('feed_key')) {
-      context.handle(
-        _feedKeyMeta,
-        feedKey.isAcceptableOrUnknown(data['feed_key']!, _feedKeyMeta),
-      );
+      context.handle(_feedKeyMeta, feedKey.isAcceptableOrUnknown(data['feed_key']!, _feedKeyMeta));
     } else if (isInserting) {
       context.missing(_feedKeyMeta);
     }
     if (data.containsKey('cursor')) {
-      context.handle(
-        _cursorMeta,
-        cursor.isAcceptableOrUnknown(data['cursor']!, _cursorMeta),
-      );
+      context.handle(_cursorMeta, cursor.isAcceptableOrUnknown(data['cursor']!, _cursorMeta));
     } else if (isInserting) {
       context.missing(_cursorMeta);
     }
     if (data.containsKey('last_updated')) {
       context.handle(
         _lastUpdatedMeta,
-        lastUpdated.isAcceptableOrUnknown(
-          data['last_updated']!,
-          _lastUpdatedMeta,
-        ),
+        lastUpdated.isAcceptableOrUnknown(data['last_updated']!, _lastUpdatedMeta),
       );
     }
     return context;
···
   final String feedKey;
   final String cursor;
   final DateTime? lastUpdated;
-  const FeedCursor({
-    required this.feedKey,
-    required this.cursor,
-    this.lastUpdated,
-  });
+  const FeedCursor({required this.feedKey, required this.cursor, this.lastUpdated});
   @override
   Map<String, Expression> toColumns(bool nullToAbsent) {
     final map = <String, Expression>{};
···
     return FeedCursorsCompanion(
       feedKey: Value(feedKey),
       cursor: Value(cursor),
-      lastUpdated: lastUpdated == null && nullToAbsent
-          ? const Value.absent()
-          : Value(lastUpdated),
+      lastUpdated: lastUpdated == null && nullToAbsent ? const Value.absent() : Value(lastUpdated),
     );
   }
 
-  factory FeedCursor.fromJson(
-    Map<String, dynamic> json, {
-    ValueSerializer? serializer,
-  }) {
+  factory FeedCursor.fromJson(Map<String, dynamic> json, {ValueSerializer? serializer}) {
     serializer ??= driftRuntimeOptions.defaultSerializer;
     return FeedCursor(
       feedKey: serializer.fromJson<String>(json['feedKey']),
···
     return FeedCursor(
       feedKey: data.feedKey.present ? data.feedKey.value : this.feedKey,
       cursor: data.cursor.present ? data.cursor.value : this.cursor,
-      lastUpdated: data.lastUpdated.present
-          ? data.lastUpdated.value
-          : this.lastUpdated,
+      lastUpdated: data.lastUpdated.present ? data.lastUpdated.value : this.lastUpdated,
     );
   }
 
···
       Value<int> rowid,
     });
 
-final class $$PostsTableReferences
-    extends BaseReferences<_$AppDatabase, $PostsTable, Post> {
+final class $$PostsTableReferences extends BaseReferences<_$AppDatabase, $PostsTable, Post> {
   $$PostsTableReferences(super.$_db, super.$_table, super.$_typedResult);
 
-  static MultiTypedResultKey<$TimelineItemsTable, List<TimelineItem>>
-  _timelineItemsRefsTable(_$AppDatabase db) => MultiTypedResultKey.fromTable(
+  static MultiTypedResultKey<$TimelineItemsTable, List<TimelineItem>> _timelineItemsRefsTable(
+    _$AppDatabase db,
+  ) => MultiTypedResultKey.fromTable(
     db.timelineItems,
     aliasName: $_aliasNameGenerator(db.posts.uri, db.timelineItems.postUri),
   );
···
     ).filter((f) => f.postUri.uri.sqlEquals($_itemColumn<String>('uri')!));
 
     final cache = $_typedResult.readTableOrNull(_timelineItemsRefsTable($_db));
-    return ProcessedTableManager(
-      manager.$state.copyWith(prefetchedData: cache),
-    );
+    return ProcessedTableManager(manager.$state.copyWith(prefetchedData: cache));
   }
 }
 
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnFilters<String> get uri => $composableBuilder(
-    column: $table.uri,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get uri =>
+      $composableBuilder(column: $table.uri, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get cid => $composableBuilder(
-    column: $table.cid,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get cid =>
+      $composableBuilder(column: $table.cid, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get authorDid => $composableBuilder(
-    column: $table.authorDid,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get authorDid =>
+      $composableBuilder(column: $table.authorDid, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get record => $composableBuilder(
-    column: $table.record,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get record =>
+      $composableBuilder(column: $table.record, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<DateTime> get indexedAt => $composableBuilder(
-    column: $table.indexedAt,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<DateTime> get indexedAt =>
+      $composableBuilder(column: $table.indexedAt, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<int> get replyCount => $composableBuilder(
-    column: $table.replyCount,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<int> get replyCount =>
+      $composableBuilder(column: $table.replyCount, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<int> get repostCount => $composableBuilder(
-    column: $table.repostCount,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<int> get repostCount =>
+      $composableBuilder(column: $table.repostCount, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<int> get likeCount => $composableBuilder(
-    column: $table.likeCount,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<int> get likeCount =>
+      $composableBuilder(column: $table.likeCount, builder: (column) => ColumnFilters(column));
 
   Expression<bool> timelineItemsRefs(
     Expression<bool> Function($$TimelineItemsTableFilterComposer f) f,
···
       referencedTable: $db.timelineItems,
       getReferencedColumn: (t) => t.postUri,
       builder:
-          (
-            joinBuilder, {
-            $addJoinBuilderToRootComposer,
-            $removeJoinBuilderFromRootComposer,
-          }) => $$TimelineItemsTableFilterComposer(
-            $db: $db,
-            $table: $db.timelineItems,
-            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
-            joinBuilder: joinBuilder,
-            $removeJoinBuilderFromRootComposer:
-                $removeJoinBuilderFromRootComposer,
-          ),
+          (joinBuilder, {$addJoinBuilderToRootComposer, $removeJoinBuilderFromRootComposer}) =>
+              $$TimelineItemsTableFilterComposer(
+                $db: $db,
+                $table: $db.timelineItems,
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer: $removeJoinBuilderFromRootComposer,
+              ),
     );
     return f(composer);
   }
 }
 
-class $$PostsTableOrderingComposer
-    extends Composer<_$AppDatabase, $PostsTable> {
+class $$PostsTableOrderingComposer extends Composer<_$AppDatabase, $PostsTable> {
   $$PostsTableOrderingComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnOrderings<String> get uri => $composableBuilder(
-    column: $table.uri,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get uri =>
+      $composableBuilder(column: $table.uri, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get cid => $composableBuilder(
-    column: $table.cid,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get cid =>
+      $composableBuilder(column: $table.cid, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get authorDid => $composableBuilder(
-    column: $table.authorDid,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get authorDid =>
+      $composableBuilder(column: $table.authorDid, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get record => $composableBuilder(
-    column: $table.record,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get record =>
+      $composableBuilder(column: $table.record, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<DateTime> get indexedAt => $composableBuilder(
-    column: $table.indexedAt,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<DateTime> get indexedAt =>
+      $composableBuilder(column: $table.indexedAt, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<int> get replyCount => $composableBuilder(
-    column: $table.replyCount,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<int> get replyCount =>
+      $composableBuilder(column: $table.replyCount, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<int> get repostCount => $composableBuilder(
-    column: $table.repostCount,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<int> get repostCount =>
+      $composableBuilder(column: $table.repostCount, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<int> get likeCount => $composableBuilder(
-    column: $table.likeCount,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<int> get likeCount =>
+      $composableBuilder(column: $table.likeCount, builder: (column) => ColumnOrderings(column));
 }
 
-class $$PostsTableAnnotationComposer
-    extends Composer<_$AppDatabase, $PostsTable> {
+class $$PostsTableAnnotationComposer extends Composer<_$AppDatabase, $PostsTable> {
   $$PostsTableAnnotationComposer({
     required super.$db,
     required super.$table,
···
   GeneratedColumn<DateTime> get indexedAt =>
       $composableBuilder(column: $table.indexedAt, builder: (column) => column);
 
-  GeneratedColumn<int> get replyCount => $composableBuilder(
-    column: $table.replyCount,
-    builder: (column) => column,
-  );
+  GeneratedColumn<int> get replyCount =>
+      $composableBuilder(column: $table.replyCount, builder: (column) => column);
 
-  GeneratedColumn<int> get repostCount => $composableBuilder(
-    column: $table.repostCount,
-    builder: (column) => column,
-  );
+  GeneratedColumn<int> get repostCount =>
+      $composableBuilder(column: $table.repostCount, builder: (column) => column);
 
   GeneratedColumn<int> get likeCount =>
       $composableBuilder(column: $table.likeCount, builder: (column) => column);
···
       referencedTable: $db.timelineItems,
       getReferencedColumn: (t) => t.postUri,
       builder:
-          (
-            joinBuilder, {
-            $addJoinBuilderToRootComposer,
-            $removeJoinBuilderFromRootComposer,
-          }) => $$TimelineItemsTableAnnotationComposer(
-            $db: $db,
-            $table: $db.timelineItems,
-            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
-            joinBuilder: joinBuilder,
-            $removeJoinBuilderFromRootComposer:
-                $removeJoinBuilderFromRootComposer,
-          ),
+          (joinBuilder, {$addJoinBuilderToRootComposer, $removeJoinBuilderFromRootComposer}) =>
+              $$TimelineItemsTableAnnotationComposer(
+                $db: $db,
+                $table: $db.timelineItems,
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer: $removeJoinBuilderFromRootComposer,
+              ),
     );
     return f(composer);
   }
···
         TableManagerState(
           db: db,
           table: table,
-          createFilteringComposer: () =>
-              $$PostsTableFilterComposer($db: db, $table: table),
-          createOrderingComposer: () =>
-              $$PostsTableOrderingComposer($db: db, $table: table),
+          createFilteringComposer: () => $$PostsTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () => $$PostsTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
               $$PostsTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
···
                 likeCount: likeCount,
                 rowid: rowid,
               ),
-          withReferenceMapper: (p0) => p0
-              .map(
-                (e) =>
-                    (e.readTable(table), $$PostsTableReferences(db, table, e)),
-              )
-              .toList(),
+          withReferenceMapper: (p0) =>
+              p0.map((e) => (e.readTable(table), $$PostsTableReferences(db, table, e))).toList(),
           prefetchHooksCallback: ({timelineItemsRefs = false}) {
             return PrefetchHooks(
               db: db,
-              explicitlyWatchedTables: [
-                if (timelineItemsRefs) db.timelineItems,
-              ],
+              explicitlyWatchedTables: [if (timelineItemsRefs) db.timelineItems],
               addJoins: null,
               getPrefetchedDataCallback: (items) async {
                 return [
                   if (timelineItemsRefs)
                     await $_getPrefetchedData<Post, $PostsTable, TimelineItem>(
                       currentTable: table,
-                      referencedTable: $$PostsTableReferences
-                          ._timelineItemsRefsTable(db),
-                      managerFromTypedResult: (p0) => $$PostsTableReferences(
-                        db,
-                        table,
-                        p0,
-                      ).timelineItemsRefs,
+                      referencedTable: $$PostsTableReferences._timelineItemsRefsTable(db),
+                      managerFromTypedResult: (p0) =>
+                          $$PostsTableReferences(db, table, p0).timelineItemsRefs,
                       referencedItemsForCurrentItem: (item, referencedItems) =>
                           referencedItems.where((e) => e.postUri == item.uri),
                       typedResults: items,
···
       Value<int> rowid,
     });
 
-class $$ProfilesTableFilterComposer
-    extends Composer<_$AppDatabase, $ProfilesTable> {
+class $$ProfilesTableFilterComposer extends Composer<_$AppDatabase, $ProfilesTable> {
   $$ProfilesTableFilterComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnFilters<String> get did => $composableBuilder(
-    column: $table.did,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get did =>
+      $composableBuilder(column: $table.did, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get handle => $composableBuilder(
-    column: $table.handle,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get handle =>
+      $composableBuilder(column: $table.handle, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get displayName => $composableBuilder(
-    column: $table.displayName,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get displayName =>
+      $composableBuilder(column: $table.displayName, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get description => $composableBuilder(
-    column: $table.description,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get description =>
+      $composableBuilder(column: $table.description, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get avatar => $composableBuilder(
-    column: $table.avatar,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get avatar =>
+      $composableBuilder(column: $table.avatar, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get banner => $composableBuilder(
-    column: $table.banner,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get banner =>
+      $composableBuilder(column: $table.banner, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<DateTime> get indexedAt => $composableBuilder(
-    column: $table.indexedAt,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<DateTime> get indexedAt =>
+      $composableBuilder(column: $table.indexedAt, builder: (column) => ColumnFilters(column));
 }
 
-class $$ProfilesTableOrderingComposer
-    extends Composer<_$AppDatabase, $ProfilesTable> {
+class $$ProfilesTableOrderingComposer extends Composer<_$AppDatabase, $ProfilesTable> {
   $$ProfilesTableOrderingComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnOrderings<String> get did => $composableBuilder(
-    column: $table.did,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get did =>
+      $composableBuilder(column: $table.did, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get handle => $composableBuilder(
-    column: $table.handle,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get handle =>
+      $composableBuilder(column: $table.handle, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get displayName => $composableBuilder(
-    column: $table.displayName,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get displayName =>
+      $composableBuilder(column: $table.displayName, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get description => $composableBuilder(
-    column: $table.description,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get description =>
+      $composableBuilder(column: $table.description, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get avatar => $composableBuilder(
-    column: $table.avatar,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get avatar =>
+      $composableBuilder(column: $table.avatar, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get banner => $composableBuilder(
-    column: $table.banner,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get banner =>
+      $composableBuilder(column: $table.banner, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<DateTime> get indexedAt => $composableBuilder(
-    column: $table.indexedAt,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<DateTime> get indexedAt =>
+      $composableBuilder(column: $table.indexedAt, builder: (column) => ColumnOrderings(column));
 }
 
-class $$ProfilesTableAnnotationComposer
-    extends Composer<_$AppDatabase, $ProfilesTable> {
+class $$ProfilesTableAnnotationComposer extends Composer<_$AppDatabase, $ProfilesTable> {
   $$ProfilesTableAnnotationComposer({
     required super.$db,
     required super.$table,
···
   GeneratedColumn<String> get handle =>
       $composableBuilder(column: $table.handle, builder: (column) => column);
 
-  GeneratedColumn<String> get displayName => $composableBuilder(
-    column: $table.displayName,
-    builder: (column) => column,
-  );
+  GeneratedColumn<String> get displayName =>
+      $composableBuilder(column: $table.displayName, builder: (column) => column);
 
-  GeneratedColumn<String> get description => $composableBuilder(
-    column: $table.description,
-    builder: (column) => column,
-  );
+  GeneratedColumn<String> get description =>
+      $composableBuilder(column: $table.description, builder: (column) => column);
 
   GeneratedColumn<String> get avatar =>
       $composableBuilder(column: $table.avatar, builder: (column) => column);
···
         TableManagerState(
           db: db,
           table: table,
-          createFilteringComposer: () =>
-              $$ProfilesTableFilterComposer($db: db, $table: table),
-          createOrderingComposer: () =>
-              $$ProfilesTableOrderingComposer($db: db, $table: table),
+          createFilteringComposer: () => $$ProfilesTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () => $$ProfilesTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
               $$ProfilesTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
···
                 indexedAt: indexedAt,
                 rowid: rowid,
               ),
-          withReferenceMapper: (p0) => p0
-              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
-              .toList(),
+          withReferenceMapper: (p0) =>
+              p0.map((e) => (e.readTable(table), BaseReferences(db, table, e))).toList(),
           prefetchHooksCallback: null,
         ),
       );
···
 
 final class $$TimelineItemsTableReferences
     extends BaseReferences<_$AppDatabase, $TimelineItemsTable, TimelineItem> {
-  $$TimelineItemsTableReferences(
-    super.$_db,
-    super.$_table,
-    super.$_typedResult,
-  );
+  $$TimelineItemsTableReferences(super.$_db, super.$_table, super.$_typedResult);
 
-  static $PostsTable _postUriTable(_$AppDatabase db) => db.posts.createAlias(
-    $_aliasNameGenerator(db.timelineItems.postUri, db.posts.uri),
-  );
+  static $PostsTable _postUriTable(_$AppDatabase db) =>
+      db.posts.createAlias($_aliasNameGenerator(db.timelineItems.postUri, db.posts.uri));
 
   $$PostsTableProcessedTableManager get postUri {
     final $_column = $_itemColumn<String>('post_uri')!;
···
     ).filter((f) => f.uri.sqlEquals($_column));
     final item = $_typedResult.readTableOrNull(_postUriTable($_db));
     if (item == null) return manager;
-    return ProcessedTableManager(
-      manager.$state.copyWith(prefetchedData: [item]),
-    );
+    return ProcessedTableManager(manager.$state.copyWith(prefetchedData: [item]));
   }
 }
 
-class $$TimelineItemsTableFilterComposer
-    extends Composer<_$AppDatabase, $TimelineItemsTable> {
+class $$TimelineItemsTableFilterComposer extends Composer<_$AppDatabase, $TimelineItemsTable> {
   $$TimelineItemsTableFilterComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnFilters<String> get feedKey => $composableBuilder(
-    column: $table.feedKey,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get feedKey =>
+      $composableBuilder(column: $table.feedKey, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get reason => $composableBuilder(
-    column: $table.reason,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get reason =>
+      $composableBuilder(column: $table.reason, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get sortKey => $composableBuilder(
-    column: $table.sortKey,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get sortKey =>
+      $composableBuilder(column: $table.sortKey, builder: (column) => ColumnFilters(column));
 
   $$PostsTableFilterComposer get postUri {
     final $$PostsTableFilterComposer composer = $composerBuilder(
···
       referencedTable: $db.posts,
       getReferencedColumn: (t) => t.uri,
       builder:
-          (
-            joinBuilder, {
-            $addJoinBuilderToRootComposer,
-            $removeJoinBuilderFromRootComposer,
-          }) => $$PostsTableFilterComposer(
-            $db: $db,
-            $table: $db.posts,
-            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
-            joinBuilder: joinBuilder,
-            $removeJoinBuilderFromRootComposer:
-                $removeJoinBuilderFromRootComposer,
-          ),
+          (joinBuilder, {$addJoinBuilderToRootComposer, $removeJoinBuilderFromRootComposer}) =>
+              $$PostsTableFilterComposer(
+                $db: $db,
+                $table: $db.posts,
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer: $removeJoinBuilderFromRootComposer,
+              ),
     );
     return composer;
   }
 }
 
-class $$TimelineItemsTableOrderingComposer
-    extends Composer<_$AppDatabase, $TimelineItemsTable> {
+class $$TimelineItemsTableOrderingComposer extends Composer<_$AppDatabase, $TimelineItemsTable> {
   $$TimelineItemsTableOrderingComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnOrderings<String> get feedKey => $composableBuilder(
-    column: $table.feedKey,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get feedKey =>
+      $composableBuilder(column: $table.feedKey, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get reason => $composableBuilder(
-    column: $table.reason,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get reason =>
+      $composableBuilder(column: $table.reason, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get sortKey => $composableBuilder(
-    column: $table.sortKey,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get sortKey =>
+      $composableBuilder(column: $table.sortKey, builder: (column) => ColumnOrderings(column));
 
   $$PostsTableOrderingComposer get postUri {
     final $$PostsTableOrderingComposer composer = $composerBuilder(
···
       referencedTable: $db.posts,
       getReferencedColumn: (t) => t.uri,
       builder:
-          (
-            joinBuilder, {
-            $addJoinBuilderToRootComposer,
-            $removeJoinBuilderFromRootComposer,
-          }) => $$PostsTableOrderingComposer(
-            $db: $db,
-            $table: $db.posts,
-            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
-            joinBuilder: joinBuilder,
-            $removeJoinBuilderFromRootComposer:
-                $removeJoinBuilderFromRootComposer,
-          ),
+          (joinBuilder, {$addJoinBuilderToRootComposer, $removeJoinBuilderFromRootComposer}) =>
+              $$PostsTableOrderingComposer(
+                $db: $db,
+                $table: $db.posts,
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer: $removeJoinBuilderFromRootComposer,
+              ),
     );
     return composer;
   }
 }
 
-class $$TimelineItemsTableAnnotationComposer
-    extends Composer<_$AppDatabase, $TimelineItemsTable> {
+class $$TimelineItemsTableAnnotationComposer extends Composer<_$AppDatabase, $TimelineItemsTable> {
   $$TimelineItemsTableAnnotationComposer({
     required super.$db,
     required super.$table,
···
       referencedTable: $db.posts,
       getReferencedColumn: (t) => t.uri,
       builder:
-          (
-            joinBuilder, {
-            $addJoinBuilderToRootComposer,
-            $removeJoinBuilderFromRootComposer,
-          }) => $$PostsTableAnnotationComposer(
-            $db: $db,
-            $table: $db.posts,
-            $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
-            joinBuilder: joinBuilder,
-            $removeJoinBuilderFromRootComposer:
-                $removeJoinBuilderFromRootComposer,
-          ),
+          (joinBuilder, {$addJoinBuilderToRootComposer, $removeJoinBuilderFromRootComposer}) =>
+              $$PostsTableAnnotationComposer(
+                $db: $db,
+                $table: $db.posts,
+                $addJoinBuilderToRootComposer: $addJoinBuilderToRootComposer,
+                joinBuilder: joinBuilder,
+                $removeJoinBuilderFromRootComposer: $removeJoinBuilderFromRootComposer,
+              ),
     );
     return composer;
   }
···
                 rowid: rowid,
               ),
           withReferenceMapper: (p0) => p0
-              .map(
-                (e) => (
-                  e.readTable(table),
-                  $$TimelineItemsTableReferences(db, table, e),
-                ),
-              )
+              .map((e) => (e.readTable(table), $$TimelineItemsTableReferences(db, table, e)))
               .toList(),
           prefetchHooksCallback: ({postUri = false}) {
             return PrefetchHooks(
···
                           state.withJoin(
                                 currentTable: table,
                                 currentColumn: table.postUri,
-                                referencedTable: $$TimelineItemsTableReferences
-                                    ._postUriTable(db),
+                                referencedTable: $$TimelineItemsTableReferences._postUriTable(db),
                                 referencedColumn: $$TimelineItemsTableReferences
                                     ._postUriTable(db)
                                     .uri,
···
       Value<int> rowid,
     });
 
-class $$AccountsTableFilterComposer
-    extends Composer<_$AppDatabase, $AccountsTable> {
+class $$AccountsTableFilterComposer extends Composer<_$AppDatabase, $AccountsTable> {
   $$AccountsTableFilterComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnFilters<String> get did => $composableBuilder(
-    column: $table.did,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get did =>
+      $composableBuilder(column: $table.did, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get handle => $composableBuilder(
-    column: $table.handle,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get handle =>
+      $composableBuilder(column: $table.handle, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get pdsUrl => $composableBuilder(
-    column: $table.pdsUrl,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get pdsUrl =>
+      $composableBuilder(column: $table.pdsUrl, builder: (column) => ColumnFilters(column));
 }
 
-class $$AccountsTableOrderingComposer
-    extends Composer<_$AppDatabase, $AccountsTable> {
+class $$AccountsTableOrderingComposer extends Composer<_$AppDatabase, $AccountsTable> {
   $$AccountsTableOrderingComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnOrderings<String> get did => $composableBuilder(
-    column: $table.did,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get did =>
+      $composableBuilder(column: $table.did, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get handle => $composableBuilder(
-    column: $table.handle,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get handle =>
+      $composableBuilder(column: $table.handle, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get pdsUrl => $composableBuilder(
-    column: $table.pdsUrl,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get pdsUrl =>
+      $composableBuilder(column: $table.pdsUrl, builder: (column) => ColumnOrderings(column));
 }
 
-class $$AccountsTableAnnotationComposer
-    extends Composer<_$AppDatabase, $AccountsTable> {
+class $$AccountsTableAnnotationComposer extends Composer<_$AppDatabase, $AccountsTable> {
   $$AccountsTableAnnotationComposer({
     required super.$db,
     required super.$table,
···
         TableManagerState(
           db: db,
           table: table,
-          createFilteringComposer: () =>
-              $$AccountsTableFilterComposer($db: db, $table: table),
-          createOrderingComposer: () =>
-              $$AccountsTableOrderingComposer($db: db, $table: table),
+          createFilteringComposer: () => $$AccountsTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () => $$AccountsTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
               $$AccountsTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
···
                 Value<String> handle = const Value.absent(),
                 Value<String> pdsUrl = const Value.absent(),
                 Value<int> rowid = const Value.absent(),
-              }) => AccountsCompanion(
-                did: did,
-                handle: handle,
-                pdsUrl: pdsUrl,
-                rowid: rowid,
-              ),
+              }) => AccountsCompanion(did: did, handle: handle, pdsUrl: pdsUrl, rowid: rowid),
           createCompanionCallback:
               ({
                 required String did,
                 required String handle,
                 required String pdsUrl,
                 Value<int> rowid = const Value.absent(),
-              }) => AccountsCompanion.insert(
-                did: did,
-                handle: handle,
-                pdsUrl: pdsUrl,
-                rowid: rowid,
-              ),
-          withReferenceMapper: (p0) => p0
-              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
-              .toList(),
+              }) =>
+                  AccountsCompanion.insert(did: did, handle: handle, pdsUrl: pdsUrl, rowid: rowid),
+          withReferenceMapper: (p0) =>
+              p0.map((e) => (e.readTable(table), BaseReferences(db, table, e))).toList(),
           prefetchHooksCallback: null,
         ),
       );
···
       Value<int> rowid,
     });
 
-class $$FeedCursorsTableFilterComposer
-    extends Composer<_$AppDatabase, $FeedCursorsTable> {
+class $$FeedCursorsTableFilterComposer extends Composer<_$AppDatabase, $FeedCursorsTable> {
   $$FeedCursorsTableFilterComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnFilters<String> get feedKey => $composableBuilder(
-    column: $table.feedKey,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get feedKey =>
+      $composableBuilder(column: $table.feedKey, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<String> get cursor => $composableBuilder(
-    column: $table.cursor,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<String> get cursor =>
+      $composableBuilder(column: $table.cursor, builder: (column) => ColumnFilters(column));
 
-  ColumnFilters<DateTime> get lastUpdated => $composableBuilder(
-    column: $table.lastUpdated,
-    builder: (column) => ColumnFilters(column),
-  );
+  ColumnFilters<DateTime> get lastUpdated =>
+      $composableBuilder(column: $table.lastUpdated, builder: (column) => ColumnFilters(column));
 }
 
-class $$FeedCursorsTableOrderingComposer
-    extends Composer<_$AppDatabase, $FeedCursorsTable> {
+class $$FeedCursorsTableOrderingComposer extends Composer<_$AppDatabase, $FeedCursorsTable> {
   $$FeedCursorsTableOrderingComposer({
     required super.$db,
     required super.$table,
···
     super.$addJoinBuilderToRootComposer,
     super.$removeJoinBuilderFromRootComposer,
   });
-  ColumnOrderings<String> get feedKey => $composableBuilder(
-    column: $table.feedKey,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get feedKey =>
+      $composableBuilder(column: $table.feedKey, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<String> get cursor => $composableBuilder(
-    column: $table.cursor,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<String> get cursor =>
+      $composableBuilder(column: $table.cursor, builder: (column) => ColumnOrderings(column));
 
-  ColumnOrderings<DateTime> get lastUpdated => $composableBuilder(
-    column: $table.lastUpdated,
-    builder: (column) => ColumnOrderings(column),
-  );
+  ColumnOrderings<DateTime> get lastUpdated =>
+      $composableBuilder(column: $table.lastUpdated, builder: (column) => ColumnOrderings(column));
 }
 
-class $$FeedCursorsTableAnnotationComposer
-    extends Composer<_$AppDatabase, $FeedCursorsTable> {
+class $$FeedCursorsTableAnnotationComposer extends Composer<_$AppDatabase, $FeedCursorsTable> {
   $$FeedCursorsTableAnnotationComposer({
     required super.$db,
     required super.$table,
···
   GeneratedColumn<String> get cursor =>
       $composableBuilder(column: $table.cursor, builder: (column) => column);
 
-  GeneratedColumn<DateTime> get lastUpdated => $composableBuilder(
-    column: $table.lastUpdated,
-    builder: (column) => column,
-  );
+  GeneratedColumn<DateTime> get lastUpdated =>
+      $composableBuilder(column: $table.lastUpdated, builder: (column) => column);
 }
 
 class $$FeedCursorsTableTableManager
···
           $$FeedCursorsTableAnnotationComposer,
           $$FeedCursorsTableCreateCompanionBuilder,
           $$FeedCursorsTableUpdateCompanionBuilder,
-          (
-            FeedCursor,
-            BaseReferences<_$AppDatabase, $FeedCursorsTable, FeedCursor>,
-          ),
+          (FeedCursor, BaseReferences<_$AppDatabase, $FeedCursorsTable, FeedCursor>),
           FeedCursor,
           PrefetchHooks Function()
         > {
···
         TableManagerState(
           db: db,
           table: table,
-          createFilteringComposer: () =>
-              $$FeedCursorsTableFilterComposer($db: db, $table: table),
-          createOrderingComposer: () =>
-              $$FeedCursorsTableOrderingComposer($db: db, $table: table),
+          createFilteringComposer: () => $$FeedCursorsTableFilterComposer($db: db, $table: table),
+          createOrderingComposer: () => $$FeedCursorsTableOrderingComposer($db: db, $table: table),
           createComputedFieldComposer: () =>
               $$FeedCursorsTableAnnotationComposer($db: db, $table: table),
           updateCompanionCallback:
···
                 lastUpdated: lastUpdated,
                 rowid: rowid,
               ),
-          withReferenceMapper: (p0) => p0
-              .map((e) => (e.readTable(table), BaseReferences(db, table, e)))
-              .toList(),
+          withReferenceMapper: (p0) =>
+              p0.map((e) => (e.readTable(table), BaseReferences(db, table, e))).toList(),
           prefetchHooksCallback: null,
         ),
       );
···
       $$FeedCursorsTableAnnotationComposer,
       $$FeedCursorsTableCreateCompanionBuilder,
       $$FeedCursorsTableUpdateCompanionBuilder,
-      (
-        FeedCursor,
-        BaseReferences<_$AppDatabase, $FeedCursorsTable, FeedCursor>,
-      ),
+      (FeedCursor, BaseReferences<_$AppDatabase, $FeedCursorsTable, FeedCursor>),
       FeedCursor,
       PrefetchHooks Function()
     >;
···
 class $AppDatabaseManager {
   final _$AppDatabase _db;
   $AppDatabaseManager(this._db);
-  $$PostsTableTableManager get posts =>
-      $$PostsTableTableManager(_db, _db.posts);
-  $$ProfilesTableTableManager get profiles =>
-      $$ProfilesTableTableManager(_db, _db.profiles);
+  $$PostsTableTableManager get posts => $$PostsTableTableManager(_db, _db.posts);
+  $$ProfilesTableTableManager get profiles => $$ProfilesTableTableManager(_db, _db.profiles);
   $$TimelineItemsTableTableManager get timelineItems =>
       $$TimelineItemsTableTableManager(_db, _db.timelineItems);
-  $$AccountsTableTableManager get accounts =>
-      $$AccountsTableTableManager(_db, _db.accounts);
+  $$AccountsTableTableManager get accounts => $$AccountsTableTableManager(_db, _db.accounts);
   $$FeedCursorsTableTableManager get feedCursors =>
       $$FeedCursorsTableTableManager(_db, _db.feedCursors);
 }

lib/src/infrastructure/network/providers.g.dart

···
 ///
 /// This client is configured for the public AppView at public.api.bsky.app.
 
-final class DioPublicProvider extends $FunctionalProvider<Dio, Dio, Dio>
-    with $Provider<Dio> {
+final class DioPublicProvider extends $FunctionalProvider<Dio, Dio, Dio> with $Provider<Dio> {
   /// Provides the public Dio client for unauthenticated API access.
   ///
   /// This client is configured for the public AppView at public.api.bsky.app.
···
 
   @$internal
   @override
-  $ProviderElement<Dio> $createElement($ProviderPointer pointer) =>
-      $ProviderElement(pointer);
+  $ProviderElement<Dio> $createElement($ProviderPointer pointer) => $ProviderElement(pointer);
 
   @override
   Dio create(Ref ref) {
···
 
   /// {@macro riverpod.override_with_value}
   Override overrideWithValue(Dio value) {
-    return $ProviderOverride(
-      origin: this,
-      providerOverride: $SyncValueProvider<Dio>(value),
-    );
+    return $ProviderOverride(origin: this, providerOverride: $SyncValueProvider<Dio>(value));
   }
 }
 
···
 /// This requires a logged-in user with a resolved PDS URL.
 /// Returns null if no user is logged in.
 
-final class DioPdsProvider extends $FunctionalProvider<Dio?, Dio?, Dio?>
-    with $Provider<Dio?> {
+final class DioPdsProvider extends $FunctionalProvider<Dio?, Dio?, Dio?> with $Provider<Dio?> {
   /// Provides the PDS Dio client for authenticated API access.
   ///
   /// This requires a logged-in user with a resolved PDS URL.
···
 
   @$internal
   @override
-  $ProviderElement<Dio?> $createElement($ProviderPointer pointer) =>
-      $ProviderElement(pointer);
+  $ProviderElement<Dio?> $createElement($ProviderPointer pointer) => $ProviderElement(pointer);
 
   @override
   Dio? create(Ref ref) {
···
 
   /// {@macro riverpod.override_with_value}
   Override overrideWithValue(Dio? value) {
-    return $ProviderOverride(
-      origin: this,
-      providerOverride: $SyncValueProvider<Dio?>(value),
-    );
+    return $ProviderOverride(origin: this, providerOverride: $SyncValueProvider<Dio?>(value));
   }
 }
 
···
 /// This client automatically routes requests to the correct host
 /// based on endpoint metadata in the registry.
 
-final class XrpcClientProvider
-    extends $FunctionalProvider<XrpcClient, XrpcClient, XrpcClient>
+final class XrpcClientProvider extends $FunctionalProvider<XrpcClient, XrpcClient, XrpcClient>
     with $Provider<XrpcClient> {
   /// Provides the XRPC client for making API requests.
   ///