From 01aca00499b84fe9dc30ac0aa4f55b386b22d155 Mon Sep 17 00:00:00 2001
From: nkechiogbuji <ogbujiqueeneth13@gmail.com>
Date: Tue, 28 Jul 2026 14:46:46 +0100
Subject: [PATCH] Add search and filter controls to the admin member list

---
 app/[communitySlug]/admin/members/page.tsx    | 233 ++-------------
 components/admin/member-list.tsx              | 266 ++++++++++++++++++
 lib/api/mappers.ts                            |   4 +
 lib/api/mock.ts                               |  36 ++-
 lib/api/types.ts                              |  29 +-
 lib/hooks/useDebouncedValue.ts                |  17 ++
 lib/members/filter-members.ts                 |  38 +++
 test/e2e/admin-members-search-filters.spec.ts |  68 +++++
 test/fixtures/openapi.json                    |   3 +
 test/member-filters.test.ts                   | 167 +++++++++++
 test/mock-members-variety.test.ts             |  45 +++
 test/tsconfig.json                            |   7 +-
 12 files changed, 667 insertions(+), 246 deletions(-)
 create mode 100644 components/admin/member-list.tsx
 create mode 100644 lib/hooks/useDebouncedValue.ts
 create mode 100644 lib/members/filter-members.ts
 create mode 100644 test/e2e/admin-members-search-filters.spec.ts
 create mode 100644 test/member-filters.test.ts
 create mode 100644 test/mock-members-variety.test.ts

diff --git a/app/[communitySlug]/admin/members/page.tsx b/app/[communitySlug]/admin/members/page.tsx
index 9b82645..5cf6bda 100644
--- a/app/[communitySlug]/admin/members/page.tsx
+++ b/app/[communitySlug]/admin/members/page.tsx
@@ -2,7 +2,7 @@
 
 import { useAccount } from "wagmi";
 import { useQuery, useInfiniteQuery, useMutation, useQueryClient } from "@tanstack/react-query";
-import { getApi, type MemberRow, type Role, type MembershipTier } from "@/lib/api";
+import { getApi, type MemberRow, type Role } from "@/lib/api";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
 import { Input } from "@/components/ui/input";
@@ -22,7 +22,6 @@ import {
   DeniedState,
   safeErrorMessage,
 } from "@/components/ui/api-states";
-import { usePagination } from "@/lib/hooks/usePagination";
 import {
   applyOptimisticRole,
   applyOptimisticRemoveRole,
@@ -30,9 +29,9 @@ import {
 import { roleRemovalConfirmationMessage } from "@/lib/api/role-removal";
 import { AddressText } from "@/components/wallet/address-text";
 import { isWalletAddress, normalizeAddress } from "@/lib/wallet/address";
-import { BulkActionToolbar, type BulkResult } from "@/components/ui/bulk-action-toolbar";
+import type { BulkResult } from "@/components/ui/bulk-action-toolbar";
+import { MemberList } from "@/components/admin/member-list";
 import { Users } from "lucide-react";
-import Link from "next/link";
 import { features } from "@/lib/features";
 
 type AssignRoleInput = {
@@ -173,21 +172,6 @@ export default function MembersPage() {
   const params = useParams();
   const communitySlug = (params?.communitySlug as string) || 'guildpass-demo';
 
-  // Filter state
-  const [searchQuery, setSearchQuery] = useState('')
-  const [roleFilter, setRoleFilter] = useState<Role | 'all'>('all')
-  const [tierFilter, setTierFilter] = useState<MembershipTier | 'all'>('all')
-  const [statusFilter, setStatusFilter] = useState<'all' | 'active' | 'inactive'>('all')
-  const [pageSize, setPageSize] = useState(25)
-
-  const resetFilters = () => {
-    setSearchQuery('')
-    setRoleFilter('all')
-    setTierFilter('all')
-    setStatusFilter('all')
-    setPageSize(25)
-  }
-
   const {
     data,
     isLoading,
@@ -198,14 +182,16 @@ export default function MembersPage() {
     isFetchingNextPage,
     refetch,
   } = useInfiniteQuery({
-    queryKey: [...queryKeys.members.all(communitySlug), { searchQuery }],
+    queryKey: queryKeys.members.all(communitySlug),
     queryFn: async ({ pageParam }) => {
       const api = getApi(address, authSession?.token, communitySlug);
       const limit = 100;
+      // Search/role/tier filtering happens entirely client-side (see
+      // components/admin/member-list.tsx) — this fetch is purely
+      // cursor-driven and never re-runs in response to filter changes.
       const res = await api.listMembers({
         cursor: pageParam,
         limit,
-        filter: searchQuery || undefined,
       });
 
       if (Array.isArray(res)) {
@@ -254,42 +240,7 @@ export default function MembersPage() {
     return data?.pages.flatMap((page) => page.members) ?? [];
   }, [data]);
 
-  const isFallbackMode = data?.pages[0]?.isFallback ?? false;
-
-  const filteredMembers = useMemo(() => {
-    return allFetchedMembers.filter((m) => {
-      const matchesSearch =
-        !isFallbackMode ||
-        !searchQuery ||
-        m.address.toLowerCase().includes(searchQuery.toLowerCase());
-      const matchesRole = roleFilter === 'all' || m.roles.includes(roleFilter);
-      const matchesTier = tierFilter === 'all' || m.tier === tierFilter;
-      const matchesStatus =
-        statusFilter === 'all' ||
-        (statusFilter === 'active' && m.active) ||
-        (statusFilter === 'inactive' && !m.active);
-
-      return matchesSearch && matchesRole && matchesTier && matchesStatus;
-    });
-  }, [allFetchedMembers, isFallbackMode, searchQuery, roleFilter, tierFilter, statusFilter]);
-
-  const {
-    paginatedItems,
-    currentPage,
-    totalPages,
-    nextPage,
-    prevPage,
-    setPage,
-    setCurrentPage,
-  } = usePagination(filteredMembers, pageSize);
-
-  useEffect(() => {
-    setCurrentPage(1);
-  }, [searchQuery, roleFilter, tierFilter, statusFilter, pageSize, setCurrentPage]);
-
-  const isFiltered = searchQuery || roleFilter !== 'all' || tierFilter !== 'all' || statusFilter !== 'all'
   const hasAnyMembers = allFetchedMembers.length > 0
-  const hasVisibleMembers = filteredMembers.length > 0
 
   const {
     mutate,
@@ -353,7 +304,6 @@ export default function MembersPage() {
         }
         setPendingAssignment(null);
         addToast({
-          tone: "default",
           tone: "warning",
           title: "Approval Required",
           description: `Assignment of ${input.role} to ${input.address.slice(0, 6)}…${input.address.slice(-4)} has been proposed for approval.`,
@@ -513,7 +463,6 @@ export default function MembersPage() {
         }
         setPendingAssignment(null);
         addToast({
-          tone: "default",
           tone: "warning",
           title: "Approval Required",
           description: `Removal of ${input.role} from ${input.address.slice(0, 6)}…${input.address.slice(-4)} has been proposed for approval.`,
@@ -637,28 +586,6 @@ export default function MembersPage() {
     });
   };
 
-  const toggleSelectAll = () => {
-    const pageAddresses = paginatedItems.map((m) => m.address);
-    const allSelected = pageAddresses.every((a) =>
-      selectedAddresses.has(a),
-    );
-    if (allSelected) {
-      // Deselect all on this page
-      setSelectedAddresses((prev) => {
-        const next = new Set(prev);
-        pageAddresses.forEach((a) => next.delete(a));
-        return next;
-      });
-    } else {
-      // Select all on this page
-      setSelectedAddresses((prev) => {
-        const next = new Set(prev);
-        pageAddresses.forEach((a) => next.add(a));
-        return next;
-      });
-    }
-  };
-
   const clearSelection = () => {
     setSelectedAddresses(new Set());
     setBulkResults(null);
@@ -733,11 +660,6 @@ export default function MembersPage() {
     }
   };
 
-  const pageAddresses = paginatedItems.map((m) => m.address);
-  const allPageSelected =
-    pageAddresses.length > 0 &&
-    pageAddresses.every((a) => selectedAddresses.has(a));
-
   const handleScrollToBottom = () => {
     if (hasNextPage && !isFetchingNextPage) {
       fetchNextPage();
@@ -872,7 +794,6 @@ export default function MembersPage() {
                       <span className="text-xs text-muted-foreground">
                         {log.timestamp.toLocaleTimeString()}
                       </span>
-                      {log.status === 'pending' && <Badge variant="secondary">Pending</Badge>}
                       {log.status === 'pending' && <Badge variant="outline">Pending</Badge>}
                       {log.status === 'success' && <Badge className="bg-green-600 hover:bg-green-700">Success</Badge>}
                       {log.status === 'error' && (
@@ -888,11 +809,6 @@ export default function MembersPage() {
 
         <Card>
           <CardContent>
-            {hasAnyMembers && hasVisibleMembers && (
-              <CardHeader className="px-0 pt-0 pb-4 border-b-0">
-                <CardTitle>Member List</CardTitle>
-              </CardHeader>
-            )}
             {isLoading ? (
               <LoadingState message="Loading members…" />
             ) : isError ? (
@@ -915,119 +831,30 @@ export default function MembersPage() {
                   </a>
                 }
               />
-            ) : !hasVisibleMembers ? (
-              <EmptyState
-                title="No matching members"
-                message="Members exist, but none match the current filters. Clear the filters to see the full list."
-                icon={<Users className="h-10 w-10" aria-hidden="true" />}
-              />
             ) : (
-               <div className="space-y-4">
-                 {/* ── Bulk action toolbar ─────────────────────────── */}
-                 {selectedAddressArray.length > 0 && (
-                   <div className="space-y-2">
-                     <div className="grid gap-3 sm:grid-cols-[minmax(0,1fr)_10rem_auto] sm:items-end">
-                       <div />
-                       <Select
-                         value={bulkRole}
-                         onChange={(e) => setBulkRole(e.target.value as Role)}
-                       >
-                         <option value="member">member</option>
-                         <option value="moderator">moderator</option>
-                         <option value="admin">admin</option>
-                       </Select>
-                     </div>
-                     <BulkActionToolbar
-                       selectedCount={selectedAddressArray.length}
-                       totalCount={filteredMembers.length}
-                       onDismiss={clearSelection}
-                       onBulkAction={handleBulkAssign}
-                       actionLabel={`Assign ${bulkRole} to selected`}
-                       isPending={isBulkPending}
-                       results={bulkResults}
-                       onRetryFailed={handleRetryFailed}
-                     />
-                   </div>
-                 )}
-                 <div className="space-y-2">
-                   {paginatedItems.map((m) => (
-                     <div
-                       key={m.address}
-                       className="flex flex-col gap-3 rounded-md border p-3 sm:flex-row sm:items-center sm:justify-between h-full bg-card"
-                     >
-                       <div className="flex items-center gap-2">
-                         <input
-                           type="checkbox"
-                           checked={selectedAddresses.has(m.address)}
-                           onChange={() => toggleSelect(m.address)}
-                           className="h-4 w-4 rounded border-gray-300"
-                           aria-label={`Select ${m.address}`}
-                         />
-                         <AddressText address={m.address} className="text-sm" />
-                         {features.profiles && (
-                           <Link
-                             href={`/members/${m.address}`}
-                             className="text-xs text-primary underline-offset-4 hover:underline"
-                           >
-                             View profile
-                           </Link>
-                         )}
-                       </div>
-                       <div className="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
-                         <span>Tier: {m.tier}</span>
-                         <div className="flex flex-wrap gap-1">
-                           {m.roles.map((r: string) => (
-                             <button
-                               key={r}
-                               type="button"
-                               className="inline-flex items-center rounded-md border border-transparent bg-secondary px-2 py-0.5 text-xs font-semibold text-secondary-foreground transition-colors hover:bg-destructive hover:text-destructive-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background"
-                               onClick={() => requestRoleRemoval(m, r as import('@/lib/api/types').Role)}
-                               aria-label={`Remove ${r} role from ${m.address}`}
-                               title={`Remove ${r} role`}
-                             >
-                               {r} <span aria-hidden="true">✕</span>
-                             </button>
-                           ))}
-                         </div>
-                         {pendingAssignment?.address.toLowerCase() ===
-                           m.address.toLowerCase() && (
-                           <Badge variant="warning">Saving</Badge>
-                         )}
-                       </div>
-                     </div>
-                   ))}
-                 </div>
-                 
-                 <div className="flex items-center justify-between border-t pt-4">
-                    <div className="text-sm text-muted-foreground">
-                      Page {currentPage} of {totalPages} ({filteredMembers.length} members)
-                    </div>
-                    <div className="flex items-center gap-2">
-                       <Select
-                          value={String(pageSize)}
-                          onChange={(e) => setPageSize(Number(e.target.value))}
-                       >
-                          <option value="25">25 per page</option>
-                          <option value="50">50 per page</option>
-                          <option value="100">100 per page</option>
-                       </Select>
-                       <Button variant="outline" size="sm" onClick={prevPage} disabled={currentPage === 1}>
-                         Previous
-                       </Button>
-                       <Button variant="outline" size="sm" onClick={nextPage} disabled={currentPage === totalPages}>
-                         Next
-                       </Button>
-                    </div>
-                 </div>
-
-                 {isFetchingNextPage && (
-                   <div className="text-center py-2 text-xs text-muted-foreground">
-                     Loading more members…
-                   </div>
-                 )}
-               </div>
-             )}
-
+              <>
+                <MemberList
+                  members={allFetchedMembers}
+                  showProfileLink={features.profiles}
+                  pendingAddress={pendingAssignment?.address.toLowerCase()}
+                  onRequestRoleRemoval={requestRoleRemoval}
+                  selectedAddresses={selectedAddresses}
+                  onToggleSelect={toggleSelect}
+                  bulkRole={bulkRole}
+                  onBulkRoleChange={setBulkRole}
+                  onBulkAssign={handleBulkAssign}
+                  onClearSelection={clearSelection}
+                  onRetryFailedBulk={handleRetryFailed}
+                  isBulkPending={isBulkPending}
+                  bulkResults={bulkResults}
+                />
+                {isFetchingNextPage && (
+                  <div className="text-center py-2 text-xs text-muted-foreground">
+                    Loading more members…
+                  </div>
+                )}
+              </>
+            )}
           </CardContent>
         </Card>
       </div>
diff --git a/components/admin/member-list.tsx b/components/admin/member-list.tsx
new file mode 100644
index 0000000..a412e89
--- /dev/null
+++ b/components/admin/member-list.tsx
@@ -0,0 +1,266 @@
+"use client";
+
+import { useEffect, useMemo, useState } from "react";
+import type { MemberRow, MembershipTier, Role } from "@/lib/api";
+import {
+  ROLE_FILTER_OPTIONS,
+  TIER_FILTER_OPTIONS,
+  filterMembers,
+} from "@/lib/members/filter-members";
+import { useDebouncedValue } from "@/lib/hooks/useDebouncedValue";
+import { usePagination } from "@/lib/hooks/usePagination";
+import { Input } from "@/components/ui/input";
+import { Select } from "@/components/ui/select";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { CardHeader, CardTitle } from "@/components/ui/card";
+import { EmptyState } from "@/components/ui/api-states";
+import { AddressText } from "@/components/wallet/address-text";
+import { BulkActionToolbar, type BulkResult } from "@/components/ui/bulk-action-toolbar";
+import { Users } from "lucide-react";
+import Link from "next/link";
+
+const SEARCH_DEBOUNCE_MS = 300;
+
+function capitalize(value: string): string {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export interface MemberListProps {
+  /** All members fetched so far, in fetch order — never mutated by this component. */
+  members: MemberRow[];
+  showProfileLink: boolean;
+  /** Lower-cased address of a role mutation currently in flight, if any. */
+  pendingAddress?: string;
+  onRequestRoleRemoval: (member: MemberRow, role: Role) => void;
+
+  selectedAddresses: Set<string>;
+  onToggleSelect: (address: string) => void;
+
+  bulkRole: Role;
+  onBulkRoleChange: (role: Role) => void;
+  onBulkAssign: () => Promise<void>;
+  onClearSelection: () => void;
+  onRetryFailedBulk: () => Promise<void>;
+  isBulkPending: boolean;
+  bulkResults: BulkResult | null;
+}
+
+export function MemberList({
+  members,
+  showProfileLink,
+  pendingAddress,
+  onRequestRoleRemoval,
+  selectedAddresses,
+  onToggleSelect,
+  bulkRole,
+  onBulkRoleChange,
+  onBulkAssign,
+  onClearSelection,
+  onRetryFailedBulk,
+  isBulkPending,
+  bulkResults,
+}: MemberListProps) {
+  const [searchInput, setSearchInput] = useState("");
+  const [roleFilter, setRoleFilter] = useState<Role | "all">("all");
+  const [tierFilter, setTierFilter] = useState<MembershipTier | "all">("all");
+  const [pageSize, setPageSize] = useState(25);
+
+  // The visible input updates immediately; only the value used for filtering
+  // is debounced, so typing never feels laggy while results still settle.
+  const debouncedSearch = useDebouncedValue(searchInput, SEARCH_DEBOUNCE_MS);
+
+  const filteredMembers = useMemo(
+    () =>
+      filterMembers(members, {
+        search: debouncedSearch,
+        role: roleFilter,
+        tier: tierFilter,
+      }),
+    [members, debouncedSearch, roleFilter, tierFilter],
+  );
+
+  const { paginatedItems, currentPage, totalPages, nextPage, prevPage, setCurrentPage } =
+    usePagination(filteredMembers, pageSize);
+
+  useEffect(() => {
+    setCurrentPage(1);
+  }, [debouncedSearch, roleFilter, tierFilter, pageSize, setCurrentPage]);
+
+  const isFiltered = searchInput.trim() !== "" || roleFilter !== "all" || tierFilter !== "all";
+  const hasVisibleMembers = filteredMembers.length > 0;
+  const selectedAddressArray = Array.from(selectedAddresses);
+
+  const clearFilters = () => {
+    setSearchInput("");
+    setRoleFilter("all");
+    setTierFilter("all");
+  };
+
+  return (
+    <div className="space-y-4">
+      <div className="grid gap-3 sm:grid-cols-[minmax(0,1fr)_10rem_10rem_auto] sm:items-end">
+        <div className="space-y-1">
+          <label htmlFor="member-search-input" className="text-xs font-medium text-muted-foreground">
+            Search members
+          </label>
+          <Input
+            id="member-search-input"
+            type="search"
+            placeholder="Search by wallet address or name…"
+            value={searchInput}
+            onChange={(e) => setSearchInput(e.target.value)}
+          />
+        </div>
+        <div className="space-y-1">
+          <label htmlFor="member-role-filter" className="text-xs font-medium text-muted-foreground">
+            Role
+          </label>
+          <Select
+            id="member-role-filter"
+            value={roleFilter}
+            onChange={(e) => setRoleFilter(e.target.value as Role | "all")}
+          >
+            <option value="all">All roles</option>
+            {ROLE_FILTER_OPTIONS.map((r) => (
+              <option key={r} value={r}>
+                {capitalize(r)}
+              </option>
+            ))}
+          </Select>
+        </div>
+        <div className="space-y-1">
+          <label htmlFor="member-tier-filter" className="text-xs font-medium text-muted-foreground">
+            Tier
+          </label>
+          <Select
+            id="member-tier-filter"
+            value={tierFilter}
+            onChange={(e) => setTierFilter(e.target.value as MembershipTier | "all")}
+          >
+            <option value="all">All tiers</option>
+            {TIER_FILTER_OPTIONS.map((t) => (
+              <option key={t} value={t}>
+                {capitalize(t)}
+              </option>
+            ))}
+          </Select>
+        </div>
+        {isFiltered && (
+          <Button variant="outline" size="sm" onClick={clearFilters}>
+            Clear filters
+          </Button>
+        )}
+      </div>
+
+      {!hasVisibleMembers ? (
+        <EmptyState
+          title="No matching members"
+          message="No members match your current filters."
+          icon={<Users className="h-10 w-10" aria-hidden="true" />}
+          actions={
+            <Button variant="outline" size="sm" onClick={clearFilters}>
+              Clear filters
+            </Button>
+          }
+        />
+      ) : (
+        <>
+          <CardHeader className="px-0 pt-0 pb-4 border-b-0">
+            <CardTitle>Member List</CardTitle>
+          </CardHeader>
+
+          {selectedAddressArray.length > 0 && (
+            <div className="space-y-2">
+              <div className="grid gap-3 sm:grid-cols-[minmax(0,1fr)_10rem_auto] sm:items-end">
+                <div />
+                <Select value={bulkRole} onChange={(e) => onBulkRoleChange(e.target.value as Role)}>
+                  <option value="member">member</option>
+                  <option value="moderator">moderator</option>
+                  <option value="admin">admin</option>
+                </Select>
+              </div>
+              <BulkActionToolbar
+                selectedCount={selectedAddressArray.length}
+                totalCount={filteredMembers.length}
+                onDismiss={onClearSelection}
+                onBulkAction={onBulkAssign}
+                actionLabel={`Assign ${bulkRole} to selected`}
+                isPending={isBulkPending}
+                results={bulkResults}
+                onRetryFailed={onRetryFailedBulk}
+              />
+            </div>
+          )}
+
+          <div className="space-y-2">
+            {paginatedItems.map((m) => (
+              <div
+                key={m.address}
+                className="flex flex-col gap-3 rounded-md border p-3 sm:flex-row sm:items-center sm:justify-between h-full bg-card"
+              >
+                <div className="flex items-center gap-2">
+                  <input
+                    type="checkbox"
+                    checked={selectedAddresses.has(m.address)}
+                    onChange={() => onToggleSelect(m.address)}
+                    className="h-4 w-4 rounded border-gray-300"
+                    aria-label={`Select ${m.address}`}
+                  />
+                  <AddressText address={m.address} className="text-sm" />
+                  {showProfileLink && (
+                    <Link
+                      href={`/members/${m.address}`}
+                      className="text-xs text-primary underline-offset-4 hover:underline"
+                    >
+                      View profile
+                    </Link>
+                  )}
+                </div>
+                <div className="flex flex-wrap items-center gap-2 text-xs text-muted-foreground">
+                  <span>Tier: {m.tier}</span>
+                  <div className="flex flex-wrap gap-1">
+                    {m.roles.map((r) => (
+                      <button
+                        key={r}
+                        type="button"
+                        className="inline-flex items-center rounded-md border border-transparent bg-secondary px-2 py-0.5 text-xs font-semibold text-secondary-foreground transition-colors hover:bg-destructive hover:text-destructive-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background"
+                        onClick={() => onRequestRoleRemoval(m, r)}
+                        aria-label={`Remove ${r} role from ${m.address}`}
+                        title={`Remove ${r} role`}
+                      >
+                        {r} <span aria-hidden="true">✕</span>
+                      </button>
+                    ))}
+                  </div>
+                  {pendingAddress === m.address.toLowerCase() && (
+                    <Badge variant="warning">Saving</Badge>
+                  )}
+                </div>
+              </div>
+            ))}
+          </div>
+
+          <div className="flex items-center justify-between border-t pt-4">
+            <div className="text-sm text-muted-foreground" role="status" aria-live="polite">
+              Page {currentPage} of {totalPages} ({filteredMembers.length} members)
+            </div>
+            <div className="flex items-center gap-2">
+              <Select value={String(pageSize)} onChange={(e) => setPageSize(Number(e.target.value))}>
+                <option value="25">25 per page</option>
+                <option value="50">50 per page</option>
+                <option value="100">100 per page</option>
+              </Select>
+              <Button variant="outline" size="sm" onClick={prevPage} disabled={currentPage === 1}>
+                Previous
+              </Button>
+              <Button variant="outline" size="sm" onClick={nextPage} disabled={currentPage === totalPages}>
+                Next
+              </Button>
+            </div>
+          </div>
+        </>
+      )}
+    </div>
+  );
+}
diff --git a/lib/api/mappers.ts b/lib/api/mappers.ts
index 05937ff..e77cfe8 100644
--- a/lib/api/mappers.ts
+++ b/lib/api/mappers.ts
@@ -72,11 +72,15 @@ export function mapMemberProfile(raw: any, address: string): MemberProfile {
 // ── Member Row (list view) ───────────────────────────────────────────────────
 
 export function mapMemberRow(raw: any): MemberRow {
+  const displayName = raw.displayName ?? raw.display_name ?? raw.username
   return {
     address: raw.address ?? raw.wallet_address ?? '',
     roles: raw.roles ?? [],
     tier: raw.tier ?? raw.membership_tier ?? 'free',
     active: raw.active ?? raw.is_active ?? false,
+    // Only present when the backend actually sends one — keeps existing
+    // fixtures/snapshots that never touch this field unaffected.
+    ...(displayName ? { displayName } : {}),
   }
 }
 
diff --git a/lib/api/mock.ts b/lib/api/mock.ts
index aed5658..66df968 100644
--- a/lib/api/mock.ts
+++ b/lib/api/mock.ts
@@ -248,14 +248,30 @@ const MOCK_ANALYTICS_SUMMARY: AnalyticsSummary = {
 
 const DEFAULT_MEMBER_STORE: Record<string, { membership: Membership; roles: Role[]; profile: MemberProfile }> = {}
 
+/** Deterministic name pool for seeded members — gives search-by-name something realistic and varied to match against. */
+const SEED_FIRST_NAMES = ['Ada', 'Grace', 'Alan', 'Katherine', 'Linus', 'Margaret', 'Dennis', 'Radia', 'Barbara', 'Vint', 'Hedy', 'Claude']
+const SEED_LAST_NAMES = ['Lovelace', 'Hopper', 'Turing', 'Johnson', 'Torvalds', 'Hamilton', 'Ritchie', 'Perlman', 'Liskov', 'Cerf', 'Lamarr', 'Shannon']
+
 // Populate 50,000 synthetic members to exercise the scale scenario
 for (let i = 0; i < 50000; i++) {
   const hex = (i + 1).toString(16).padStart(40, '0')
   const address = `0x${hex}`
   const tier: MembershipTier = i % 10 < 3 ? 'pro' : i % 10 < 7 ? 'standard' : 'free'
   const active = i % 5 !== 0
-  const roles: Role[] = i === 0 ? ['admin'] : i % 50 === 0 ? ['moderator'] : ['member']
-  
+  // i % 777 (excluding i === 0, already 'admin') seeds a small, deterministic
+  // set of multi-role members so role-filter "matches any assigned role"
+  // behavior has real examples to exercise, without disturbing the existing
+  // single-admin / every-50th-moderator distribution other tests rely on.
+  const roles: Role[] =
+    i === 0
+      ? ['admin']
+      : i % 777 === 0
+        ? ['moderator', 'member']
+        : i % 50 === 0
+          ? ['moderator']
+          : ['member']
+  const displayName = `${SEED_FIRST_NAMES[i % SEED_FIRST_NAMES.length]} ${SEED_LAST_NAMES[Math.floor(i / SEED_FIRST_NAMES.length) % SEED_LAST_NAMES.length]}`
+
   DEFAULT_MEMBER_STORE[address] = {
     membership: {
       address,
@@ -265,7 +281,7 @@ for (let i = 0; i < 50000; i++) {
     roles,
     profile: {
       address,
-      displayName: `Synthetic Member ${i + 1}`,
+      displayName,
       badges: i % 100 === 0 ? ['Early Adopter'] : [],
     },
   }
@@ -408,7 +424,6 @@ export function getCommunityState(communityId: string = 'guildpass-demo'): Commu
       resources: [...(MOCK_RESOURCES[normalizedId] ?? [])],
       policies: [...(MOCK_POLICIES[normalizedId] ?? [])],
       webhookEvents: [...DEFAULT_WEBHOOK_EVENTS],
-      memberStore: { ...(MOCK_MEMBER_STORES[normalizedId] ?? {}) },
       memberStore: Object.fromEntries(
         Object.entries(MOCK_MEMBER_STORES[normalizedId] ?? {}).map(([k, v]) => [
           k,
@@ -1047,6 +1062,7 @@ export class MockAccessApi implements AccessApi {
       roles: m.roles,
       tier: m.membership.tier,
       active: m.membership.active,
+      ...(m.profile.displayName ? { displayName: m.profile.displayName } : {}),
     }))
 
     if (!params) {
@@ -1192,13 +1208,11 @@ export class MockAccessApi implements AccessApi {
     const action = state.pendingActions.find(a => a.id === id)
     if (!action || action.status !== 'pending') return
     
-    if (!action.currentApprovals.includes(MOCK_ADMIN_ADDRESS)) {
-      action.currentApprovals.push(MOCK_ADMIN_ADDRESS)
     const adminAddr = this.address || '0x0000000000000000000000000000000000000001'
     if (!action.currentApprovals.includes(adminAddr)) {
       action.currentApprovals.push(adminAddr)
     }
-    
+
     if (action.currentApprovals.length >= action.requiredApprovals) {
       if (action.type === 'assignRole') {
         const data = ensureAddress(action.payload.address!, this.communityId)
@@ -1233,15 +1247,12 @@ export class MockAccessApi implements AccessApi {
   async updateApprovalConfig(config: ApprovalConfig): Promise<void> {
     await initPromise
     const state = getCommunityState(this.communityId)
-    state.community.approvalConfig = config
-    const state = getCommunityState(this.communityId);
-    (state.community as any).approvalConfig = config
+    ;(state.community as any).approvalConfig = config
     schedulePersist()
   }
 
   private _checkApproval(type: PendingActionType, payload: PendingActionPayload): { status: 'executed' | 'pending'; pendingActionId?: string } {
     const state = getCommunityState(this.communityId)
-    const config = state.community.approvalConfig
     const config = (state.community as any).approvalConfig
     const required = config ? config[type] || 1 : 1
     
@@ -1252,9 +1263,6 @@ export class MockAccessApi implements AccessApi {
         id: pendingActionId,
         type,
         payload,
-        proposer: MOCK_ADMIN_ADDRESS,
-        requiredApprovals: required,
-        currentApprovals: [MOCK_ADMIN_ADDRESS],
         proposer: adminAddr,
         requiredApprovals: required,
         currentApprovals: [adminAddr],
diff --git a/lib/api/types.ts b/lib/api/types.ts
index 863be49..ed105c2 100644
--- a/lib/api/types.ts
+++ b/lib/api/types.ts
@@ -47,37 +47,11 @@ export const WebhookEventLogSchema = z.object({
   payloadSummary: WebhookPayloadSummarySchema,
 })
 
-export interface ApprovalConfig {
-  assignRole: number
-  removeRole: number
-  updatePolicy: number
-}
-
-export type PendingActionType = 'assignRole' | 'removeRole' | 'updatePolicy'
-
-export interface PendingActionPayload {
-  address?: string
-  role?: string
-  policy?: AccessPolicy
-}
-
-export interface PendingAction {
-  id: string
-  type: PendingActionType
-  payload: PendingActionPayload
-  proposer: string
-  requiredApprovals: number
-  currentApprovals: string[] // List of admin addresses who approved
-  status: 'pending' | 'approved' | 'rejected' | 'executed'
-  createdAt: string
-}
-
 export interface Community {
   id: string
   name: string
   description?: string
   tiers: MembershipTier[]
-  approvalConfig?: ApprovalConfig
 }
 
 export const CommunitySchema = z.object({
@@ -217,6 +191,7 @@ export interface MemberRow {
   roles: Role[]
   tier: MembershipTier
   active: boolean
+  displayName?: string
 }
 
 export const MemberRowSchema = z.object({
@@ -224,6 +199,7 @@ export const MemberRowSchema = z.object({
   roles: z.array(RoleSchema),
   tier: MembershipTierSchema,
   active: z.boolean(),
+  displayName: z.string().optional(),
 })
 
 export interface MemberGrowthDataPoint {
@@ -701,7 +677,6 @@ export interface AdminAccessApi {
    * @provisional Calls `GET /v1/admin/analytics` — endpoint not yet live in
    * guildpass-core. Contract tracked in issue #157; pending backend confirmation.
    */
-  getAnalyticsSummary(signal?: AbortSignal): Promise<AnalyticsSummary>
   getPendingActions(): Promise<PendingAction[]>
   approveAction(id: string): Promise<void>
   rejectAction(id: string): Promise<void>
diff --git a/lib/hooks/useDebouncedValue.ts b/lib/hooks/useDebouncedValue.ts
new file mode 100644
index 0000000..ca8eccb
--- /dev/null
+++ b/lib/hooks/useDebouncedValue.ts
@@ -0,0 +1,17 @@
+import { useEffect, useState } from 'react';
+
+/**
+ * Returns a copy of `value` that only updates `delayMs` after the last
+ * change — the input driving `value` itself should update immediately;
+ * only downstream consumers of the returned value see the delay.
+ */
+export function useDebouncedValue<T>(value: T, delayMs: number): T {
+  const [debounced, setDebounced] = useState(value);
+
+  useEffect(() => {
+    const timer = setTimeout(() => setDebounced(value), delayMs);
+    return () => clearTimeout(timer);
+  }, [value, delayMs]);
+
+  return debounced;
+}
diff --git a/lib/members/filter-members.ts b/lib/members/filter-members.ts
new file mode 100644
index 0000000..2dad8b7
--- /dev/null
+++ b/lib/members/filter-members.ts
@@ -0,0 +1,38 @@
+import { MemberRow, MembershipTier, MembershipTierSchema, Role, RoleSchema } from '../api/types';
+
+/** Canonical option lists, in the order already declared on the enums — used for filter dropdowns instead of deriving from loaded data so options don't shift as more members load. */
+export const ROLE_FILTER_OPTIONS: Role[] = RoleSchema.options;
+export const TIER_FILTER_OPTIONS: MembershipTier[] = MembershipTierSchema.options;
+
+export interface MemberFilters {
+  search: string;
+  role: Role | 'all';
+  tier: MembershipTier | 'all';
+}
+
+/**
+ * True when `member` satisfies every active filter (AND across search/role/
+ * tier, ANY within a member's own roles array). Never mutates `member`.
+ */
+export function memberMatchesFilters(member: MemberRow, filters: MemberFilters): boolean {
+  const term = filters.search.trim().toLowerCase();
+
+  const matchesSearch =
+    term === '' ||
+    member.address.toLowerCase().includes(term) ||
+    (member.displayName?.toLowerCase().includes(term) ?? false);
+
+  const matchesRole = filters.role === 'all' || (member.roles ?? []).includes(filters.role);
+
+  // Exact match only — an unrecognized tier value is simply excluded from a
+  // specific filter (never coerced into one of the known tiers) and still
+  // matches 'all'.
+  const matchesTier = filters.tier === 'all' || member.tier === filters.tier;
+
+  return matchesSearch && matchesRole && matchesTier;
+}
+
+/** Returns a new array (input order preserved, input never mutated). */
+export function filterMembers(members: MemberRow[], filters: MemberFilters): MemberRow[] {
+  return members.filter((member) => memberMatchesFilters(member, filters));
+}
diff --git a/test/e2e/admin-members-search-filters.spec.ts b/test/e2e/admin-members-search-filters.spec.ts
new file mode 100644
index 0000000..4465e3d
--- /dev/null
+++ b/test/e2e/admin-members-search-filters.spec.ts
@@ -0,0 +1,68 @@
+/**
+ * test/e2e/admin-members-search-filters.spec.ts
+ *
+ * End-to-end coverage for the admin member search/role/tier filters that
+ * the SSR-only unit test harness (node:test + renderToStaticMarkup, see
+ * test/member-filters.test.ts) cannot exercise: real typing/selecting,
+ * the debounce delay, and the "Clear filters" click.
+ *
+ * Run with: npm run test:e2e -- admin-members-search-filters.spec.ts
+ *
+ * KNOWN ISSUE (pre-existing, not specific to this spec — see
+ * test/e2e/profile-edit.spec.ts for the original writeup): the mock wallet
+ * connector's window.ethereum polyfill does not currently reach a connected
+ * wagmi state in this environment because of CSP restrictions on
+ * Playwright's addInitScript, so AdminGuard-gated routes like this one never
+ * get past the initial "Connect Wallet" state. This spec is written to the
+ * same conventions as profile-edit.spec.ts / siwe-flow.spec.ts and will
+ * start passing once that shared harness gap is fixed.
+ */
+
+import { test, expect } from '@playwright/test'
+import { injectMockWalletConnector, clearAuthSession } from './helpers'
+
+const BASE_URL = process.env.BASE_URL || 'http://localhost:3000'
+const ADDRESS = '0x1234567890abcdef1234567890abcdef12345678'
+// Mock-mode admin seeding (lib/api/mock.ts MOCK_ADMIN_ADDRESS convention) —
+// matches the address AdminGuard expects to already hold the admin role.
+const COMMUNITY_SLUG = 'guildpass-demo'
+
+test.describe('Admin member search/filter controls (E2E)', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto(BASE_URL)
+    await clearAuthSession(page)
+    await injectMockWalletConnector(page, { address: ADDRESS, isConnected: true })
+    await page.goto(`${BASE_URL}/${COMMUNITY_SLUG}/admin/members`)
+  })
+
+  test('typing a search term debounces before narrowing the list', async ({ page }) => {
+    const search = page.getByLabel('Search members')
+    await search.waitFor({ state: 'visible', timeout: 10000 })
+
+    const rowCountBefore = await page.locator('[aria-label^="Select 0x"]').count()
+
+    await search.fill('zzz-no-such-member-zzz')
+    // Immediately after typing, filtering should not have applied yet.
+    expect(await page.locator('[aria-label^="Select 0x"]').count()).toBe(rowCountBefore)
+
+    await expect(page.getByText('No members match your current filters.')).toBeVisible({ timeout: 2000 })
+  })
+
+  test('role and tier filters combine with search, and Clear filters restores the full list', async ({ page }) => {
+    const search = page.getByLabel('Search members')
+    await search.waitFor({ state: 'visible', timeout: 10000 })
+
+    await page.getByLabel('Role').selectOption('admin')
+    await page.getByLabel('Tier').selectOption('free')
+    await search.fill('nonexistent-combo')
+
+    await expect(page.getByText('No members match your current filters.')).toBeVisible({ timeout: 2000 })
+
+    await page.getByRole('button', { name: 'Clear filters' }).click()
+
+    await expect(search).toHaveValue('')
+    await expect(page.getByLabel('Role')).toHaveValue('all')
+    await expect(page.getByLabel('Tier')).toHaveValue('all')
+    await expect(page.getByText('No members match your current filters.')).not.toBeVisible()
+  })
+})
diff --git a/test/fixtures/openapi.json b/test/fixtures/openapi.json
index b10bfd6..fd69e3e 100644
--- a/test/fixtures/openapi.json
+++ b/test/fixtures/openapi.json
@@ -617,6 +617,9 @@
           },
           "active": {
             "type": "boolean"
+          },
+          "displayName": {
+            "type": "string"
           }
         },
         "required": [
diff --git a/test/member-filters.test.ts b/test/member-filters.test.ts
new file mode 100644
index 0000000..79cc500
--- /dev/null
+++ b/test/member-filters.test.ts
@@ -0,0 +1,167 @@
+import './setup-env'
+import { describe, test } from 'node:test'
+import * as assert from 'node:assert/strict'
+import { filterMembers, memberMatchesFilters, type MemberFilters } from '../lib/members/filter-members'
+import type { MemberRow } from '../lib/api/types'
+
+function member(overrides: Partial<MemberRow> & { address: string }): MemberRow {
+  return {
+    roles: ['member'],
+    tier: 'free',
+    active: true,
+    ...overrides,
+  }
+}
+
+const NO_FILTER: MemberFilters = { search: '', role: 'all', tier: 'all' }
+
+describe('filterMembers — search', () => {
+  test('matches a partial wallet address', () => {
+    const ada = member({ address: '0xAbCdEf0000000000000000000000000000000001', displayName: 'Not Matching Name' })
+    const grace = member({ address: '0x1111111111111111111111111111111111111111', displayName: 'Also Not Matching' })
+    const result = filterMembers([ada, grace], { ...NO_FILTER, search: 'bcde' })
+    assert.deepEqual(result.map((m) => m.address), [ada.address])
+  })
+
+  test('matches a partial display name', () => {
+    const ada = member({ address: '0x0000000000000000000000000000000000000001', displayName: 'Ada Lovelace' })
+    const grace = member({ address: '0x0000000000000000000000000000000000000002', displayName: 'Grace Hopper' })
+    const result = filterMembers([ada, grace], { ...NO_FILTER, search: 'lace' })
+    assert.deepEqual(result.map((m) => m.displayName), ['Ada Lovelace'])
+  })
+
+  test('search is case-insensitive for both address and name', () => {
+    const ada = member({ address: '0xABCDEF0000000000000000000000000000000001', displayName: 'Ada Lovelace' })
+    const byAddress = filterMembers([ada], { ...NO_FILTER, search: 'abcdef' })
+    const byName = filterMembers([ada], { ...NO_FILTER, search: 'ADA LOVELACE' })
+    assert.equal(byAddress.length, 1)
+    assert.equal(byName.length, 1)
+  })
+
+  test('trims leading and trailing whitespace from the search term', () => {
+    const ada = member({ address: '0x0000000000000000000000000000000000000001', displayName: 'Ada Lovelace' })
+    const result = filterMembers([ada], { ...NO_FILTER, search: '   ada   ' })
+    assert.equal(result.length, 1)
+  })
+
+  test('an empty (or whitespace-only) search returns every member, subject to role/tier', () => {
+    const members = [
+      member({ address: '0x01', displayName: 'One' }),
+      member({ address: '0x02', displayName: 'Two' }),
+    ]
+    assert.equal(filterMembers(members, { ...NO_FILTER, search: '' }).length, 2)
+    assert.equal(filterMembers(members, { ...NO_FILTER, search: '   ' }).length, 2)
+  })
+})
+
+describe('filterMembers — role', () => {
+  test('"all" shows members regardless of role', () => {
+    const members = [
+      member({ address: '0x01', roles: ['member'] }),
+      member({ address: '0x02', roles: ['admin'] }),
+    ]
+    assert.equal(filterMembers(members, { ...NO_FILTER, role: 'all' }).length, 2)
+  })
+
+  test('a specific role excludes members who do not have it', () => {
+    const moderator = member({ address: '0x01', roles: ['moderator'] })
+    const plainMember = member({ address: '0x02', roles: ['member'] })
+    const result = filterMembers([moderator, plainMember], { ...NO_FILTER, role: 'moderator' })
+    assert.deepEqual(result.map((m) => m.address), [moderator.address])
+  })
+
+  test('matches when the role is any one of a member\'s multiple roles', () => {
+    const multiRole = member({ address: '0x01', roles: ['member', 'admin'] })
+    const result = filterMembers([multiRole], { ...NO_FILTER, role: 'admin' })
+    assert.equal(result.length, 1)
+  })
+
+  test('a member with an empty roles array never matches a specific role filter, but matches "all"', () => {
+    const noRoles = member({ address: '0x01', roles: [] })
+    assert.equal(filterMembers([noRoles], { ...NO_FILTER, role: 'member' }).length, 0)
+    assert.equal(filterMembers([noRoles], { ...NO_FILTER, role: 'all' }).length, 1)
+    assert.doesNotThrow(() => memberMatchesFilters(noRoles, { ...NO_FILTER, role: 'admin' }))
+  })
+})
+
+describe('filterMembers — tier', () => {
+  test('"all" shows members regardless of tier', () => {
+    const members = [member({ address: '0x01', tier: 'free' }), member({ address: '0x02', tier: 'pro' })]
+    assert.equal(filterMembers(members, { ...NO_FILTER, tier: 'all' }).length, 2)
+  })
+
+  test('a specific tier matches exactly and excludes other tiers', () => {
+    const pro = member({ address: '0x01', tier: 'pro' })
+    const free = member({ address: '0x02', tier: 'free' })
+    const result = filterMembers([pro, free], { ...NO_FILTER, tier: 'pro' })
+    assert.deepEqual(result.map((m) => m.address), [pro.address])
+  })
+
+  test('an unrecognized tier value is excluded from a specific filter (never reclassified) but matches "all"', () => {
+    const weirdTier = member({ address: '0x01', tier: 'unknown-tier' as unknown as MemberRow['tier'] })
+    assert.equal(filterMembers([weirdTier], { ...NO_FILTER, tier: 'free' }).length, 0)
+    assert.equal(filterMembers([weirdTier], { ...NO_FILTER, tier: 'pro' }).length, 0)
+    assert.equal(filterMembers([weirdTier], { ...NO_FILTER, tier: 'all' }).length, 1)
+  })
+})
+
+describe('filterMembers — combined filters (AND across groups)', () => {
+  test('a member must satisfy search, role, and tier simultaneously', () => {
+    const target = member({ address: '0x0000000000000000000000000000000000000001', displayName: 'Ada Lovelace', roles: ['admin'], tier: 'pro' })
+    const wrongRole = member({ address: '0x0000000000000000000000000000000000000002', displayName: 'Ada Clone', roles: ['member'], tier: 'pro' })
+    const wrongTier = member({ address: '0x0000000000000000000000000000000000000003', displayName: 'Ada Twin', roles: ['admin'], tier: 'free' })
+    const wrongSearch = member({ address: '0x0000000000000000000000000000000000000004', displayName: 'Grace Hopper', roles: ['admin'], tier: 'pro' })
+
+    const result = filterMembers([target, wrongRole, wrongTier, wrongSearch], {
+      search: 'ada lovelace',
+      role: 'admin',
+      tier: 'pro',
+    })
+
+    assert.deepEqual(result.map((m) => m.address), [target.address])
+  })
+
+  test('produces an empty result when no member satisfies every active filter', () => {
+    const members = [
+      member({ address: '0x01', roles: ['member'], tier: 'free' }),
+      member({ address: '0x02', roles: ['admin'], tier: 'standard' }),
+    ]
+    const result = filterMembers(members, { search: '', role: 'admin', tier: 'free' })
+    assert.deepEqual(result, [])
+  })
+})
+
+describe('filterMembers — ordering and immutability', () => {
+  test('preserves the original relative order of surviving members', () => {
+    const members = [
+      member({ address: '0x03', roles: ['member'] }),
+      member({ address: '0x01', roles: ['member'] }),
+      member({ address: '0x02', roles: ['member'] }),
+    ]
+    const result = filterMembers(members, NO_FILTER)
+    assert.deepEqual(result.map((m) => m.address), ['0x03', '0x01', '0x02'])
+  })
+
+  test('does not mutate the input array or its members', () => {
+    const members = [member({ address: '0x01', roles: ['member'] }), member({ address: '0x02', roles: ['admin'] })]
+    const snapshot = JSON.parse(JSON.stringify(members))
+    const result = filterMembers(members, { ...NO_FILTER, role: 'admin' })
+    assert.deepEqual(members, snapshot)
+    assert.notEqual(result, members)
+  })
+})
+
+describe('filterMembers — live-style data with missing optional fields', () => {
+  test('a member with no displayName does not crash and only matches by address', () => {
+    const noName: MemberRow = { address: '0x0000000000000000000000000000000000000abc', roles: ['member'], tier: 'free', active: true }
+    assert.doesNotThrow(() => filterMembers([noName], { ...NO_FILTER, search: 'abc' }))
+    assert.equal(filterMembers([noName], { ...NO_FILTER, search: 'abc' }).length, 1)
+    assert.equal(filterMembers([noName], { ...NO_FILTER, search: 'nonexistent-name' }).length, 0)
+  })
+
+  test('a member with roles omitted at runtime (backend shape drift) does not crash', () => {
+    const malformed = { address: '0x01', tier: 'free', active: true } as unknown as MemberRow
+    assert.doesNotThrow(() => filterMembers([malformed], { ...NO_FILTER, role: 'member' }))
+    assert.equal(filterMembers([malformed], { ...NO_FILTER, role: 'member' }).length, 0)
+  })
+})
diff --git a/test/mock-members-variety.test.ts b/test/mock-members-variety.test.ts
new file mode 100644
index 0000000..b5acc59
--- /dev/null
+++ b/test/mock-members-variety.test.ts
@@ -0,0 +1,45 @@
+import './setup-env'
+import { describe, test } from 'node:test'
+import * as assert from 'node:assert/strict'
+import { MockAccessApi } from '../lib/api/mock'
+import { ROLE_FILTER_OPTIONS, TIER_FILTER_OPTIONS } from '../lib/members/filter-members'
+import type { MemberRow } from '../lib/api/types'
+
+describe('mock member seed data variety (search/filter feature)', () => {
+  test('listMembers() exposes a displayName for search-by-name to match against', async () => {
+    const api = new MockAccessApi()
+    const result = await api.listMembers()
+    assert.ok(Array.isArray(result))
+    const withNames = (result as MemberRow[]).filter((m) => typeof m.displayName === 'string' && m.displayName.length > 0)
+    assert.ok(withNames.length > 0, 'expected at least some seeded members to carry a displayName')
+  })
+
+  test('seed data covers every canonical tier', async () => {
+    const api = new MockAccessApi()
+    const result = (await api.listMembers()) as MemberRow[]
+    for (const tier of TIER_FILTER_OPTIONS) {
+      assert.ok(result.some((m) => m.tier === tier), `expected at least one seeded member with tier "${tier}"`)
+    }
+  })
+
+  test('seed data covers every canonical role', async () => {
+    const api = new MockAccessApi()
+    const result = (await api.listMembers()) as MemberRow[]
+    for (const role of ROLE_FILTER_OPTIONS) {
+      assert.ok(result.some((m) => m.roles.includes(role)), `expected at least one seeded member with role "${role}"`)
+    }
+  })
+
+  test('seed data includes at least one multi-role member', async () => {
+    const api = new MockAccessApi()
+    const result = (await api.listMembers()) as MemberRow[]
+    assert.ok(result.some((m) => m.roles.length > 1), 'expected at least one seeded member with more than one role')
+  })
+
+  test('seed addresses remain unique (no duplicates introduced)', async () => {
+    const api = new MockAccessApi()
+    const result = (await api.listMembers()) as MemberRow[]
+    const addresses = result.map((m) => m.address)
+    assert.equal(new Set(addresses).size, addresses.length)
+  })
+})
diff --git a/test/tsconfig.json b/test/tsconfig.json
index 08d7e69..e03fb02 100644
--- a/test/tsconfig.json
+++ b/test/tsconfig.json
@@ -67,8 +67,11 @@
     "../lib/validation/profile.ts",
     "../lib/api/analytics.ts",
     "../components/analytics/*.tsx",
-    "../app/analytics/*.tsx"
+    "../app/analytics/*.tsx",
     "../lib/integration-client.ts",
-    "../lib/integration/resilientCall.ts"
+    "../lib/integration/resilientCall.ts",
+    "../lib/hooks/*.ts",
+    "../lib/members/*.ts",
+    "../components/admin/*.tsx"
   ]
 }