feat: add bulk invite to jury group page + widen member search role filter

Adds bulkInviteMembers procedure to juryGroup router and integrates
BulkInviteForm into the jury group members tab. Also removes the
JURY_MEMBER-only filter from the user search — any user can now be
added to a jury group.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

src/server/routers/juryGroup.ts

@@ -3,6 +3,8 @@ import { TRPCError } from '@trpc/server'
 import { Prisma } from '@prisma/client'
 import { router, adminProcedure, protectedProcedure } from '../trpc'
 import { logAudit } from '@/server/utils/audit'
+import { generateInviteToken, getInviteExpiryMs } from '@/server/utils/invite'
+import { sendJuryInvitationEmail } from '@/lib/email'
 
 const capModeEnum = z.enum(['HARD', 'SOFT', 'NONE'])
 
@@ -393,4 +395,113 @@ export const juryGroupRouter = router({
         })),
       }
     }),
+
+  /**
+   * Bulk invite new users as jury group members — creates accounts, assigns JURY_MEMBER role, sends invite emails
+   */
+  bulkInviteMembers: adminProcedure
+    .input(
+      z.object({
+        juryGroupId: z.string(),
+        role: z.enum(['CHAIR', 'MEMBER', 'OBSERVER']).default('MEMBER'),
+        invitees: z.array(
+          z.object({
+            name: z.string().optional(),
+            email: z.string().email(),
+          })
+        ).min(1).max(50),
+      })
+    )
+    .mutation(async ({ ctx, input }) => {
+      const group = await ctx.prisma.juryGroup.findUniqueOrThrow({
+        where: { id: input.juryGroupId },
+        select: { id: true, name: true },
+      })
+
+      const results: Array<{ email: string; status: 'created' | 'existing' | 'error'; error?: string }> = []
+
+      for (const invitee of input.invitees) {
+        try {
+          let user = await ctx.prisma.user.findUnique({
+            where: { email: invitee.email },
+            select: { id: true, status: true, role: true },
+          })
+
+          if (!user) {
+            const inviteToken = generateInviteToken()
+            const expiryMs = await getInviteExpiryMs(ctx.prisma)
+
+            user = await ctx.prisma.user.create({
+              data: {
+                email: invitee.email,
+                name: invitee.name || null,
+                role: 'JURY_MEMBER',
+                status: 'INVITED',
+                inviteToken,
+                inviteTokenExpiresAt: new Date(Date.now() + expiryMs),
+              },
+              select: { id: true, status: true, role: true },
+            })
+
+            const inviteUrl = `${process.env.NEXTAUTH_URL}/accept-invite?token=${inviteToken}`
+            try {
+              await sendJuryInvitationEmail(
+                invitee.email,
+                invitee.name || null,
+                inviteUrl,
+                group.name
+              )
+            } catch {
+              // Email failure shouldn't block the invite
+            }
+
+            results.push({ email: invitee.email, status: 'created' })
+          } else {
+            results.push({ email: invitee.email, status: 'existing' })
+          }
+
+          // Add as jury group member (skip if already added)
+          const existing = await ctx.prisma.juryGroupMember.findUnique({
+            where: {
+              juryGroupId_userId: { juryGroupId: input.juryGroupId, userId: user.id },
+            },
+          })
+          if (!existing) {
+            await ctx.prisma.juryGroupMember.create({
+              data: {
+                juryGroupId: input.juryGroupId,
+                userId: user.id,
+                role: input.role,
+              },
+            })
+          }
+        } catch (err) {
+          results.push({
+            email: invitee.email,
+            status: 'error',
+            error: err instanceof Error ? err.message : 'Unknown error',
+          })
+        }
+      }
+
+      await logAudit({
+        userId: ctx.user.id,
+        action: 'CREATE',
+        entityType: 'JuryGroupMember',
+        entityId: input.juryGroupId,
+        detailsJson: {
+          action: 'BULK_INVITE',
+          groupName: group.name,
+          count: input.invitees.length,
+          results,
+        },
+      })
+
+      return {
+        created: results.filter((r) => r.status === 'created').length,
+        existing: results.filter((r) => r.status === 'existing').length,
+        errors: results.filter((r) => r.status === 'error').length,
+        results,
+      }
+    }),
 })