fix: feed syncing and dev tool record parsing

ios/Podfile.lock

···
   - Mantle (2.2.0):
     - Mantle/extobjc (= 2.2.0)
   - Mantle/extobjc (2.2.0)
+  - package_info_plus (0.4.5):
+    - Flutter
   - path_provider_foundation (0.0.1):
     - Flutter
     - FlutterMacOS
···
   - flutter_secure_storage_darwin (from `.symlinks/plugins/flutter_secure_storage_darwin/darwin`)
   - gal (from `.symlinks/plugins/gal/darwin`)
   - image_picker_ios (from `.symlinks/plugins/image_picker_ios/ios`)
+  - package_info_plus (from `.symlinks/plugins/package_info_plus/ios`)
   - path_provider_foundation (from `.symlinks/plugins/path_provider_foundation/darwin`)
   - shared_preferences_foundation (from `.symlinks/plugins/shared_preferences_foundation/darwin`)
   - sqlite3_flutter_libs (from `.symlinks/plugins/sqlite3_flutter_libs/darwin`)
···
     :path: ".symlinks/plugins/gal/darwin"
   image_picker_ios:
     :path: ".symlinks/plugins/image_picker_ios/ios"
+  package_info_plus:
+    :path: ".symlinks/plugins/package_info_plus/ios"
   path_provider_foundation:
     :path: ".symlinks/plugins/path_provider_foundation/darwin"
   shared_preferences_foundation:
···
   image_picker_ios: 4f2f91b01abdb52842a8e277617df877e40f905b
   libwebp: 02b23773aedb6ff1fd38cec7a77b81414c6842a8
   Mantle: c5aa8794a29a022dfbbfc9799af95f477a69b62d
+  package_info_plus: c0502532a26c7662a62a356cebe2692ec5fe4ec4
   path_provider_foundation: 0b743cbb62d8e47eab856f09262bb8c1ddcfe6ba
   SDWebImage: e9c98383c7572d713c1a0d7dd2783b10599b9838
   SDWebImageWebPCoder: 0e06e365080397465cc73a7a9b472d8a3bd0f377

lib/src/features/debug/presentation/debug_drawer.dart

···
 import 'package:flutter_riverpod/flutter_riverpod.dart';
 import 'package:go_router/go_router.dart';
 
+import '../../../app/router.dart';
 import '../application/debug_overlay_controller.dart';
 import 'atproto_session_tab.dart';
 import 'network_inspector_tab.dart';
···
     final overlayState = ref.watch(debugOverlayControllerProvider);
     final theme = Theme.of(context);
 
-    return Material(
-      elevation: 16,
-      color: theme.colorScheme.surface,
-      child: SafeArea(
-        left: false,
-        child: DefaultTabController(
-          length: 3,
-          initialIndex: overlayState.activeTabIndex,
-          child: Column(
-            children: [
-              _buildHeader(context, ref, theme),
-              _buildTabBar(theme),
-              const Expanded(
-                child: TabBarView(
-                  children: [SystemInfoTab(), AtprotoSessionTab(), NetworkInspectorTab()],
+    return Overlay(
+      initialEntries: [
+        OverlayEntry(
+          builder: (_) => Material(
+            elevation: 16,
+            color: theme.colorScheme.surface,
+            child: SafeArea(
+              left: false,
+              child: DefaultTabController(
+                length: 3,
+                initialIndex: overlayState.activeTabIndex,
+                child: Column(
+                  children: [
+                    _buildHeader(context, ref, theme),
+                    _buildTabBar(theme),
+                    const Expanded(
+                      child: TabBarView(
+                        children: [SystemInfoTab(), AtprotoSessionTab(), NetworkInspectorTab()],
+                      ),
+                    ),
+                    _buildFooter(context, ref, theme),
+                  ],
                 ),
               ),
-              _buildFooter(context, ref, theme),
-            ],
+            ),
           ),
         ),
-      ),
+      ],
     );
   }
 
···
       child: FilledButton.tonal(
         onPressed: () {
           ref.read(debugOverlayControllerProvider.notifier).hide();
-          context.push('/devtools');
+          rootNavigatorKey.currentContext?.go('/devtools');
         },
         child: const Row(
           mainAxisAlignment: MainAxisAlignment.center,

lib/src/features/developer_tools/domain/repo_collection.dart

···
 ///
 /// A collection is a type of record in a user's repository (e.g.,
 /// app.bsky.feed.post, app.bsky.actor.profile).
+///
+/// Note: The com.atproto.repo.describeRepo API only returns collection NSIDs,
+/// not record counts.
 class RepoCollection {
-  const RepoCollection({required this.nsid, required this.count});
+  const RepoCollection({required this.nsid});
 
-  /// Creates a collection from JSON response.
-  factory RepoCollection.fromJson(Map<String, dynamic> json) {
-    return RepoCollection(
-      nsid: json['nsid'] as String? ?? json['collection'] as String,
-      count: json['count'] as int? ?? 0,
-    );
+  /// Creates a collection from an NSID string.
+  factory RepoCollection.fromNsid(String nsid) {
+    return RepoCollection(nsid: nsid);
   }
 
   /// Collection NSID (e.g., "app.bsky.feed.post").
   final String nsid;
 
-  /// Number of records in this collection.
-  final int count;
-
   Map<String, dynamic> toJson() {
-    return {'nsid': nsid, 'count': count};
+    return {'nsid': nsid};
   }
 
   @override
   bool operator ==(Object other) =>
       identical(this, other) ||
-      other is RepoCollection &&
-          runtimeType == other.runtimeType &&
-          nsid == other.nsid &&
-          count == other.count;
+      other is RepoCollection && runtimeType == other.runtimeType && nsid == other.nsid;
 
   @override
-  int get hashCode => Object.hash(nsid, count);
+  int get hashCode => nsid.hashCode;
 
   @override
-  String toString() => 'RepoCollection(nsid: $nsid, count: $count)';
+  String toString() => 'RepoCollection(nsid: $nsid)';
 }

lib/src/features/developer_tools/infrastructure/devtools_repository.dart

···
   /// Calls com.atproto.repo.describeRepo to get available collections
   /// for the specified DID.
   ///
-  /// Returns a list of collections with their NSIDs and record counts.
+  /// Returns a list of collections with their NSIDs. Note that the API
+  /// only returns collection NSIDs (as strings), not record counts.
   Future<List<RepoCollection>> describeRepo(String did) async {
     _logger.info('Describing repo for DID: $did');
 
···
         return [];
       }
 
-      return collections
-          .map((json) => RepoCollection.fromJson(json as Map<String, dynamic>))
-          .toList();
+      return collections.map((nsid) => RepoCollection.fromNsid(nsid as String)).toList();
     } catch (e, stack) {
       _logger.error('Failed to describe repo for DID: $did', e, stack);
       rethrow;

lib/src/features/developer_tools/presentation/screens/collections_page.dart

···
 
     return ListTile(
       title: Text(collection.nsid),
-      subtitle: Text(
-        '${collection.count} ${collection.count == 1 ? 'record' : 'records'}',
-        style: theme.textTheme.bodySmall?.copyWith(color: theme.colorScheme.onSurfaceVariant),
-      ),
       trailing: Row(
         mainAxisSize: MainAxisSize.min,
         children: [

lib/src/features/developer_tools/presentation/screens/dev_tools_home_page.dart

···
           ),
           const SizedBox(height: 16),
           _buildInfoCard(context, title: 'PDS Host', value: pdsUrl),
-          const SizedBox(height: 16),
+          const SizedBox(height: 24),
           Text('Quick Actions', style: theme.textTheme.titleMedium),
           const SizedBox(height: 8),
-          const Card(
-            child: Padding(padding: EdgeInsets.all(16.0), child: Text('Coming soon...')),
+          Card(
+            clipBehavior: Clip.antiAlias,
+            child: ListTile(
+              leading: const Icon(Icons.folder_outlined),
+              title: const Text('Browse My Repository'),
+              subtitle: const Text('Explore collections and records'),
+              trailing: const Icon(Icons.chevron_right),
+              onTap: authState is AuthStateAuthenticated
+                  ? () => context.push('/devtools/collections')
+                  : null,
+              enabled: authState is AuthStateAuthenticated,
+            ),
           ),
         ],
       ),

lib/src/features/feeds/application/feed_providers.dart

···
     final authState = ref.watch(authProvider);
     final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
 
-    if (ownerDid == null) return const Stream.empty();
+    if (ownerDid == null) {
+      return const Stream.empty();
+    }
 
     final repository = ref.watch(feedRepositoryProvider);
-    return repository
-        .watchAllFeeds(ownerDid)
-        .map((list) => list.map(SavedFeedData.fromEntity).toList());
+    return repository.watchAllFeeds(ownerDid).map((list) {
+      return list.map(SavedFeedData.fromEntity).toList();
+    });
   }
 }
 
···
     final authState = ref.watch(authProvider);
     final ownerDid = (authState is AuthStateAuthenticated) ? authState.session.did : null;
 
-    if (ownerDid == null) return const Stream.empty();
+    if (ownerDid == null) {
+      return const Stream.empty();
+    }
 
     final repository = ref.watch(feedRepositoryProvider);
-    return repository
-        .watchPinnedFeeds(ownerDid)
-        .map((list) => list.map(SavedFeedData.fromEntity).toList());
+    return repository.watchPinnedFeeds(ownerDid).map((list) {
+      return list.map(SavedFeedData.fromEntity).toList();
+    });
   }
 }
 

lib/src/features/feeds/infrastructure/feed_repository.dart

···
     List<String> remotePinnedUris,
     String ownerDid,
   ) async {
+    _logger.debug(
+      'Merging preferences: ${remoteSavedUris.length} saved, ${remotePinnedUris.length} pinned',
+    );
+    final pinnedStr = remotePinnedUris.join(', ');
+    _logger.debug(
+      'Pinned URIs: ${pinnedStr.length > 500 ? pinnedStr.substring(0, 500) : pinnedStr}',
+    );
+
     final localFeeds = await _dao.getAllFeeds(ownerDid);
     final now = DateTime.now();
     final remoteSavedSet = remoteSavedUris.toSet();
···
 
     final Map<String, FeedGenerator> fetchedMetadata = {};
     if (newRemoteFeeds.isNotEmpty) {
+      _logger.debug('Need to fetch metadata for ${newRemoteFeeds.length} new feeds');
       try {
         final batchResults = await getFeedGenerators(newRemoteFeeds);
+        _logger.debug('Batch fetch returned ${batchResults.length} results');
         for (final feed in batchResults) {
           fetchedMetadata[feed.uri] = feed;
         }
-      } catch (e) {
-        _logger.warning('Failed to batch fetch feed metadata', {'error': e});
+      } catch (e, stack) {
+        _logger.error('Failed to batch fetch feed metadata', {'error': e, 'stack': stack});
       }
+    } else {
+      _logger.debug('No new feeds need metadata fetching');
     }
 
     for (var i = 0; i < remoteSavedUris.length; i++) {
···
                 localUpdatedAt: const Value(null),
               ),
             );
+            _logger.debug('Prepared feed for insert', {
+              'uri': remoteUri,
+              'name': metadata.displayName,
+              'isPinned': remoteIsPinned,
+            });
           } else {
             _logger.warning('Missing metadata for $remoteUri');
           }
···
       }
     }
 
+    _logger.debug(
+      'Database operations: ${feedsToInsert.length} inserts, ${feedsToUpdate.length} updates, ${feedsToRemove.length} deletes',
+    );
+
     if (feedsToInsert.isNotEmpty) {
+      final pinnedInserts = feedsToInsert.where((f) => f.isPinned.value == true).length;
+      _logger.debug('Inserting ${feedsToInsert.length} feeds ($pinnedInserts pinned)');
       await _dao.upsertFeeds(feedsToInsert);
     }
-    for (final update in feedsToUpdate) {
-      await _dao.updateSyncState(
-        uri: update.uri,
-        ownerDid: ownerDid,
-        sortOrder: update.sortOrder,
-        isPinned: update.isPinned,
-        lastSynced: update.lastSynced,
-        clearLocalModification: update.clearLocalUpdatedAt,
-      );
+
+    if (feedsToUpdate.isNotEmpty) {
+      final pinnedUpdates = feedsToUpdate.where((u) => u.isPinned).length;
+      _logger.debug('Updating ${feedsToUpdate.length} feeds ($pinnedUpdates pinned)');
+      for (final update in feedsToUpdate) {
+        await _dao.updateSyncState(
+          uri: update.uri,
+          ownerDid: ownerDid,
+          sortOrder: update.sortOrder,
+          isPinned: update.isPinned,
+          lastSynced: update.lastSynced,
+          clearLocalModification: update.clearLocalUpdatedAt,
+        );
+      }
     }
-    for (final uri in feedsToRemove) {
-      await _dao.deleteFeed(uri, ownerDid);
+
+    if (feedsToRemove.isNotEmpty) {
+      _logger.debug('Deleting ${feedsToRemove.length} feeds');
+      for (final uri in feedsToRemove) {
+        await _dao.deleteFeed(uri, ownerDid);
+      }
     }
 
     for (final uri in feedsToSyncToRemote) {
···
       if (!existing.any((e) => e.payload == uri && e.type == 'save')) {
         await _syncQueueDao.enqueueFeedSync(type: 'save', feedUri: uri, ownerDid: ownerDid);
       }
+    }
+
+    final allFeeds = await _dao.getAllFeeds(ownerDid);
+    final pinnedFeeds = allFeeds.where((f) => f.isPinned).toList();
+    _logger.debug('Sync completed: ${allFeeds.length} total, ${pinnedFeeds.length} pinned');
+    if (pinnedFeeds.isNotEmpty) {
+      final pinnedNames = pinnedFeeds.map((f) => '${f.displayName} (${f.uri})').join(', ');
+      _logger.debug(
+        'Pinned feeds: ${pinnedNames.length > 500 ? pinnedNames.substring(0, 500) : pinnedNames}',
+      );
+    } else {
+      _logger.warning('No pinned feeds found after sync!');
     }
   }
 
···
   Future<List<FeedGenerator>> getFeedGenerators(List<String> uris) async {
     if (uris.isEmpty) return [];
 
+    _logger.debug('Batch fetching feed generators', {'count': uris.length});
+
     const batchSize = 25;
     final results = <FeedGenerator>[];
 
···
       final end = (i + batchSize < uris.length) ? i + batchSize : uris.length;
       final batch = uris.sublist(i, end);
 
+      _logger.debug('Fetching batch $i-$end', {'batchSize': batch.length, 'uris': batch});
+
       try {
         final response = await _api.call(
           'app.bsky.feed.getFeedGenerators',
           params: {'feeds': batch},
         );
 
-        final views = (response['feeds'] as List).cast<Map<String, dynamic>>();
-        results.addAll(views.map((v) => FeedGenerator.fromJson(v)));
-      } catch (e) {
-        _logger.error('Batch fetch failed for slice $i-$end', {'error': e});
+        final feedsArray = response['feeds'];
+        if (feedsArray is! List) {
+          _logger.error('Invalid response structure', {
+            'expected': 'List',
+            'got': feedsArray.runtimeType,
+            'response': response,
+          });
+          continue;
+        }
+
+        final views = feedsArray.cast<Map<String, dynamic>>();
+        final batchResults = views.map((v) => FeedGenerator.fromJson(v)).toList();
+        results.addAll(batchResults);
+
+        _logger.debug('Batch $i-$end successful', {
+          'requested': batch.length,
+          'received': batchResults.length,
+        });
+      } catch (e, stack) {
+        _logger.error('Batch fetch failed for slice $i-$end', {
+          'error': e,
+          'stack': stack,
+          'batchUris': batch,
+        });
       }
     }
 
+    _logger.debug('Batch fetch complete', {
+      'totalRequested': uris.length,
+      'totalReceived': results.length,
+    });
     return results;
   }
 }

lib/src/infrastructure/db/daos/saved_feeds_dao.dart

···
     return (select(savedFeeds)
           ..where((t) => t.ownerDid.equals(ownerDid))
           ..orderBy([(t) => OrderingTerm(expression: t.sortOrder)]))
-        .watch();
+        .watch()
+        .map((list) {
+          return list;
+        });
   }
 
   /// Gets all pinned feeds ordered by sortOrder.
···
           ..where((t) => t.ownerDid.equals(ownerDid))
           ..where((t) => t.isPinned.equals(true))
           ..orderBy([(t) => OrderingTerm(expression: t.sortOrder)]))
-        .watch();
+        .watch()
+        .map((list) {
+          return list;
+        });
   }
 
   /// Gets feeds that haven't been synced recently (stale metadata).

lib/src/infrastructure/network/dio_clients.dart

···
 ///
 /// This client is used for unauthenticated reads like fetching profiles, threads, and
 /// search results.
+///
+/// The [listFormat] is set to [ListFormat.multi] to serialize array query
+/// parameters as repeated parameter names (e.g., ?feeds=uri1&feeds=uri2), which is
+/// the format expected by AT Protocol endpoints.
 Dio createPublicDio({bool enableLogging = true, List<Interceptor> interceptors = const []}) {
   final dio = Dio(
     BaseOptions(
···
       receiveTimeout: const Duration(seconds: 30),
       sendTimeout: const Duration(seconds: 30),
       headers: {'Accept': 'application/json', 'Content-Type': 'application/json'},
+      listFormat: ListFormat.multi,
     ),
   );
 
···
 ///
 /// This client is used for authenticated operations and requires the PDS URL to be provided
 /// (i.e. resolved from user's DID document).
+///
+/// The [listFormat] is set to [ListFormat.multi] to serialize array query
+/// parameters as repeated parameter names (e.g., ?feeds=uri1&feeds=uri2), which is
+/// the format expected by AT Protocol endpoints.
 Dio createPdsDio({
   required String pdsUrl,
   required SessionGetter getSession,
···
       receiveTimeout: const Duration(seconds: 30),
       sendTimeout: const Duration(seconds: 30),
       headers: {'Accept': 'application/json', 'Content-Type': 'application/json'},
+      listFormat: ListFormat.multi,
     ),
   );
 

lib/src/infrastructure/network/endpoint_registry.dart

···
     'app.bsky.feed.getFeed': const EndpointMeta(
       nsid: 'app.bsky.feed.getFeed',
       method: HttpMethod.get,
-      hostKind: HostKind.publicApi,
-      requiresAuth: false,
+      hostKind: HostKind.pds,
+      requiresAuth: true,
+    ),
+    'app.bsky.feed.getListFeed': const EndpointMeta(
+      nsid: 'app.bsky.feed.getListFeed',
+      method: HttpMethod.get,
+      hostKind: HostKind.pds,
+      requiresAuth: true,
     ),
     'app.bsky.feed.getFeedGenerator': const EndpointMeta(
       nsid: 'app.bsky.feed.getFeedGenerator',
+      method: HttpMethod.get,
+      hostKind: HostKind.publicApi,
+    ),
+    'app.bsky.feed.getFeedGenerators': const EndpointMeta(
+      nsid: 'app.bsky.feed.getFeedGenerators',
       method: HttpMethod.get,
       hostKind: HostKind.publicApi,
     ),
···
       method: HttpMethod.get,
       hostKind: HostKind.publicApi,
     ),
+    'app.bsky.graph.getList': const EndpointMeta(
+      nsid: 'app.bsky.graph.getList',
+      method: HttpMethod.get,
+      hostKind: HostKind.publicApi,
+    ),
     'app.bsky.graph.muteActor': const EndpointMeta(
       nsid: 'app.bsky.graph.muteActor',
       method: HttpMethod.post,
···
     'com.atproto.repo.getRecord': const EndpointMeta(
       nsid: 'com.atproto.repo.getRecord',
       method: HttpMethod.get,
-      hostKind: HostKind.publicApi,
+      hostKind: HostKind.pds,
+      requiresAuth: true,
     ),
     'com.atproto.repo.describeRepo': const EndpointMeta(
       nsid: 'com.atproto.repo.describeRepo',
       method: HttpMethod.get,
-      hostKind: HostKind.publicApi,
+      hostKind: HostKind.pds,
+      requiresAuth: true,
     ),
     'com.atproto.repo.listRecords': const EndpointMeta(
       nsid: 'com.atproto.repo.listRecords',
       method: HttpMethod.get,
-      hostKind: HostKind.publicApi,
+      hostKind: HostKind.pds,
+      requiresAuth: true,
     ),
 
     'com.atproto.identity.resolveHandle': const EndpointMeta(

test/src/features/developer_tools/infrastructure/devtools_repository_test.dart

···
 
       test('returns list of collections on success', () async {
         final responseData = {
-          'collections': [
-            {'nsid': 'app.bsky.feed.post', 'count': 42},
-            {'nsid': 'app.bsky.actor.profile', 'count': 1},
-            {'nsid': 'app.bsky.graph.follow', 'count': 100},
-          ],
+          'collections': ['app.bsky.feed.post', 'app.bsky.actor.profile', 'app.bsky.graph.follow'],
         };
 
         when(
···
 
         expect(result, hasLength(3));
         expect(result[0].nsid, 'app.bsky.feed.post');
-        expect(result[0].count, 42);
         expect(result[1].nsid, 'app.bsky.actor.profile');
-        expect(result[1].count, 1);
         expect(result[2].nsid, 'app.bsky.graph.follow');
-        expect(result[2].count, 100);
 
         verify(
           () => mockXrpc.call('com.atproto.repo.describeRepo', params: {'repo': testDid}),

test/src/features/developer_tools/presentation/screens/dev_tools_home_page_test.dart

···
       expect(find.text('https://pds.example.com'), findsOneWidget);
 
       expect(find.text('Quick Actions'), findsOneWidget);
-      expect(find.text('Coming soon...'), findsOneWidget);
+      expect(find.text('Browse My Repository'), findsOneWidget);
+      expect(find.text('Explore collections and records'), findsOneWidget);
     });
 
     testWidgets('copies DID to clipboard', (tester) async {

test/src/infrastructure/network/endpoint_registry_test.dart

···
         expect(meta.proxyKind, equals(ProxyKind.chat), reason: '$nsid should use chat proxy');
       }
     });
+
+    test('feed generator endpoints are registered', () {
+      final feedEndpoints = ['app.bsky.feed.getFeedGenerator', 'app.bsky.feed.getFeedGenerators'];
+
+      for (final nsid in feedEndpoints) {
+        final meta = registry.get(nsid);
+        expect(meta.hostKind, equals(HostKind.publicApi), reason: '$nsid should use publicApi');
+        expect(meta.requiresAuth, isFalse, reason: '$nsid should not require auth');
+        expect(meta.method, equals(HttpMethod.get), reason: '$nsid should be GET');
+      }
+    });
+
+    test('graph list endpoints are registered', () {
+      final listEndpoints = ['app.bsky.graph.getList'];
+
+      for (final nsid in listEndpoints) {
+        final meta = registry.get(nsid);
+        expect(meta.hostKind, equals(HostKind.publicApi), reason: '$nsid should use publicApi');
+        expect(meta.requiresAuth, isFalse, reason: '$nsid should not require auth');
+        expect(meta.method, equals(HttpMethod.get), reason: '$nsid should be GET');
+      }
+    });
   });
 }