fix lexicon record jetstream index logic:

Now network.slices.lexicon records will:
1. Be treated as primary collections for the target slice
2. Get indexed without requiring the DID to be an existing actor
3. Not create an actor entry (since lexicons are metadata, not user activity)

api/src/jetstream.rs

···
             if collections.contains(&commit.collection) {
                 // Special handling for network.slices.lexicon records
                 // These should only be indexed to the slice specified in their JSON data
-                if commit.collection == "network.slices.lexicon" {
+                let is_lexicon_for_this_slice = if commit.collection == "network.slices.lexicon" {
                     if let Some(target_slice_uri) =
                         commit.record.get("slice").and_then(|v| v.as_str())
                     {
···
                         if slice_uri != target_slice_uri {
                             continue;
                         }
+                        true // This is a lexicon record for this specific slice
                     } else {
                         // No target slice specified, skip this lexicon record entirely
                         continue;
                     }
-                }
+                } else {
+                    false
+                };
+
                 // Get the domain for this slice (with caching)
                 let domain = match self.get_slice_domain(&slice_uri).await {
                     Ok(Some(domain)) => domain,
···
                 };
 
                 // Check if this is a primary collection (starts with slice domain)
-                let is_primary_collection = commit.collection.starts_with(&domain);
+                // Lexicon records for this slice are always treated as primary
+                let is_primary_collection = commit.collection.starts_with(&domain) || is_lexicon_for_this_slice;
 
                 // For external collections, check actor status BEFORE expensive validation
                 if !is_primary_collection {
···
                         commit.collection, slice_uri, domain
                     );
 
-                    // Ensure actor exists for primary collections
-                    let is_cached =
-                        matches!(self.is_actor_cached(did, &slice_uri).await, Ok(Some(_)));
+                    // Ensure actor exists for primary collections (except lexicons)
+                    // Lexicons don't create actors - they just get indexed
+                    if !is_lexicon_for_this_slice {
+                        let is_cached =
+                            matches!(self.is_actor_cached(did, &slice_uri).await, Ok(Some(_)));
 
-                    if !is_cached {
-                        // Actor not in cache - create it
-                        info!("Creating new actor {} for slice {}", did, slice_uri);
+                        if !is_cached {
+                            // Actor not in cache - create it
+                            info!("Creating new actor {} for slice {}", did, slice_uri);
 
-                        // Resolve actor data (handle, PDS)
-                        match resolve_actor_data(&self.http_client, did).await {
-                            Ok(actor_data) => {
-                                let actor = Actor {
-                                    did: actor_data.did.clone(),
-                                    handle: actor_data.handle,
-                                    slice_uri: slice_uri.clone(),
-                                    indexed_at: Utc::now().to_rfc3339(),
-                                };
+                            // Resolve actor data (handle, PDS)
+                            match resolve_actor_data(&self.http_client, did).await {
+                                Ok(actor_data) => {
+                                    let actor = Actor {
+                                        did: actor_data.did.clone(),
+                                        handle: actor_data.handle,
+                                        slice_uri: slice_uri.clone(),
+                                        indexed_at: Utc::now().to_rfc3339(),
+                                    };
 
-                                // Insert into database
-                                if let Err(e) = self.database.batch_insert_actors(&[actor]).await {
-                                    error!("Failed to create actor {}: {}", did, e);
-                                } else {
-                                    // Add to cache after successful database insert
-                                    self.cache_actor_exists(did, &slice_uri).await;
-                                    info!("Created actor {} for slice {}", did, slice_uri);
+                                    // Insert into database
+                                    if let Err(e) = self.database.batch_insert_actors(&[actor]).await {
+                                        error!("Failed to create actor {}: {}", did, e);
+                                    } else {
+                                        // Add to cache after successful database insert
+                                        self.cache_actor_exists(did, &slice_uri).await;
+                                        info!("Created actor {} for slice {}", did, slice_uri);
+                                    }
                                 }
-                            }
-                            Err(e) => {
-                                error!("Failed to resolve actor data for {}: {}", did, e);
+                                Err(e) => {
+                                    error!("Failed to resolve actor data for {}: {}", did, e);
+                                }
                             }
                         }
                     }