add user sync collections method for an after first login sync use case, fix limit param in search and list record requests

api/scripts/codegen.sh

···
         echo "," >> "$temp_file"
     fi
     first=false
-    
+
     # Extract nsid and definitions from the lexicon file
     nsid=$(jq -r '.id' "$lexicon_file")
     definitions=$(jq '.defs' "$lexicon_file")
-    
+
     # Create the formatted lexicon object
     echo "  {" >> "$temp_file"
     echo "    \"nsid\": \"$nsid\"," >> "$temp_file"
···
 
 # Generate the TypeScript client
 echo "Generating TypeScript client..."
-deno run --allow-all ./scripts/generate-typescript.ts "$(cat "$temp_file")" > ./generated_client.ts
+deno run --allow-all ./scripts/generate_typescript.ts "$(cat "$temp_file")" > ./generated_client.ts
 
 # Clean up
 rm "$temp_file"
 
-echo "✅ Generated TypeScript client at ./generated_client.ts"
+echo "✅ Generated TypeScript client at ./generated_client.ts"

api/scripts/generate_typescript.ts

···
     type: "JobStatus[]",
   });
 
+  // Sync user collections interfaces
+  sourceFile.addInterface({
+    name: "SyncUserCollectionsRequest",
+    isExported: true,
+    properties: [
+      { name: "slice", type: "string" },
+      { name: "timeoutSeconds", type: "number", hasQuestionToken: true },
+    ],
+  });
+
+  sourceFile.addInterface({
+    name: "SyncUserCollectionsResult",
+    isExported: true,
+    properties: [
+      { name: "success", type: "boolean" },
+      { name: "reposProcessed", type: "number" },
+      { name: "recordsSynced", type: "number" },
+      { name: "timedOut", type: "boolean" },
+      { name: "message", type: "string" },
+    ],
+  });
+
   sourceFile.addInterface({
     name: "JetstreamStatusResponse",
     isExported: true,
···
   }
 }
 
-// Convert NSID to PascalCase
+// Convert NSID to PascalCase (for record types, no "Record" suffix)
 function nsidToPascalCase(nsid: string): string {
   return (
     nsid
···
           .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
           .join("")
       )
-      .join("") + "Record"
+      .join("")
   );
 }
 
···
   } else if (ref.includes("#")) {
     // Cross-lexicon reference: app.bsky.embed.defs#aspectRatio -> AppBskyEmbedDefs["AspectRatio"]
     const [nsid, defName] = ref.split("#");
+    
+    if (defName === "main") {
+      // Find the lexicon and check if it has multiple definitions
+      const lexicon = lexicons.find(lex => lex.id === nsid);
+      if (lexicon && lexicon.definitions) {
+        const defCount = Object.keys(lexicon.definitions).length;
+        const mainDef = lexicon.definitions.main;
+        
+        if (defCount === 1 && mainDef) {
+          // Single definition - use clean name
+          if (mainDef.type === "record") {
+            // For records: AppBskyActorProfile
+            return nsidToPascalCase(nsid);
+          } else {
+            // For objects: ComAtprotoRepoStrongRef
+            return nsidToNamespace(nsid);
+          }
+        } else {
+          // Multiple definitions - use namespace pattern
+          const namespace = nsidToNamespace(nsid);
+          return `${namespace}["Main"]`;
+        }
+      }
+      // Fallback
+      return nsidToNamespace(nsid);
+    }
+    
     const namespace = nsidToNamespace(nsid);
     return `${namespace}["${defNameToPascalCase(defName)}"]`;
   } else {
-    // Direct lexicon reference: app.bsky.richtext.facet -> AppBskyRichtextFacet["Main"]
-    // This refers to the main definition of the lexicon
-    const namespace = nsidToNamespace(ref);
-    return `${namespace}["Main"]`;
+    // Direct lexicon reference: check if single or multiple definitions
+    const lexicon = lexicons.find(lex => lex.id === ref);
+    if (lexicon && lexicon.definitions) {
+      const defCount = Object.keys(lexicon.definitions).length;
+      const mainDef = lexicon.definitions.main;
+      
+      if (defCount === 1 && mainDef) {
+        // Single definition - use clean name
+        if (mainDef.type === "record") {
+          // For records: AppBskyActorProfile
+          return nsidToPascalCase(ref);
+        } else {
+          // For objects: ComAtprotoRepoStrongRef
+          return nsidToNamespace(ref);
+        }
+      } else if (mainDef) {
+        // Multiple definitions - use namespace pattern
+        const namespace = nsidToNamespace(ref);
+        return `${namespace}["Main"]`;
+      }
+    }
+    // Fallback
+    return nsidToNamespace(ref);
   }
 }
 
···
   defValue: any
 ): void {
   const namespace = nsidToNamespace(lexicon.id);
-  const interfaceName = defNameToPascalCase(defKey);
+  
+  // For single-definition lexicons with main, use clean name
+  const defCount = Object.keys(lexicon.definitions).length;
+  const interfaceName = (defKey === "main" && defCount === 1) 
+    ? namespace  // Clean name: ComAtprotoRepoStrongRef
+    : `${namespace}${defNameToPascalCase(defKey)}`; // Multi-def: AppBskyRichtextFacetMention
 
   const properties: Array<{
     name: string;
···
   }
 
   sourceFile.addInterface({
-    name: `${namespace}${interfaceName}`,
+    name: interfaceName,
     isExported: true,
     properties: properties,
   });
···
     }
   }
 
-  // For main records, use the traditional Record suffix naming
+  // For main records, use clean naming without Record suffix
   const interfaceName =
     defKey === "main"
       ? nsidToPascalCase(lexicon.id)
···
           isAsync: true,
           statements: [
             `return await this.makeRequest<JetstreamStatusResponse>('social.slices.slice.getJetstreamStatus', 'GET');`,
+          ],
+        });
+
+        classDeclaration.addMethod({
+          name: "syncUserCollections",
+          parameters: [
+            { name: "params", type: "SyncUserCollectionsRequest", hasQuestionToken: true },
+          ],
+          returnType: "Promise<SyncUserCollectionsResult>",
+          isAsync: true,
+          statements: [
+            `const requestParams = { slice: this.sliceUri, ...params };`,
+            `return await this.makeRequest<SyncUserCollectionsResult>('social.slices.slice.syncUserCollections', 'POST', requestParams);`,
           ],
         });
       }

api/src/database.rs

···
 use crate::errors::DatabaseError;
 use crate::models::{Actor, CollectionStats, IndexedRecord, Record};
 
-// Helper function to get field type from lexicon definition  
+// Helper function to get field type from lexicon definition
 async fn get_field_type_from_lexicon(
-    pool: &sqlx::PgPool, 
-    slice_uri: &str, 
-    collection: &str, 
+    pool: &sqlx::PgPool,
+    slice_uri: &str,
+    collection: &str,
     field: &str
 ) -> Option<String> {
     let lexicon_query = sqlx::query!(
         r#"
         SELECT json->>'definitions' as definitions
-        FROM record 
+        FROM record
         WHERE collection = 'social.slices.lexicon'
-            AND json->>'slice' = $1 
+            AND json->>'slice' = $1
             AND json->>'nsid' = $2
             AND (json->>'definitions')::jsonb->'main'->>'type' = 'record'
         LIMIT 1
···
         slice_uri,
         collection
     );
-    
+
     if let Ok(Some(row)) = lexicon_query.fetch_optional(pool).await {
         if let Some(definitions_str) = &row.definitions {
             if let Ok(definitions) = serde_json::from_str::<serde_json::Value>(definitions_str) {
···
                 .get("record")?
                 .get("properties")?
                 .get(field)?;
-                
+
             // Check if it's a datetime field
             if let Some(field_type) = field_def.get("type").and_then(|t| t.as_str()) {
                 if field_type == "string" {
···
 // Async helper function to parse sort parameter with lexicon type information
 async fn parse_sort_parameter_with_lexicon(
     pool: &sqlx::PgPool,
-    slice_uri: &str, 
+    slice_uri: &str,
     collection: &str,
     sort: Option<&str>
 ) -> String {
···
                         "desc" => "DESC",
                         _ => "ASC", // Default to ASC for any invalid direction
                     };
-                    
+
                     // Validate field name to prevent SQL injection
                     if field.chars().all(|c| c.is_alphanumeric() || c == '_') {
                         if field == "indexed_at" {
···
                         } else {
                             // Get field type from lexicon
                             let field_type = get_field_type_from_lexicon(pool, slice_uri, collection, field).await;
-                            
+
                             if field_type == Some("datetime".to_string()) {
                                 // For datetime fields, use safe casting that handles invalid dates
                                 // This will cast valid dates and return NULL for invalid ones
···
                         "desc" => "DESC",
                         _ => "ASC", // Default to ASC for any invalid direction
                     };
-                    
+
                     // Validate field name to prevent SQL injection
                     if field.chars().all(|c| c.is_alphanumeric() || c == '_') {
                         if field == "indexed_at" {
···
         // Fallback to plain text for backward compatibility
         cursor.to_string()
     };
-    
+
     let parts: Vec<&str> = cursor_content.split("::").collect();
     if parts.len() != 3 {
         return Err("Invalid cursor format".into());
     }
-    
+
     let sort_value = parts[0].to_string();
     let indexed_at = parts[1].parse::<chrono::DateTime<chrono::Utc>>()?;
     let cid = parts[2].to_string();
-    
+
     Ok(ParsedCursor {
         sort_value,
         indexed_at,
···
     // For compound cursor filtering, we use tuple comparison:
     // WHERE (sort_field, indexed_at, cid) < (cursor_sort, cursor_indexed_at, cursor_cid) for DESC
     // WHERE (sort_field, indexed_at, cid) > (cursor_sort, cursor_indexed_at, cursor_cid) for ASC
-    
+
     let comparison_op = if is_desc { "<" } else { ">" };
-    
+
     // Handle different field types for the sort field comparison
     let sort_field_expr = if sort_field == "indexed_at" {
         sort_field.to_string()
···
         // For JSON fields, cast to text for comparison
         format!("json->>'{}'", sort_field)
     };
-    
+
     // Handle NULL values in cursor comparison
     if comparison_op == "<" {
         // For DESC ordering, we want records where:
···
 // Generate cursor from record and sort parameters
 fn generate_cursor_from_record(record: &Record, sort: Option<&str>) -> String {
     let primary_sort_field = get_primary_sort_field(sort);
-    
+
     // Extract sort value from the record based on the sort field
     let sort_value = match primary_sort_field.as_str() {
         "indexed_at" => record.indexed_at.to_rfc3339(),
···
                 .unwrap_or_else(|| "NULL".to_string()) // Use "NULL" string for null values to match SQL NULLS LAST behavior
         }
     };
-    
+
     generate_cursor(&sort_value, record.indexed_at, &record.cid)
 }
 
···
         Ok(())
     }
 
-    pub async fn get_existing_record_cids(&self, did: &str, collection: &str) -> Result<std::collections::HashMap<String, String>, DatabaseError> {
+    pub async fn get_existing_record_cids_for_slice(&self, did: &str, collection: &str, slice_uri: &str) -> Result<std::collections::HashMap<String, String>, DatabaseError> {
         let records = sqlx::query!(
             r#"SELECT "uri", "cid"
                FROM "record"
-               WHERE "did" = $1 AND "collection" = $2"#,
+               WHERE "did" = $1 AND "collection" = $2 AND "slice_uri" = $3"#,
             did,
-            collection
+            collection,
+            slice_uri
         )
         .fetch_all(&self.pool)
         .await?;
···
                 COUNT(DISTINCT r.did) as unique_actors
             FROM record r
             INNER JOIN slice_collections sc ON r.collection = sc.collection_nsid
+            WHERE r.slice_uri = $1
             GROUP BY r.collection
             ORDER BY r.collection
             "#,
···
             SELECT COUNT(*) as count
             FROM record r
             INNER JOIN slice_collections sc ON r.collection = sc.collection_nsid
+            WHERE r.slice_uri = $1
             "#,
             slice_uri
         )
···
         // For lexicon collection, we filter by slice directly
         if collection == "social.slices.lexicon" {
             let order_by = parse_sort_parameter(sort); // Use simple parsing for lexicon collections
-            
+
             // Note: For lexicon searches, authors filtering is not commonly used as lexicons are typically not user-specific
             // But we include it for completeness
             let records = match (cursor, field) {
···
                         let primary_sort_field = get_primary_sort_field(sort);
                         let is_desc = is_primary_sort_desc(sort);
                         let cursor_where_clause = build_cursor_where_clause(&parsed_cursor, &primary_sort_field, is_desc);
-                        
+
                         let query_sql = format!(
                             "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $4 AND json->>'slice' = $5 AND json->>$6 ILIKE '%' || $7 || '%' {} ORDER BY {} LIMIT $8",
                             cursor_where_clause, order_by
···
                 let cursor_dt = cursor_time.parse::<chrono::DateTime<chrono::Utc>>()
                     .unwrap_or_else(|_| chrono::Utc::now());
                 let query_sql = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND json->>$2 ILIKE '%' || $3 || '%' AND indexed_at < $4 ORDER BY {} LIMIT $5",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND json->>$3 ILIKE '%' || $4 || '%' AND indexed_at < $5 ORDER BY {} LIMIT $6",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query_sql)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(field_name)
                     .bind(query)
                     .bind(cursor_dt)
···
                 let cursor_dt = cursor_time.parse::<chrono::DateTime<chrono::Utc>>()
                     .unwrap_or_else(|_| chrono::Utc::now());
                 let query_sql = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND json::text ILIKE '%' || $2 || '%' AND indexed_at < $3 ORDER BY {} LIMIT $4",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND json::text ILIKE '%' || $3 || '%' AND indexed_at < $4 ORDER BY {} LIMIT $5",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query_sql)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(query)
                     .bind(cursor_dt)
                     .bind(limit as i64)
···
             },
             (None, Some(field_name)) => {
                 let query_sql = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND json->>$2 ILIKE '%' || $3 || '%' ORDER BY {} LIMIT $4",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND json->>$3 ILIKE '%' || $4 || '%' ORDER BY {} LIMIT $5",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query_sql)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(field_name)
                     .bind(query)
                     .bind(limit as i64)
···
             },
             (None, None) => {
                 let query_sql = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND json::text ILIKE '%' || $2 || '%' ORDER BY {} LIMIT $3",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND json::text ILIKE '%' || $3 || '%' ORDER BY {} LIMIT $4",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query_sql)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(query)
                     .bind(limit as i64)
                     .fetch_all(&self.pool)
···
         // For lexicon collection, we filter by slice directly
         if collection == "social.slices.lexicon" {
             let order_by = parse_sort_parameter(sort); // Use simple parsing for lexicon collections
-            
-            
+
+
             // Determine the author list to use
             let author_list: Option<Vec<String>> = if let Some(authors_list) = authors {
                 Some(authors_list.clone())
···
                 let cursor_dt = cursor_time.parse::<chrono::DateTime<chrono::Utc>>()
                     .unwrap_or_else(|_| chrono::Utc::now());
                 let query = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND indexed_at < $2 AND did = ANY($3) ORDER BY {} LIMIT $4",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND indexed_at < $3 AND did = ANY($4) ORDER BY {} LIMIT $5",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(cursor_dt)
                     .bind(author_list)
                     .bind(limit as i64)
···
                 let cursor_dt = cursor_time.parse::<chrono::DateTime<chrono::Utc>>()
                     .unwrap_or_else(|_| chrono::Utc::now());
                 let query = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND indexed_at < $2 ORDER BY {} LIMIT $3",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND indexed_at < $3 ORDER BY {} LIMIT $4",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(cursor_dt)
                     .bind(limit as i64)
                     .fetch_all(&self.pool)
···
             },
             (None, Some(author_list)) => {
                 let query = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND did = ANY($2) ORDER BY {} LIMIT $3",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 AND did = ANY($3) ORDER BY {} LIMIT $4",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(author_list)
                     .bind(limit as i64)
                     .fetch_all(&self.pool)
···
             },
             (None, None) => {
                 let query = format!(
-                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 ORDER BY {} LIMIT $2",
+                    "SELECT uri, cid, did, collection, json, indexed_at, slice_uri FROM record WHERE collection = $1 AND slice_uri = $2 ORDER BY {} LIMIT $3",
                     order_by
                 );
                 sqlx::query_as::<_, Record>(&query)
                     .bind(collection)
+                    .bind(slice_uri)
                     .bind(limit as i64)
                     .fetch_all(&self.pool)
                     .await?
···
         "#)
         .fetch_all(&self.pool)
         .await?;
-        
+
         Ok(rows.into_iter().map(|(uri,)| uri).collect())
     }
 
···
         )
         .fetch_all(&self.pool)
         .await?;
-        
+
         Ok(rows.into_iter().map(|row| (row.did, row.slice_uri)).collect())
     }
 
···
         )
         .fetch_optional(&self.pool)
         .await?;
-        
+
         Ok(row.and_then(|r| r.domain))
     }
 

api/src/handler_sync_user_collections.rs

···
+use axum::{
+    extract::State,
+    http::{HeaderMap, StatusCode},
+    response::Json,
+};
+use serde::Deserialize;
+use tracing::{info, warn};
+
+use crate::auth::{extract_bearer_token, verify_oauth_token};
+use crate::sync::{SyncService, SyncUserCollectionsResult};
+use crate::AppState;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncUserCollectionsRequest {
+    pub slice: String,
+    #[serde(default = "default_timeout")]
+    pub timeout_seconds: u64,
+}
+
+fn default_timeout() -> u64 {
+    30 // 30 second default timeout for login scenarios
+}
+
+/// Handler for social.slices.slice.syncUserCollections
+/// Synchronously syncs external collections for the authenticated user with timeout protection
+/// Automatically discovers external collections based on the slice's domain configuration
+pub async fn sync_user_collections(
+    State(state): State<AppState>,
+    headers: HeaderMap,
+    Json(request): Json<SyncUserCollectionsRequest>,
+) -> Result<Json<SyncUserCollectionsResult>, (StatusCode, Json<serde_json::Value>)> {
+    // Extract and verify OAuth token
+    let token = extract_bearer_token(&headers).map_err(|e| {
+        (StatusCode::UNAUTHORIZED, Json(serde_json::json!({
+            "error": "AuthenticationRequired",
+            "message": format!("Bearer token required: {}", e)
+        })))
+    })?;
+
+    let user_info = verify_oauth_token(&token, &state.config.auth_base_url).await
+        .map_err(|e| {
+            (StatusCode::UNAUTHORIZED, Json(serde_json::json!({
+                "error": "InvalidToken",
+                "message": format!("Token verification failed: {}", e)
+            })))
+        })?;
+
+    let user_did = user_info.did.unwrap_or(user_info.sub);
+    
+    info!(
+        "🔄 Starting user collections sync for {} on slice {} (timeout: {}s)",
+        user_did, request.slice, request.timeout_seconds
+    );
+
+    // Validate timeout (max 5 minutes for sync operations)
+    if request.timeout_seconds > 300 {
+        return Err((StatusCode::BAD_REQUEST, Json(serde_json::json!({
+            "error": "InvalidTimeout",
+            "message": "Maximum timeout is 300 seconds (5 minutes)"
+        }))));
+    }
+
+    // Create sync service
+    let sync_service = SyncService::new(state.database.clone(), state.config.relay_endpoint.clone());
+    
+    // Perform timeout-protected sync with auto-discovered external collections
+    match sync_service.sync_user_collections(
+        &user_did,
+        &request.slice,
+        request.timeout_seconds,
+    ).await {
+        Ok(result) => {
+            if result.timed_out {
+                info!(
+                    "⏰ Sync timed out for user {}, suggesting async job",
+                    user_did
+                );
+            } else {
+                info!(
+                    "✅ Sync completed for user {}: {} repos, {} records",
+                    user_did, result.repos_processed, result.records_synced
+                );
+            }
+            Ok(Json(result))
+        },
+        Err(e) => {
+            warn!("❌ Sync failed for user {}: {}", user_did, e);
+            Err((StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({
+                "error": "SyncFailed",
+                "message": format!("Sync operation failed: {}", e)
+            }))))
+        }
+    }
+}

api/src/handler_xrpc_dynamic.rs

···
     let mut manual_params = DynamicListParams {
         author: params.get("author").and_then(|v| v.as_str()).map(|s| s.to_string()),
         authors: None,
-        limit: params.get("limit").and_then(|v| v.as_i64()).map(|i| i as i32),
+        limit: params.get("limit").and_then(|v| {
+            if let Some(s) = v.as_str() {
+                s.parse::<i32>().ok()
+            } else {
+                v.as_i64().map(|i| i as i32)
+            }
+        }),
         cursor: params.get("cursor").and_then(|v| v.as_str()).map(|s| s.to_string()),
         slice: params.get("slice").and_then(|v| v.as_str()).ok_or(StatusCode::BAD_REQUEST)?.to_string(),
         sort: params.get("sort").and_then(|v| v.as_str()).map(|s| s.to_string()),
···
     state: AppState,
     params: serde_json::Value,
 ) -> Result<Json<serde_json::Value>, StatusCode> {
-    let search_params: DynamicSearchParams = serde_json::from_value(params)
-        .map_err(|_| StatusCode::BAD_REQUEST)?;
+    // Manual parameter extraction to handle string/number conversion
+    let search_params = DynamicSearchParams {
+        slice: params.get("slice").and_then(|v| v.as_str()).ok_or(StatusCode::BAD_REQUEST)?.to_string(),
+        query: params.get("query").and_then(|v| v.as_str()).ok_or(StatusCode::BAD_REQUEST)?.to_string(),
+        field: params.get("field").and_then(|v| v.as_str()).map(|s| s.to_string()),
+        limit: params.get("limit").and_then(|v| {
+            if let Some(s) = v.as_str() {
+                s.parse::<i32>().ok()
+            } else {
+                v.as_i64().map(|i| i as i32)
+            }
+        }),
+        cursor: params.get("cursor").and_then(|v| v.as_str()).map(|s| s.to_string()),
+        sort: params.get("sort").and_then(|v| v.as_str()).map(|s| s.to_string()),
+    };
 
     // Use slice-aware search method that filters by collection belonging to the slice
     match state.database.search_slice_collection_records(

api/src/main.rs

···
 mod handler_records;
 mod handler_stats;
 mod handler_sync;
+mod handler_sync_user_collections;
 mod handler_upload_blob;
 mod handler_xrpc_codegen;
 mod handler_xrpc_dynamic;
···
         .route(
             "/xrpc/social.slices.slice.startSync",
             post(handler_sync::sync),
+        )
+        .route(
+            "/xrpc/social.slices.slice.syncUserCollections",
+            post(handler_sync_user_collections::sync_user_collections),
         )
         .route(
             "/xrpc/social.slices.slice.getJobStatus",

api/src/sync.rs

···
 use chrono::{Utc};
 use reqwest::Client;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use tokio::time::{timeout, Duration};
 use tracing::{debug, error, info, warn};
 use atproto_identity::{
     plc::query as plc_query,
···
     did: String,
     pds: String,
     handle: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SyncUserCollectionsResult {
+    pub success: bool,
+    pub repos_processed: i64,
+    pub records_synced: i64,
+    pub timed_out: bool,
+    pub message: String,
 }
 
 #[derive(Clone)]
···
     }
 
     async fn fetch_records_for_repo_collection(&self, repo: &str, collection: &str, pds_url: &str, slice_uri: &str) -> Result<Vec<Record>, SyncError> {
-        // First, get existing record CIDs from database
-        let existing_cids = self.database.get_existing_record_cids(repo, collection)
+        // First, get existing record CIDs from database for this specific slice
+        let existing_cids = self.database.get_existing_record_cids_for_slice(repo, collection, slice_uri)
             .await
             .map_err(|e| SyncError::Generic(format!("Failed to get existing CIDs: {}", e)))?;
 
···
         let mut cache = self.atp_cache.lock().unwrap();
         cache.clear();
     }
+
+    /// Get external collections for a slice (collections that don't start with the slice's domain)
+    async fn get_external_collections_for_slice(&self, slice_uri: &str) -> Result<Vec<String>, SyncError> {
+        // Get the slice's domain
+        let domain = self.database.get_slice_domain(slice_uri).await
+            .map_err(|e| SyncError::Generic(format!("Failed to get slice domain: {}", e)))?
+            .ok_or_else(|| SyncError::Generic(format!("Slice not found: {}", slice_uri)))?;
+        
+        // Get all collections (lexicons) for this slice
+        let collections = self.database.get_slice_collections_list(slice_uri).await
+            .map_err(|e| SyncError::Generic(format!("Failed to get slice collections: {}", e)))?;
+        
+        // Filter for external collections (those that don't start with the slice domain)
+        let external_collections: Vec<String> = collections
+            .into_iter()
+            .filter(|collection| !collection.starts_with(&domain))
+            .collect();
+        
+        info!("🔍 Found {} external collections for slice {} (domain: {}): {:?}", 
+              external_collections.len(), slice_uri, domain, external_collections);
+        
+        Ok(external_collections)
+    }
+
+    /// Sync user's data for all external collections defined in the slice
+    /// Automatically discovers which collections to sync based on slice configuration
+    /// Uses timeout protection to ensure responsive login flows
+    pub async fn sync_user_collections(
+        &self,
+        user_did: &str,
+        slice_uri: &str,
+        timeout_secs: u64,
+    ) -> Result<SyncUserCollectionsResult, SyncError> {
+        info!("🔎 Auto-discovering external collections for user {} in slice {}", user_did, slice_uri);
+        
+        // Auto-discover external collections from slice configuration
+        let external_collections = self.get_external_collections_for_slice(slice_uri).await?;
+        
+        if external_collections.is_empty() {
+            info!("ℹ️ No external collections found for slice {}", slice_uri);
+            return Ok(SyncUserCollectionsResult {
+                success: true,
+                repos_processed: 0,
+                records_synced: 0,
+                timed_out: false,
+                message: "No external collections to sync".to_string(),
+            });
+        }
+        
+        info!("📋 Syncing {} external collections for user {}: {:?}", 
+              external_collections.len(), user_did, external_collections);
+        
+        // Use backfill_collections with timeout protection, but only for this specific user
+        let sync_future = async {
+            self.backfill_collections(
+                slice_uri,
+                None, // No primary collections for user sync
+                Some(&external_collections),
+                Some(&[user_did.to_string()]), // Only sync this user's repos
+            ).await
+        };
+        
+        match timeout(Duration::from_secs(timeout_secs), sync_future).await {
+            Ok(result) => {
+                let (repos_processed, records_synced) = result?;
+                info!("✅ User sync completed within timeout: {} repos, {} records", repos_processed, records_synced);
+                Ok(SyncUserCollectionsResult {
+                    success: true,
+                    repos_processed,
+                    records_synced,
+                    timed_out: false,
+                    message: format!("Sync completed: {} repos, {} records", repos_processed, records_synced),
+                })
+            },
+            Err(_) => {
+                // Timeout occurred - return partial success with guidance
+                warn!("⏰ Sync for user {} timed out after {}s, suggest using async job", user_did, timeout_secs);
+                Ok(SyncUserCollectionsResult {
+                    success: false,
+                    repos_processed: 0,
+                    records_synced: 0,
+                    timed_out: true,
+                    message: format!("Sync timed out after {}s - use startSync endpoint for larger syncs", timeout_secs),
+                })
+            }
+        }
+    }
+
 }

frontend/src/client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-08-29 21:39:46 UTC
-// Lexicons: 3
+// Generated at: 2025-08-30 17:33:35 UTC
+// Lexicons: 6
 
 /**
  * @example Usage
···
  *
  * const client = new AtProtoClient(
  *   'https://slices-api.fly.dev',
- *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lx5zq4t56s2q'
+ *   'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lwzmbjpqxk2q'
  * );
  *
- * // List records from a slice
- * const slices = await client.social.slices.slice.listRecords();
+ * // List records from the app.bsky.actor.profile collection
+ * const records = await client.app.bsky.actor.profile.listRecords();
+ *
+ * // Get a specific record
+ * const record = await client.app.bsky.actor.profile.getRecord({
+ *   uri: 'at://did:plc:example/app.bsky.actor.profile/3abc123'
+ * });
+ *
+ * // Search records in the collection
+ * const searchResults = await client.app.bsky.actor.profile.searchRecords({
+ *   query: "example search term"
+ * });
  *
- * // Get slice statistics
- * const stats = await client.social.slices.slice.stats({
- *   slice: 'at://did:plc:bcgltzqazw5tb6k2g3ttenbj/social.slices.slice/3lx5zq4t56s2q'
+ * // Search specific field
+ * const fieldSearch = await client.app.bsky.actor.profile.searchRecords({
+ *   query: "blog",
+ *   field: "title"
  * });
  *
- * // Serve the slice names as JSON
- * Deno.serve(async () => new Response(JSON.stringify(slices.records.map(r => r.value.name))));
+ * // Serve the records as JSON
+ * Deno.serve(async () => new Response(JSON.stringify(records.records.map(r => r.value))));
  * ```
  */
 
···
 
 export type GetJobHistoryResponse = JobStatus[];
 
+export interface SyncUserCollectionsRequest {
+  slice: string;
+  timeoutSeconds?: number;
+}
+
+export interface SyncUserCollectionsResult {
+  success: boolean;
+  reposProcessed: number;
+  recordsSynced: number;
+  timedOut: boolean;
+  message: string;
+}
+
 export interface JetstreamStatusResponse {
   connected: boolean;
   status: string;
···
   searchRecords(params: SearchRecordsParams): Promise<ListRecordsResponse<T>>;
 }
 
-export interface SocialSlicesSliceRecord {
-  /** Name of the slice */
+export interface ComAtprotoLabelDefsLabel {
+  /** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
+  cid?: string;
+  /** Timestamp when this label was created. */
+  cts: string;
+  /** Timestamp at which this label expires (no longer applies). */
+  exp?: string;
+  /** If true, this is a negation label, overwriting a previous label. */
+  neg?: boolean;
+  /** Signature of dag-cbor encoded label. */
+  sig?: string;
+  /** DID of the actor who created this label. */
+  src: string;
+  /** AT URI of the record, repository (account), or other resource that this label applies to. */
+  uri: string;
+  /** The short string name of the value or type of this label. */
+  val: string;
+  /** The AT Protocol version of the label object. */
+  ver?: number;
+}
+
+export interface ComAtprotoLabelDefsLabelValueDefinition {
+  /** Does the user need to have adult content enabled in order to configure this label? */
+  adultOnly?: boolean;
+  /** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */
+  blurs: string;
+  /** The default setting for this label. */
+  defaultSetting?: string;
+  /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */
+  identifier: string;
+  locales: ComAtprotoLabelDefs["LabelValueDefinitionStrings"][];
+  /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
+  severity: string;
+}
+
+export interface ComAtprotoLabelDefsLabelValueDefinitionStrings {
+  /** A longer description of what the label means and why it might be applied. */
+  description: string;
+  /** The code of the language these strings are written in. */
+  lang: string;
+  /** A short human-readable name for the label. */
   name: string;
-  /** Primary domain namespace for this slice (e.g. social.grain) */
-  domain: string;
-  /** When the slice was created */
-  createdAt: string;
 }
 
-export type SocialSlicesSliceRecordSortFields = "name" | "domain" | "createdAt";
+export interface ComAtprotoLabelDefsSelfLabel {
+  /** The short string name of the value or type of this label. */
+  val: string;
+}
 
-export interface SocialSlicesLexiconRecord {
-  /** Namespaced identifier for the lexicon */
-  nsid: string;
-  /** The lexicon schema definitions as JSON */
-  definitions: string;
-  /** When the lexicon was created */
-  createdAt: string;
-  /** When the lexicon was last updated */
-  updatedAt?: string;
-  /** AT-URI reference to the slice this lexicon belongs to */
-  slice: string;
+export interface ComAtprotoLabelDefsSelfLabels {
+  values: ComAtprotoLabelDefs["SelfLabel"][];
 }
 
-export type SocialSlicesLexiconRecordSortFields =
-  | "nsid"
-  | "definitions"
-  | "createdAt"
-  | "updatedAt"
-  | "slice";
+export interface ComAtprotoRepoStrongRef {
+  cid: string;
+  uri: string;
+}
 
-export interface SocialSlicesActorProfileRecord {
-  displayName?: string;
+export interface AppBskyActorProfile {
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef;
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef;
+  createdAt?: string;
   /** Free-form profile description text. */
   description?: string;
+  displayName?: string;
+  joinedViaStarterPack?: ComAtprotoRepoStrongRef;
+  /** Self-label values, specific to the Bluesky application, on the overall account. */
+  labels?:
+    | ComAtprotoLabelDefs["SelfLabels"]
+    | {
+        $type: string;
+        [key: string]: unknown;
+      };
+  pinnedPost?: ComAtprotoRepoStrongRef;
+}
+
+export type AppBskyActorProfileSortFields =
+  | "createdAt"
+  | "description"
+  | "displayName";
+
+export interface SocialSlicesActorProfile {
   /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
   avatar?: BlobRef;
   createdAt?: string;
+  /** Free-form profile description text. */
+  description?: string;
+  displayName?: string;
 }
 
-export type SocialSlicesActorProfileRecordSortFields =
-  | "displayName"
+export type SocialSlicesActorProfileSortFields =
+  | "createdAt"
   | "description"
-  | "createdAt";
+  | "displayName";
+
+export interface SocialSlicesLexicon {
+  /** When the lexicon was created */
+  createdAt: string;
+  /** The lexicon schema definitions as JSON */
+  definitions: string;
+  /** Namespaced identifier for the lexicon */
+  nsid: string;
+  /** AT-URI reference to the slice this lexicon belongs to */
+  slice: string;
+  /** When the lexicon was last updated */
+  updatedAt?: string;
+}
+
+export type SocialSlicesLexiconSortFields =
+  | "createdAt"
+  | "definitions"
+  | "nsid"
+  | "slice"
+  | "updatedAt";
+
+export interface SocialSlicesSlice {
+  /** When the slice was created */
+  createdAt: string;
+  /** Name of the slice */
+  name: string;
+}
+
+export type SocialSlicesSliceSortFields = "createdAt" | "name";
+
+export interface ComAtprotoLabelDefs {
+  readonly Label: ComAtprotoLabelDefsLabel;
+  readonly LabelValueDefinition: ComAtprotoLabelDefsLabelValueDefinition;
+  readonly LabelValueDefinitionStrings: ComAtprotoLabelDefsLabelValueDefinitionStrings;
+  readonly SelfLabel: ComAtprotoLabelDefsSelfLabel;
+  readonly SelfLabels: ComAtprotoLabelDefsSelfLabels;
+}
 
 class BaseClient {
   protected readonly baseUrl: string;
···
   }
 }
 
-class SliceSlicesSocialClient extends BaseClient {
+class ProfileActorBskyAppClient extends BaseClient {
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
···
   }
 
   async listRecords(
-    params?: ListRecordsParams<SocialSlicesSliceRecordSortFields>
-  ): Promise<ListRecordsResponse<SocialSlicesSliceRecord>> {
+    params?: ListRecordsParams<AppBskyActorProfileSortFields>
+  ): Promise<ListRecordsResponse<AppBskyActorProfile>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<ListRecordsResponse<SocialSlicesSliceRecord>>(
-      "social.slices.slice.listRecords",
+    return await this.makeRequest<ListRecordsResponse<AppBskyActorProfile>>(
+      "app.bsky.actor.profile.listRecords",
       "GET",
       requestParams
     );
···
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<SocialSlicesSliceRecord>> {
+  ): Promise<RecordResponse<AppBskyActorProfile>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<SocialSlicesSliceRecord>>(
-      "social.slices.slice.getRecord",
+    return await this.makeRequest<RecordResponse<AppBskyActorProfile>>(
+      "app.bsky.actor.profile.getRecord",
       "GET",
       requestParams
     );
   }
 
   async searchRecords(
-    params: SearchRecordsParams<SocialSlicesSliceRecordSortFields>
-  ): Promise<ListRecordsResponse<SocialSlicesSliceRecord>> {
+    params: SearchRecordsParams<AppBskyActorProfileSortFields>
+  ): Promise<ListRecordsResponse<AppBskyActorProfile>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<ListRecordsResponse<SocialSlicesSliceRecord>>(
-      "social.slices.slice.searchRecords",
+    return await this.makeRequest<ListRecordsResponse<AppBskyActorProfile>>(
+      "app.bsky.actor.profile.searchRecords",
       "GET",
       requestParams
     );
   }
 
   async createRecord(
-    record: SocialSlicesSliceRecord,
+    record: AppBskyActorProfile,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.slice", ...record };
+    const recordValue = { $type: "app.bsky.actor.profile", ...record };
     const payload = {
       slice: this.sliceUri,
       ...(useSelfRkey ? { rkey: "self" } : {}),
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.slice.createRecord",
+      "app.bsky.actor.profile.createRecord",
       "POST",
       payload
     );
···
 
   async updateRecord(
     rkey: string,
-    record: SocialSlicesSliceRecord
+    record: AppBskyActorProfile
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.slice", ...record };
+    const recordValue = { $type: "app.bsky.actor.profile", ...record };
     const payload = {
       slice: this.sliceUri,
       rkey,
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.slice.updateRecord",
+      "app.bsky.actor.profile.updateRecord",
       "POST",
       payload
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.makeRequest<void>(
-      "social.slices.slice.deleteRecord",
+      "app.bsky.actor.profile.deleteRecord",
       "POST",
       { rkey }
     );
   }
+}
+
+class ActorBskyAppClient extends BaseClient {
+  readonly profile: ProfileActorBskyAppClient;
+  private readonly sliceUri: string;
 
-  async codegen(request: CodegenXrpcRequest): Promise<CodegenXrpcResponse> {
-    return await this.makeRequest<CodegenXrpcResponse>(
-      "social.slices.slice.codegen",
-      "POST",
-      request
+  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
+    super(baseUrl, oauthClient);
+    this.sliceUri = sliceUri;
+    this.profile = new ProfileActorBskyAppClient(
+      baseUrl,
+      sliceUri,
+      oauthClient
     );
   }
+}
+
+class BskyAppClient extends BaseClient {
+  readonly actor: ActorBskyAppClient;
+  private readonly sliceUri: string;
 
-  async stats(params: SliceStatsParams): Promise<SliceStatsOutput> {
-    return await this.makeRequest<SliceStatsOutput>(
-      "social.slices.slice.stats",
-      "POST",
-      params
-    );
+  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
+    super(baseUrl, oauthClient);
+    this.sliceUri = sliceUri;
+    this.actor = new ActorBskyAppClient(baseUrl, sliceUri, oauthClient);
+  }
+}
+
+class AppClient extends BaseClient {
+  readonly bsky: BskyAppClient;
+  private readonly sliceUri: string;
+
+  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
+    super(baseUrl, oauthClient);
+    this.sliceUri = sliceUri;
+    this.bsky = new BskyAppClient(baseUrl, sliceUri, oauthClient);
+  }
+}
+
+class ProfileActorSlicesSocialClient extends BaseClient {
+  private readonly sliceUri: string;
+
+  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
+    super(baseUrl, oauthClient);
+    this.sliceUri = sliceUri;
   }
 
-  async records(params: SliceRecordsParams): Promise<SliceRecordsOutput> {
-    return await this.makeRequest<SliceRecordsOutput>(
-      "social.slices.slice.records",
-      "POST",
-      params
-    );
+  async listRecords(
+    params?: ListRecordsParams<SocialSlicesActorProfileSortFields>
+  ): Promise<ListRecordsResponse<SocialSlicesActorProfile>> {
+    const requestParams = { ...params, slice: this.sliceUri };
+    return await this.makeRequest<
+      ListRecordsResponse<SocialSlicesActorProfile>
+    >("social.slices.actor.profile.listRecords", "GET", requestParams);
   }
 
-  async getActors(params?: GetActorsParams): Promise<GetActorsResponse> {
+  async getRecord(
+    params: GetRecordParams
+  ): Promise<RecordResponse<SocialSlicesActorProfile>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<GetActorsResponse>(
-      "social.slices.slice.getActors",
+    return await this.makeRequest<RecordResponse<SocialSlicesActorProfile>>(
+      "social.slices.actor.profile.getRecord",
       "GET",
       requestParams
     );
   }
 
-  async startSync(params: BulkSyncParams): Promise<SyncJobResponse> {
+  async searchRecords(
+    params: SearchRecordsParams<SocialSlicesActorProfileSortFields>
+  ): Promise<ListRecordsResponse<SocialSlicesActorProfile>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<SyncJobResponse>(
-      "social.slices.slice.startSync",
+    return await this.makeRequest<
+      ListRecordsResponse<SocialSlicesActorProfile>
+    >("social.slices.actor.profile.searchRecords", "GET", requestParams);
+  }
+
+  async createRecord(
+    record: SocialSlicesActorProfile,
+    useSelfRkey?: boolean
+  ): Promise<{ uri: string; cid: string }> {
+    const recordValue = { $type: "social.slices.actor.profile", ...record };
+    const payload = {
+      slice: this.sliceUri,
+      ...(useSelfRkey ? { rkey: "self" } : {}),
+      record: recordValue,
+    };
+    return await this.makeRequest<{ uri: string; cid: string }>(
+      "social.slices.actor.profile.createRecord",
       "POST",
-      requestParams
+      payload
     );
   }
 
-  async getJobStatus(params: GetJobStatusParams): Promise<JobStatus> {
-    return await this.makeRequest<JobStatus>(
-      "social.slices.slice.getJobStatus",
-      "GET",
-      params
+  async updateRecord(
+    rkey: string,
+    record: SocialSlicesActorProfile
+  ): Promise<{ uri: string; cid: string }> {
+    const recordValue = { $type: "social.slices.actor.profile", ...record };
+    const payload = {
+      slice: this.sliceUri,
+      rkey,
+      record: recordValue,
+    };
+    return await this.makeRequest<{ uri: string; cid: string }>(
+      "social.slices.actor.profile.updateRecord",
+      "POST",
+      payload
     );
   }
 
-  async getJobHistory(
-    params: GetJobHistoryParams
-  ): Promise<GetJobHistoryResponse> {
-    return await this.makeRequest<GetJobHistoryResponse>(
-      "social.slices.slice.getJobHistory",
-      "GET",
-      params
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.makeRequest<void>(
+      "social.slices.actor.profile.deleteRecord",
+      "POST",
+      { rkey }
     );
   }
+}
+
+class ActorSlicesSocialClient extends BaseClient {
+  readonly profile: ProfileActorSlicesSocialClient;
+  private readonly sliceUri: string;
 
-  async getJetstreamStatus(): Promise<JetstreamStatusResponse> {
-    return await this.makeRequest<JetstreamStatusResponse>(
-      "social.slices.slice.getJetstreamStatus",
-      "GET"
+  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
+    super(baseUrl, oauthClient);
+    this.sliceUri = sliceUri;
+    this.profile = new ProfileActorSlicesSocialClient(
+      baseUrl,
+      sliceUri,
+      oauthClient
     );
   }
 }
···
   }
 
   async listRecords(
-    params?: ListRecordsParams<SocialSlicesLexiconRecordSortFields>
-  ): Promise<ListRecordsResponse<SocialSlicesLexiconRecord>> {
+    params?: ListRecordsParams<SocialSlicesLexiconSortFields>
+  ): Promise<ListRecordsResponse<SocialSlicesLexicon>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<
-      ListRecordsResponse<SocialSlicesLexiconRecord>
-    >("social.slices.lexicon.listRecords", "GET", requestParams);
+    return await this.makeRequest<ListRecordsResponse<SocialSlicesLexicon>>(
+      "social.slices.lexicon.listRecords",
+      "GET",
+      requestParams
+    );
   }
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<SocialSlicesLexiconRecord>> {
+  ): Promise<RecordResponse<SocialSlicesLexicon>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<RecordResponse<SocialSlicesLexiconRecord>>(
+    return await this.makeRequest<RecordResponse<SocialSlicesLexicon>>(
       "social.slices.lexicon.getRecord",
       "GET",
       requestParams
···
   }
 
   async searchRecords(
-    params: SearchRecordsParams<SocialSlicesLexiconRecordSortFields>
-  ): Promise<ListRecordsResponse<SocialSlicesLexiconRecord>> {
+    params: SearchRecordsParams<SocialSlicesLexiconSortFields>
+  ): Promise<ListRecordsResponse<SocialSlicesLexicon>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<
-      ListRecordsResponse<SocialSlicesLexiconRecord>
-    >("social.slices.lexicon.searchRecords", "GET", requestParams);
+    return await this.makeRequest<ListRecordsResponse<SocialSlicesLexicon>>(
+      "social.slices.lexicon.searchRecords",
+      "GET",
+      requestParams
+    );
   }
 
   async createRecord(
-    record: SocialSlicesLexiconRecord,
+    record: SocialSlicesLexicon,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
     const recordValue = { $type: "social.slices.lexicon", ...record };
···
 
   async updateRecord(
     rkey: string,
-    record: SocialSlicesLexiconRecord
+    record: SocialSlicesLexicon
   ): Promise<{ uri: string; cid: string }> {
     const recordValue = { $type: "social.slices.lexicon", ...record };
     const payload = {
···
   }
 }
 
-class ProfileActorSlicesSocialClient extends BaseClient {
+class SliceSlicesSocialClient extends BaseClient {
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
···
   }
 
   async listRecords(
-    params?: ListRecordsParams<SocialSlicesActorProfileRecordSortFields>
-  ): Promise<ListRecordsResponse<SocialSlicesActorProfileRecord>> {
+    params?: ListRecordsParams<SocialSlicesSliceSortFields>
+  ): Promise<ListRecordsResponse<SocialSlicesSlice>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<
-      ListRecordsResponse<SocialSlicesActorProfileRecord>
-    >("social.slices.actor.profile.listRecords", "GET", requestParams);
+    return await this.makeRequest<ListRecordsResponse<SocialSlicesSlice>>(
+      "social.slices.slice.listRecords",
+      "GET",
+      requestParams
+    );
   }
 
   async getRecord(
     params: GetRecordParams
-  ): Promise<RecordResponse<SocialSlicesActorProfileRecord>> {
+  ): Promise<RecordResponse<SocialSlicesSlice>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<
-      RecordResponse<SocialSlicesActorProfileRecord>
-    >("social.slices.actor.profile.getRecord", "GET", requestParams);
+    return await this.makeRequest<RecordResponse<SocialSlicesSlice>>(
+      "social.slices.slice.getRecord",
+      "GET",
+      requestParams
+    );
   }
 
   async searchRecords(
-    params: SearchRecordsParams<SocialSlicesActorProfileRecordSortFields>
-  ): Promise<ListRecordsResponse<SocialSlicesActorProfileRecord>> {
+    params: SearchRecordsParams<SocialSlicesSliceSortFields>
+  ): Promise<ListRecordsResponse<SocialSlicesSlice>> {
     const requestParams = { ...params, slice: this.sliceUri };
-    return await this.makeRequest<
-      ListRecordsResponse<SocialSlicesActorProfileRecord>
-    >("social.slices.actor.profile.searchRecords", "GET", requestParams);
+    return await this.makeRequest<ListRecordsResponse<SocialSlicesSlice>>(
+      "social.slices.slice.searchRecords",
+      "GET",
+      requestParams
+    );
   }
 
   async createRecord(
-    record: SocialSlicesActorProfileRecord,
+    record: SocialSlicesSlice,
     useSelfRkey?: boolean
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.actor.profile", ...record };
+    const recordValue = { $type: "social.slices.slice", ...record };
     const payload = {
       slice: this.sliceUri,
       ...(useSelfRkey ? { rkey: "self" } : {}),
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.actor.profile.createRecord",
+      "social.slices.slice.createRecord",
       "POST",
       payload
     );
···
 
   async updateRecord(
     rkey: string,
-    record: SocialSlicesActorProfileRecord
+    record: SocialSlicesSlice
   ): Promise<{ uri: string; cid: string }> {
-    const recordValue = { $type: "social.slices.actor.profile", ...record };
+    const recordValue = { $type: "social.slices.slice", ...record };
     const payload = {
       slice: this.sliceUri,
       rkey,
       record: recordValue,
     };
     return await this.makeRequest<{ uri: string; cid: string }>(
-      "social.slices.actor.profile.updateRecord",
+      "social.slices.slice.updateRecord",
       "POST",
       payload
     );
···
 
   async deleteRecord(rkey: string): Promise<void> {
     return await this.makeRequest<void>(
-      "social.slices.actor.profile.deleteRecord",
+      "social.slices.slice.deleteRecord",
       "POST",
       { rkey }
     );
   }
-}
+
+  async codegen(request: CodegenXrpcRequest): Promise<CodegenXrpcResponse> {
+    return await this.makeRequest<CodegenXrpcResponse>(
+      "social.slices.slice.codegen",
+      "POST",
+      request
+    );
+  }
+
+  async stats(params: SliceStatsParams): Promise<SliceStatsOutput> {
+    return await this.makeRequest<SliceStatsOutput>(
+      "social.slices.slice.stats",
+      "POST",
+      params
+    );
+  }
+
+  async records(params: SliceRecordsParams): Promise<SliceRecordsOutput> {
+    return await this.makeRequest<SliceRecordsOutput>(
+      "social.slices.slice.records",
+      "POST",
+      params
+    );
+  }
+
+  async getActors(params?: GetActorsParams): Promise<GetActorsResponse> {
+    const requestParams = { ...params, slice: this.sliceUri };
+    return await this.makeRequest<GetActorsResponse>(
+      "social.slices.slice.getActors",
+      "GET",
+      requestParams
+    );
+  }
 
-class ActorSlicesSocialClient extends BaseClient {
-  readonly profile: ProfileActorSlicesSocialClient;
-  private readonly sliceUri: string;
+  async startSync(params: BulkSyncParams): Promise<SyncJobResponse> {
+    const requestParams = { ...params, slice: this.sliceUri };
+    return await this.makeRequest<SyncJobResponse>(
+      "social.slices.slice.startSync",
+      "POST",
+      requestParams
+    );
+  }
 
-  constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
-    super(baseUrl, oauthClient);
-    this.sliceUri = sliceUri;
-    this.profile = new ProfileActorSlicesSocialClient(
-      baseUrl,
-      sliceUri,
-      oauthClient
+  async getJobStatus(params: GetJobStatusParams): Promise<JobStatus> {
+    return await this.makeRequest<JobStatus>(
+      "social.slices.slice.getJobStatus",
+      "GET",
+      params
+    );
+  }
+
+  async getJobHistory(
+    params: GetJobHistoryParams
+  ): Promise<GetJobHistoryResponse> {
+    return await this.makeRequest<GetJobHistoryResponse>(
+      "social.slices.slice.getJobHistory",
+      "GET",
+      params
+    );
+  }
+
+  async getJetstreamStatus(): Promise<JetstreamStatusResponse> {
+    return await this.makeRequest<JetstreamStatusResponse>(
+      "social.slices.slice.getJetstreamStatus",
+      "GET"
+    );
+  }
+
+  async syncUserCollections(
+    params?: SyncUserCollectionsRequest
+  ): Promise<SyncUserCollectionsResult> {
+    const requestParams = { slice: this.sliceUri, ...params };
+    return await this.makeRequest<SyncUserCollectionsResult>(
+      "social.slices.slice.syncUserCollections",
+      "POST",
+      requestParams
     );
   }
 }
 
 class SlicesSocialClient extends BaseClient {
+  readonly actor: ActorSlicesSocialClient;
+  readonly lexicon: LexiconSlicesSocialClient;
   readonly slice: SliceSlicesSocialClient;
-  readonly lexicon: LexiconSlicesSocialClient;
-  readonly actor: ActorSlicesSocialClient;
   private readonly sliceUri: string;
 
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
     super(baseUrl, oauthClient);
     this.sliceUri = sliceUri;
-    this.slice = new SliceSlicesSocialClient(baseUrl, sliceUri, oauthClient);
+    this.actor = new ActorSlicesSocialClient(baseUrl, sliceUri, oauthClient);
     this.lexicon = new LexiconSlicesSocialClient(
       baseUrl,
       sliceUri,
       oauthClient
     );
-    this.actor = new ActorSlicesSocialClient(baseUrl, sliceUri, oauthClient);
+    this.slice = new SliceSlicesSocialClient(baseUrl, sliceUri, oauthClient);
   }
 }
 
···
 }
 
 export class AtProtoClient extends BaseClient {
+  readonly app: AppClient;
   readonly social: SocialClient;
   readonly oauth?: OAuthClient;
   private readonly sliceUri: string;
···
   constructor(baseUrl: string, sliceUri: string, oauthClient?: OAuthClient) {
     super(baseUrl, oauthClient);
     this.sliceUri = sliceUri;
+    this.app = new AppClient(baseUrl, sliceUri, oauthClient);
     this.social = new SocialClient(baseUrl, sliceUri, oauthClient);
     this.oauth = this.oauthClient;
   }

frontend/src/routes/oauth.ts

···
 
     // Create OAuth session with auto token management
     const sessionId = await oauthSessions.createOAuthSession();
-    
+
     if (!sessionId) {
       return Response.redirect(
         new URL(
···
     // Create session cookie
     const sessionCookie = sessionStore.createSessionCookie(sessionId);
 
+    // Sync external collections if user doesn't have them yet
+    try {
+      // Get user info from OAuth session
+      const userInfo = await atprotoClient.oauth?.getUserInfo();
+      if (!userInfo?.sub) {
+        console.log(
+          "No user DID available, skipping external collections sync"
+        );
+      } else {
+        // Check if user already has bsky profile synced
+        try {
+          const profileCheck =
+            await atprotoClient.app.bsky.actor.profile.listRecords({
+              authors: [userInfo.sub],
+              limit: 1,
+            });
+
+          // If we can't find existing records, sync them
+          if (!profileCheck.records || profileCheck.records.length === 0) {
+            console.log("No existing external collections found, syncing...");
+            await atprotoClient.social.slices.slice.syncUserCollections();
+          } else {
+            console.log("External collections already synced, skipping sync");
+          }
+        } catch (_profileError) {
+          // If we can't check existing records, skip sync to be safe
+          console.log(
+            "Could not check existing external collections, skipping sync"
+          );
+        }
+      }
+    } catch (error) {
+      console.log(
+        "Error during sync check, skipping external collections sync:",
+        error
+      );
+    }
+
     return new Response(null, {
       status: 302,
       headers: {
···
 async function handleLogout(req: Request): Promise<Response> {
   // Get session from request
   const session = await sessionStore.getSessionFromRequest(req);
-  
+
   if (session) {
     // Use OAuth session manager to handle logout
     await oauthSessions.logout(session.sessionId);