fix validation on reference lookup, fix records search to return results for dids

frontend/src/features/slices/records/handlers.tsx

···
   // Get URL parameters for collection, author, and search filtering
   const url = new URL(req.url);
   const selectedCollection = url.searchParams.get("collection") || "";
-  const selectedAuthor = url.searchParams.get("author") || "";
   const searchQuery = url.searchParams.get("search") || "";
 
   // Fetch real records if a collection is selected
···
               collection: { eq: selectedCollection },
             }),
             ...(searchQuery &&
-              searchQuery.trim() !== "" && { json: { contains: searchQuery } }),
-            ...(selectedAuthor && { did: { eq: selectedAuthor } }),
+              searchQuery.trim() !== "" && {
+                json: { contains: searchQuery },
+                $or: { did: { eq: searchQuery } },
+              }),
           },
           limit: 20,
         });

packages/lexicon-rs/src/lib.rs

···
         )))?;
 
     // Validate the record data against the schema
-    validate_data_against_schema(&record, record_schema, &ctx.with_path(collection))
+    validate_data_against_schema(&record, record_schema, &ctx.with_current_lexicon(collection).with_path(collection))
 }
 
 /// Internal function to validate data against a schema

packages/lexicon-rs/src/validation/field/reference.rs

···
                 ))
             })?;
 
-        // Check for circular references
-        // TODO: Implement circular reference detection when ValidationContext supports it
-        // For now, we rely on reasonable recursion depth limits
-
         // Resolve the reference to get the target schema
+        // Note: Circular reference detection is handled by ValidationContext.resolve_reference()
         let resolved_schema = Self::resolve_reference(&parsed_ref, ctx)?;
 
         // Create a new validation context for the resolved schema
···
                 ctx.with_path(&format!("{}#{}", ctx.current_lexicon_id().unwrap_or("unknown"), def_name))
             },
             ParsedReference::GlobalWithFragment { nsid, definition } => {
-                ctx.with_path(&format!("{}#{}", nsid, definition))
+                ctx.with_current_lexicon(nsid).with_path(&format!("{}#{}", nsid, definition))
             },
             ParsedReference::GlobalMain(nsid) => {
-                ctx.with_path(&format!("{}#main", nsid))
+                ctx.with_current_lexicon(nsid).with_path(&format!("{}#main", nsid))
             },
         };