fix lexicon getRecords weirdness, fix lexicon delete handlers and add oob for count

api/src/database/records.rs

···
         let mut where_clauses = Vec::new();
         let mut param_count = 1;
 
-        let is_lexicon = where_clause
-            .as_ref()
-            .and_then(|wc| wc.conditions.get("collection"))
-            .and_then(|c| c.eq.as_ref())
-            .and_then(|v| v.as_str())
-            == Some("network.slices.lexicon");
-
         // Extract collection name from where clause for lexicon lookup
         let collection = where_clause
             .as_ref()
···
         // Build ORDER BY clause with datetime field information
         let order_by = build_order_by_clause_with_field_info(sort_by, primary_field_is_datetime);
 
-        if is_lexicon {
-            where_clauses.push(format!("json->>'slice' = ${}", param_count));
-        } else {
-            where_clauses.push(format!("slice_uri = ${}", param_count));
-        }
+        where_clauses.push(format!("slice_uri = ${}", param_count));
         param_count += 1;
 
         // Build all other WHERE conditions first (including collection filter)
-        // For non-lexicon records, exclude the 'slice' field since we handle it via slice_uri
+        // Exclude the 'slice' field since we handle it via slice_uri
         let mut filtered_where_clause = None;
         let filtered_clause;
 
-        if is_lexicon {
-            filtered_where_clause = where_clause;
-        } else if let Some(wc) = where_clause {
+        if let Some(wc) = where_clause {
             let mut filtered_conditions = std::collections::HashMap::new();
             for (field, condition) in &wc.conditions {
                 if field != "slice" {
···
         let mut where_clauses = Vec::new();
         let mut param_count = 1;
 
-        let is_lexicon = where_clause
-            .as_ref()
-            .and_then(|wc| wc.conditions.get("collection"))
-            .and_then(|c| c.eq.as_ref())
-            .and_then(|v| v.as_str())
-            == Some("network.slices.lexicon");
-
-        if is_lexicon {
-            where_clauses.push(format!("json->>'slice' = ${}", param_count));
-        } else {
-            where_clauses.push(format!("slice_uri = ${}", param_count));
-        }
+        where_clauses.push(format!("slice_uri = ${}", param_count));
         param_count += 1;
 
         let (and_conditions, or_conditions) =

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

···
 import { LexiconsList } from "./templates/fragments/LexiconsList.tsx";
 import { LexiconFormModal } from "./templates/fragments/LexiconFormModal.tsx";
 import { Badge } from "../../../shared/fragments/Badge.tsx";
+import { Card } from "../../../shared/fragments/Card.tsx";
 import { FileCode } from "lucide-preact";
 import { buildSliceUrl } from "../../../utils/slice-params.ts";
 import type { NetworkSlicesLexicon } from "../../../client.ts";
 import type { RecordResponse } from "@slices/client";
+import { publicClient } from "../../../config.ts";
 
 async function handleListLexicons(
   req: Request,
···
     const remainingLexicons =
       await sliceClient.network.slices.lexicon.getRecords();
 
+    const countHeader = (
+      <Card.Header
+        title={`${remainingLexicons.records.length} ${
+          remainingLexicons.records.length === 1 ? "Lexicon" : "Lexicons"
+        }`}
+        id="lexicon-count-header"
+        hx-swap-oob="true"
+      />
+    );
+
     if (remainingLexicons.records.length === 0) {
       return renderHTML(
-        <EmptyState
-          icon={<FileCode size={64} strokeWidth={1} />}
-          title="No lexicons uploaded"
-          description="Upload lexicon definitions to define custom schemas for this slice."
-          withPadding
-        />,
+        <div>
+          <EmptyState
+            icon={<FileCode size={64} strokeWidth={1} />}
+            title="No lexicons uploaded"
+            description="Upload lexicon definitions to define custom schemas for this slice."
+            withPadding
+          />
+          {countHeader}
+        </div>,
         {
           headers: {
             "HX-Retarget": "#lexicon-list",
···
         }
       );
     } else {
-      return new Response("", {
-        status: 200,
-        headers: { "content-type": "text/html" },
-      });
+      return renderHTML(countHeader);
     }
   } catch (error) {
     console.error("Failed to delete lexicon:", error);
···
     const remainingLexicons =
       await sliceClient.network.slices.lexicon.getRecords();
 
+    const countHeader = (
+      <Card.Header
+        title={`${remainingLexicons.records.length} ${
+          remainingLexicons.records.length === 1 ? "Lexicon" : "Lexicons"
+        }`}
+        id="lexicon-count-header"
+        hx-swap-oob="true"
+      />
+    );
+
     if (remainingLexicons.records.length === 0) {
       return renderHTML(
-        <EmptyState
-          icon={<FileCode size={64} strokeWidth={1} />}
-          title="No lexicons uploaded"
-          description="Upload lexicon definitions to define custom schemas for this slice."
-          withPadding
-        />
+        <div>
+          <EmptyState
+            icon={<FileCode size={64} strokeWidth={1} />}
+            title="No lexicons uploaded"
+            description="Upload lexicon definitions to define custom schemas for this slice."
+            withPadding
+          />
+          {countHeader}
+        </div>
       );
     } else {
       // Get slice info for domain comparison
       const sliceUri = buildSliceUri(context.currentUser.sub!, sliceId);
-      const sliceResponse = await sliceClient.network.slices.slice.getRecord({
+      const sliceResponse = await publicClient.network.slices.slice.getRecord({
         uri: sliceUri,
       });
       const sliceDomain = sliceResponse.value.domain;
 
       return renderHTML(
-        <LexiconsList
-          records={remainingLexicons.records}
-          sliceId={sliceId}
-          handle={handle || undefined}
-          sliceDomain={sliceDomain}
-          hasSliceAccess
-        />
+        <div>
+          <LexiconsList
+            records={remainingLexicons.records}
+            sliceId={sliceId}
+            handle={handle || undefined}
+            sliceDomain={sliceDomain}
+            hasSliceAccess
+          />
+          {countHeader}
+        </div>
       );
     }
   } catch (error) {
···
 
     // Get the current lexicon record using the URI
     const currentRecord = await sliceClient.network.slices.lexicon.getRecord({
-      uri
+      uri,
     });
 
     // Update the record with the new exclusion status

frontend/src/features/slices/lexicon/templates/SliceLexiconPage.tsx

···
             title={`${lexicons.length} ${
               lexicons.length === 1 ? "Lexicon" : "Lexicons"
             }`}
+            id="lexicon-count-header"
           />
           <Card.Content id="lexicon-list">
             {lexicons.length > 0 ? (

frontend/src/shared/fragments/Card.tsx

···
   children: ComponentChildren;
 }
 
-interface CardHeaderProps {
+type CardHeaderProps = JSX.IntrinsicElements['div'] & {
   title: string;
   action?: JSX.Element;
-  className?: string;
-}
+};
 
 interface CardContentProps extends JSX.HTMLAttributes<HTMLDivElement> {
   children: ComponentChildren;
···
   );
 }
 
-Card.Header = function CardHeader({ title, action, className }: CardHeaderProps): JSX.Element {
+Card.Header = function CardHeader({ title, action, className, ...props }: CardHeaderProps): JSX.Element {
   return (
-    <div className={cn("bg-zinc-50 dark:bg-zinc-800 px-6 py-3 border-b border-zinc-200 dark:border-zinc-700 rounded-t-sm", className)}>
+    <div className={cn("bg-zinc-50 dark:bg-zinc-800 px-6 py-3 border-b border-zinc-200 dark:border-zinc-700 rounded-t-sm", className)} {...props}>
       <div className="flex items-center justify-between">
         <Text as="h2" size="base" className="font-semibold">
           {title}