create-nextblock 0.2.78 → 0.8.1

package/templates/nextblock-template/app/cms/settings/security/page.tsx

@@ -0,0 +1,13 @@
+// app/cms/settings/security/page.tsx
+import { getSecurityPanelData } from './actions';
+import SecurityPanel from './components/SecurityPanel';
+
+export default async function SecuritySettingsPage() {
+  const data = await getSecurityPanelData();
+
+  return (
+    <div className="max-w-4xl mx-auto space-y-6">
+      <SecurityPanel data={data} />
+    </div>
+  );
+}

package/templates/nextblock-template/app/cms/settings/taxes/page.tsx

@@ -0,0 +1,21 @@
+import { redirect } from 'next/navigation';
+import { verifyPackageOnline } from '@nextblock-cms/db/server';
+import { TaxesPage as TaxesPageUI } from '@nextblock-cms/ecommerce/server';
+
+export const metadata = {
+  title: 'Tax Settings | NextBlock™ CMS',
+};
+
+export default async function TaxesPageWrapper({
+  searchParams,
+}: {
+  searchParams?: Promise<{ success?: string }>;
+}) {
+  const isOnline = await verifyPackageOnline('ecommerce');
+
+  if (!isOnline) {
+    redirect('/cms/settings/packages');
+  }
+
+  return <TaxesPageUI searchParams={await searchParams} />;
+}

package/templates/nextblock-template/app/cms/shipping/page.tsx

@@ -0,0 +1,20 @@
+import { redirect } from 'next/navigation';
+import { verifyPackageOnline } from '@nextblock-cms/db/server';
+import { ShippingPage as ShippingPageUI } from '@nextblock-cms/ecommerce/server';
+
+export default async function ShippingPage({
+    searchParams,
+}: {
+    searchParams: Promise<{ success?: string }>;
+}) {
+    const [isOnline, resolvedSearchParams] = await Promise.all([
+        verifyPackageOnline('ecommerce'),
+        searchParams,
+    ]);
+
+    if (!isOnline) {
+        redirect('/cms/settings/packages');
+    }
+
+    return <ShippingPageUI searchParams={resolvedSearchParams} />;
+}

package/templates/nextblock-template/app/cms/users/[id]/edit/page.tsx

@@ -1,20 +1,23 @@
 // app/cms/users/[id]/edit/page.tsx
-import { createClient } from "@nextblock-cms/db/server";
-import UserForm from "../../components/UserForm";
-import { updateUserProfile } from "../../actions";
-import type { Database } from "@nextblock-cms/db";
-import { notFound } from "next/navigation";
-
-type Profile = Database['public']['Tables']['profiles']['Row'];
-type AuthUser = {
-    id: string;
-    email: string | undefined;
+import UserForm from "../../components/UserForm";
+import { updateUserProfile } from "../../actions";
+import type { Database } from "@nextblock-cms/db";
+import { notFound } from "next/navigation";
+import { getDefaultUserAddresses } from "@nextblock-cms/ecommerce/server";
+
+type Profile = Database['public']['Tables']['profiles']['Row'];
+type AuthUser = {
+    id: string;
+    email: string | undefined;
     created_at: string | undefined;
     last_sign_in_at: string | undefined;
 };
 
-async function getUserAndProfileData(userId: string): Promise<{ authUser: AuthUser; profile: Profile | null } | null> {
-  const supabase = createClient();
+async function getUserAndProfileData(userId: string): Promise<{
+  authUser: AuthUser;
+  profile: Profile | null;
+  addresses: Awaited<ReturnType<typeof getDefaultUserAddresses>>;
+} | null> {
 
   // Fetch user from auth.users
   // For admin operations, you might need a service_role client to fetch any user.
@@ -40,8 +43,8 @@ async function getUserAndProfileData(userId: string): Promise<{ authUser: AuthUs
     return null;
   }
 
-  // Fetch profile from public.profiles
-  const { data: profileData, error: profileError } = await supabase
+  // Fetch profile from public.profiles using Service Role to bypass RLS
+  const { data: profileData, error: profileError } = await serviceSupabase
     .from("profiles")
     .select("*")
     .eq("id", userId)
@@ -59,8 +62,10 @@ async function getUserAndProfileData(userId: string): Promise<{ authUser: AuthUs
       last_sign_in_at: authUserData.last_sign_in_at,
   };
 
-  return { authUser: simplifiedAuthUser, profile: profileData as Profile | null };
-}
+  const addresses = await getDefaultUserAddresses(userId, serviceSupabase as any);
+
+  return { authUser: simplifiedAuthUser, profile: profileData as Profile | null, addresses };
+}
 
 export default async function EditUserPage(props: { params: Promise<{ id: string }> }) {
   const params = await props.params;
@@ -78,14 +83,14 @@ export default async function EditUserPage(props: { params: Promise<{ id: string
   const updateUserActionWithId = updateUserProfile.bind(null, userId);
 
   return (
-    <div className="max-w-xl mx-auto">
+    <div className="max-w-4xl mx-auto">
       <h1 className="text-2xl font-bold mb-6">Edit User: {userData.authUser.email}</h1>
-      <UserForm
-        userToEditAuth={userData.authUser}
-        userToEditProfile={userData.profile}
-        formAction={updateUserActionWithId}
-        actionButtonText="Update User Profile"
-      />
+      <UserForm
+        userToEditAuth={userData.authUser}
+        userToEditProfile={userData.profile}
+        userToEditAddresses={userData.addresses}
+        formAction={updateUserActionWithId}
+      />
     </div>
   );
 }

package/templates/nextblock-template/app/cms/users/actions.ts

@@ -1,10 +1,13 @@
 // app/cms/users/actions.ts
-"use server";
-
-import { createClient } from "@nextblock-cms/db/server";
-import { revalidatePath } from "next/cache";
-import { redirect } from "next/navigation";
-import type { Database } from "@nextblock-cms/db";
+"use server";
+
+import { createClient } from "@nextblock-cms/db/server";
+import { revalidatePath } from "next/cache";
+import { redirect } from "next/navigation";
+import type { Database } from "@nextblock-cms/db";
+import { normalizeCustomerAddress } from "@nextblock-cms/ecommerce";
+import { upsertDefaultUserAddresses } from "@nextblock-cms/ecommerce/server";
+import { createClient as createSupabaseClient } from '@supabase/supabase-js';
 
 type UserRole = Database['public']['Enums']['user_role'];
 
@@ -29,25 +32,73 @@ async function verifyAdmin(supabase: ReturnType<typeof createClient>): Promise<{
   return { isAdmin: true, userId: user.id };
 }
 
-type UpdateUserProfilePayload = {
-  role: UserRole;
-  username?: string | null;
-  full_name?: string | null;
-  // Add other editable profile fields here if needed
-};
-
-export async function updateUserProfile(userIdToUpdate: string, formData: FormData) {
-  const supabase = createClient();
-  const adminCheck = await verifyAdmin(supabase);
+type UpdateUserProfilePayload = {
+  role: UserRole;
+  full_name?: string | null;
+  avatar_url?: string | null;
+  website?: string | null;
+  github_username?: string | null;
+  phone?: string | null;
+};
+
+function createServiceRoleClient() {
+  const supabaseUrl = process.env.NEXT_PUBLIC_SUPABASE_URL;
+  const serviceRoleKey = process.env.SUPABASE_SERVICE_ROLE_KEY;
+
+  if (!supabaseUrl || !serviceRoleKey) {
+    throw new Error('Missing required environment variables');
+  }
+
+  return createSupabaseClient(supabaseUrl, serviceRoleKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false,
+    },
+  });
+}
+
+export async function updateUserProfile(userIdToUpdate: string, formData: FormData) {
+  const supabase = createClient();
+  const adminCheck = await verifyAdmin(supabase);
   if (!adminCheck.isAdmin) {
     return { error: adminCheck.error || "Unauthorized" };
   }
 
-  const rawFormData = {
-    role: formData.get("role") as UserRole,
-    username: formData.get("username") as string || null,
-    full_name: formData.get("full_name") as string || null,
-  };
+  const parseAddressField = (fieldName: string) => {
+    const rawValue = formData.get(fieldName) as string | null;
+    if (!rawValue) {
+      return null;
+    }
+
+    try {
+      return normalizeCustomerAddress(JSON.parse(rawValue));
+    } catch {
+      throw new Error(`Invalid JSON for ${fieldName}.`);
+    }
+  };
+
+  let billingAddressJSON = null;
+  let shippingAddressJSON = null;
+
+  try {
+    billingAddressJSON = parseAddressField("billing_address");
+    shippingAddressJSON = parseAddressField("shipping_address");
+  } catch (error: any) {
+    return { error: error.message };
+  }
+
+  if (formData.get("use_billing_for_shipping") === "true") {
+    shippingAddressJSON = billingAddressJSON;
+  }
+
+  const rawFormData = {
+    role: formData.get("role") as UserRole,
+    full_name: formData.get("full_name") as string || null,
+    avatar_url: formData.get("avatar_url") as string || null,
+    website: formData.get("website") as string || null,
+    github_username: formData.get("github_username") as string || null,
+    phone: formData.get("phone") as string || null,
+  };
 
   if (!rawFormData.role) {
     return { error: "Role is a required field." };
@@ -69,26 +120,40 @@ export async function updateUserProfile(userIdToUpdate: string, formData: FormDa
   }
 
 
-  const profileData: UpdateUserProfilePayload = {
-    role: rawFormData.role,
-    username: rawFormData.username,
-    full_name: rawFormData.full_name,
-  };
-
-  const { error } = await supabase
-    .from("profiles")
-    .update(profileData)
-    .eq("id", userIdToUpdate);
+  const profileData: UpdateUserProfilePayload = {
+    role: rawFormData.role,
+    full_name: rawFormData.full_name,
+    avatar_url: rawFormData.avatar_url,
+    website: rawFormData.website,
+    github_username: rawFormData.github_username,
+    phone: rawFormData.phone,
+  };
+
+  const adminSupabase = createServiceRoleClient();
+
+  const { error } = await adminSupabase
+    .from("profiles")
+    .update(profileData)
+    .eq("id", userIdToUpdate);
 
   if (error) {
-    console.error("Error updating user profile:", error);
-    return { error: `Failed to update profile: ${error.message}` };
-  }
-
-  revalidatePath("/cms/users");
-  revalidatePath(`/cms/users/${userIdToUpdate}/edit`);
-  redirect(`/cms/users/${userIdToUpdate}/edit?success=User profile updated successfully`);
-}
+    console.error("Error updating user profile:", error);
+    return { error: `Failed to update profile: ${error.message}` };
+  }
+
+  await upsertDefaultUserAddresses({
+    userId: userIdToUpdate,
+    billingAddress: billingAddressJSON,
+    shippingAddress: shippingAddressJSON,
+    client: adminSupabase,
+  });
+
+  revalidatePath("/cms/users");
+  revalidatePath(`/cms/users/${userIdToUpdate}/edit`);
+  revalidatePath("/profile");
+  revalidatePath("/checkout");
+  redirect(`/cms/users/${userIdToUpdate}/edit?success=User profile updated successfully`);
+}
 
 export async function deleteUserAndProfile(userIdToDelete: string) {
 
@@ -153,4 +218,4 @@ export async function deleteUserAndProfile(userIdToDelete: string) {
   // The `profiles` table has ON DELETE CASCADE for the user ID, so it should be deleted automatically.
   revalidatePath("/cms/users");
   redirect("/cms/users?success=User deleted successfully");
-}
+}

package/templates/nextblock-template/app/cms/users/components/DeleteUserButton.tsx

@@ -5,7 +5,7 @@ import React, { useState, useTransition } from "react";
 import { DropdownMenuItem } from "@nextblock-cms/ui";
 import { Trash2, ShieldAlert } from "lucide-react";
 import { deleteUserAndProfile } from "../actions";
-import { ConfirmationModal } from "@/app/cms/components/ConfirmationModal";
+import { ConfirmationModal } from '../../components/ConfirmationModal';
 
 export function DeleteUserButtonClient({
   userId,

package/templates/nextblock-template/app/cms/users/components/UserForm.tsx

@@ -1,158 +1,71 @@
-// app/cms/users/components/UserForm.tsx
-"use client";
-
-import { useEffect, useState, useTransition, useRef } from "react";
-import { useHotkeys } from "@/hooks/use-hotkeys";
-import { useRouter, useSearchParams } from "next/navigation";
-import { Button } from "@nextblock-cms/ui";
-import { Spinner, Alert, AlertDescription, Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@nextblock-cms/ui";
-import { Info } from "lucide-react";
-import { Input } from "@nextblock-cms/ui";
-import { Label } from "@nextblock-cms/ui";
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from "@nextblock-cms/ui";
-import type { Database } from "@nextblock-cms/db";
-import { useAuth } from "@/context/AuthContext";
-
+"use client";
+
+import { CustomerProfileForm, ExtendedProfileUpdateData, addressesMatch, type CustomerAddressInput } from "@nextblock-cms/ecommerce";
+import MediaPickerDialog from "../../media/components/MediaPickerDialog";
+import type { Database } from "@nextblock-cms/db";
+import { useSearchParams } from "next/navigation";
+
+
 type Profile = Database['public']['Tables']['profiles']['Row'];
-type UserRole = Database['public']['Enums']['user_role'];
-type AuthUser = {
-    id: string;
-    email: string | undefined;
-    created_at: string | undefined;
-    last_sign_in_at: string | undefined;
-};
-
-interface UserFormProps {
-  userToEditAuth: AuthUser; // Auth details (email, id) - email usually not editable here
-  userToEditProfile: Profile | null; // Profile details (role, username, etc.)
-  formAction: (formData: FormData) => Promise<{ error?: string } | void>;
-  actionButtonText?: string;
-}
-
-export default function UserForm({
-  userToEditAuth,
-  userToEditProfile,
-  formAction,
-  actionButtonText = "Save Changes",
-}: UserFormProps) {
-  const router = useRouter();
-  const searchParams = useSearchParams();
-  const [isPending, startTransition] = useTransition();
-  const { isAdmin, isLoading: authLoading } = useAuth(); // For client-side guard
-
-  const [role, setRole] = useState<UserRole>(userToEditProfile?.role || "USER");
-  const [username, setUsername] = useState(userToEditProfile?.username || "");
-  const [fullName, setFullName] = useState(userToEditProfile?.full_name || "");
-  // Email is typically not changed here by an admin, it's part of auth.users managed by user or super-admin
-  const email = userToEditAuth.email || "N/A";
-
-  const [formMessage, setFormMessage] = useState<{ type: 'success' | 'error', text: string } | null>(null);
-
- useEffect(() => {
-    const successMessage = searchParams.get('success');
-    const errorMessage = searchParams.get('error');
-    if (successMessage) {
-      setFormMessage({ type: 'success', text: successMessage });
-      // Optionally clear the query param from URL
-      // router.replace(pathname, undefined, { shallow: true }); // if using next/router
-    } else if (errorMessage) {
-      setFormMessage({ type: 'error', text: errorMessage });
-    }
-  }, [searchParams, router]);
-
 
-  const handleSubmit = async (event: React.FormEvent<HTMLFormElement>) => {
-    event.preventDefault();
-    setFormMessage(null);
-    const formData = new FormData(event.currentTarget);
-    // Add user ID to form data if needed by action, or pass it directly
-    // formData.append("userId", userToEditAuth.id);
-
-    startTransition(async () => {
-      const result = await formAction(formData); // The action is already bound with userId
-      if (result?.error) {
-        setFormMessage({ type: 'error', text: result.error });
-      }
-      // Success is handled by redirect with query param in server action
-    });
-  };
-
-  if (authLoading) return <div>Loading...</div>;
-  if (!isAdmin) return <div>Access Denied. Admin role required.</div>;
-
-  const userRoles: UserRole[] = ['USER', 'WRITER', 'ADMIN'];
-
-  const formRef = useRef<HTMLFormElement>(null);
-  useHotkeys('ctrl+s', () => formRef.current?.requestSubmit());
+interface UserFormProps {
+  userToEditAuth: { email: string | undefined; id: string };
+  userToEditProfile: Profile | null;
+  userToEditAddresses: {
+    billingAddress: CustomerAddressInput | null;
+    shippingAddress: CustomerAddressInput | null;
+  };
+  formAction: (formData: FormData) => Promise<{ error?: string } | void>;
+}
+
+export default function UserForm({ userToEditAuth, userToEditProfile, userToEditAddresses, formAction }: UserFormProps) {
+  const searchParams = useSearchParams();
+  const successMsg = searchParams.get('success');
+
+  const handleAdminSave = async (data: ExtendedProfileUpdateData) => {
+      const formData = new FormData();
+      // Only append if defined to avoid null string issues if server doesn't handle them, 
+      // but server action expects strings or checks presence.
+      // Standard practice: append everything that has a value.
+      if (data.full_name !== undefined) formData.append('full_name', data.full_name || '');
+      if (data.avatar_url !== undefined) formData.append('avatar_url', data.avatar_url || '');
+      if (data.website !== undefined) formData.append('website', data.website || '');
+      if (data.github_username !== undefined) formData.append('github_username', data.github_username || '');
+      if (data.phone !== undefined) formData.append('phone', data.phone || '');
+      if (data.role !== undefined) formData.append('role', data.role);
+      
+      formData.append('billing_address', JSON.stringify(data.billing_address ?? null));
+      formData.append('shipping_address', JSON.stringify(data.shipping_address ?? null));
+      formData.append('use_billing_for_shipping', data.use_billing_for_shipping ? 'true' : 'false');
+
+      return await formAction(formData);
+  };
 
   return (
-    <form ref={formRef} onSubmit={handleSubmit} className="space-y-6">
-      {formMessage && (
-        <Alert variant={formMessage.type === 'success' ? 'success' : 'destructive'}>
-           <AlertDescription>{formMessage.text}</AlertDescription>
-        </Alert>
-      )}
-      <div>
-        <Label htmlFor="email">Email (Read-only)</Label>
-        <Input id="email" name="email" value={email} readOnly disabled className="mt-1 bg-muted/50" />
-      </div>
-
-      <div>
-        <Label htmlFor="username">Username</Label>
-        <Input id="username" name="username" value={username} onChange={(e) => setUsername(e.target.value)} className="mt-1" />
-      </div>
-
-      <div>
-        <Label htmlFor="full_name">Full Name</Label>
-        <Input id="full_name" name="full_name" value={fullName} onChange={(e) => setFullName(e.target.value)} className="mt-1" />
-      </div>
-
-      <div>
-        <div className="flex items-center gap-2 mb-2">
-          <Label htmlFor="role">Role</Label>
-          <TooltipProvider>
-            <Tooltip>
-              <TooltipTrigger asChild>
-                <Info className="h-4 w-4 text-muted-foreground opacity-70 cursor-pointer" />
-              </TooltipTrigger>
-              <TooltipContent className="max-w-xs">
-                <p><strong>ADMIN:</strong> Full access to settings and content.</p>
-                <p><strong>WRITER:</strong> Can create/edit content, no settings access.</p>
-                <p><strong>USER:</strong> Read-only access.</p>
-              </TooltipContent>
-            </Tooltip>
-          </TooltipProvider>
-        </div>
-        <Select name="role" value={role} onValueChange={(value) => setRole(value as UserRole)} required>
-          <SelectTrigger className="mt-1"><SelectValue placeholder="Select role" /></SelectTrigger>
-          <SelectContent>
-            {userRoles.map((r) => (
-              <SelectItem key={r} value={r}>{r.charAt(0) + r.slice(1).toLowerCase()}</SelectItem>
-            ))}
-          </SelectContent>
-        </Select>
-      </div>
-
-      <div className="flex justify-end space-x-3 pt-4">
-        <Button type="button" variant="outline" onClick={() => router.push("/cms/users")} disabled={isPending}>
-          Cancel
-        </Button>
-        <Button type="submit" disabled={isPending || authLoading}>
-          {isPending ? (
-            <>
-              <Spinner className="mr-2 h-4 w-4" /> Saving...
-            </>
-          ) : (
-            actionButtonText
-          )}
-        </Button>
-      </div>
-    </form>
+    <div className="max-w-4xl mx-auto">
+      <CustomerProfileForm 
+          initialData={{
+              full_name: userToEditProfile?.full_name || '',
+              avatar_url: userToEditProfile?.avatar_url || '',
+              website: userToEditProfile?.website || '',
+              github_username: userToEditProfile?.github_username || '',
+              phone: userToEditProfile?.phone || '',
+              role: userToEditProfile?.role || 'USER',
+              billing_address: userToEditAddresses.billingAddress,
+              shipping_address: userToEditAddresses.shippingAddress,
+              use_billing_for_shipping:
+                !userToEditAddresses.shippingAddress ||
+                addressesMatch(
+                  userToEditAddresses.billingAddress,
+                  userToEditAddresses.shippingAddress
+                ),
+          }}
+          MediaPickerComponent={MediaPickerDialog}
+          isAdmin={true}
+          email={userToEditAuth.email}
+          onAction={handleAdminSave}
+          initialSuccessMessage={successMsg}
+      />
+    </div>
   );
 }

package/templates/nextblock-template/app/cms/users/page.tsx

@@ -44,7 +44,12 @@ async function getUsersData(currentAdminId: string): Promise<UserWithProfile[]>
     throw new Error('Missing required environment variables');
   }
   
-  const supabaseAdmin = createServiceRoleClient(supabaseUrl, serviceRoleKey);
+  const supabaseAdmin = createServiceRoleClient(supabaseUrl, serviceRoleKey, {
+    auth: {
+      autoRefreshToken: false,
+      persistSession: false
+    }
+  });
 
   const { data: { users: authUsers }, error: usersError } = await supabaseAdmin.auth.admin.listUsers({
       page: 1,
@@ -52,19 +57,19 @@ async function getUsersData(currentAdminId: string): Promise<UserWithProfile[]>
   });
 
   if (usersError) {
-    console.error("Error fetching auth users:", usersError);
+    console.error("Error fetching auth users:", JSON.stringify(usersError, null, 2));
     return [];
   }
   if (!authUsers) return [];
 
   // Fetch all profiles
-  const supabase = createClient(); // Standard client for profile fetching (RLS applies)
-  const { data: profiles, error: profilesError } = await supabase
+  // Use admin client to bypass RLS policies so we can see all user profiles
+  const { data: profiles, error: profilesError } = await supabaseAdmin
     .from("profiles")
     .select("*");
 
   if (profilesError) {
-    console.error("Error fetching profiles:", profilesError);
+    console.error("Error fetching profiles:", JSON.stringify(profilesError, null, 2));
     // Continue without profiles if there's an error, or handle differently
   }
 
@@ -82,7 +87,7 @@ async function getUsersData(currentAdminId: string): Promise<UserWithProfile[]>
       authUser: simplifiedAuthUser,
       profile: profilesMap.get(authUser.id) || null,
     };
-  }).filter(user => user.authUser.id !== currentAdminId); // Filter out the current admin from the list
+  });
 }
 
 export default async function CmsUsersListPage() {
@@ -123,8 +128,8 @@ export default async function CmsUsersListPage() {
               <TableRow>
                 <TableHead className="w-[80px]">Avatar</TableHead>
                 <TableHead>Email</TableHead>
-                <TableHead>Username</TableHead>
                 <TableHead>Full Name</TableHead>
+                <TableHead>GitHub</TableHead>
                 <TableHead>Role</TableHead>
                 <TableHead>Joined</TableHead>
                 <TableHead className="text-right w-[80px]">Actions</TableHead>
@@ -135,13 +140,13 @@ export default async function CmsUsersListPage() {
                 <TableRow key={authUser.id}>
                   <TableCell>
                      <Avatar className="h-9 w-9">
-                        <AvatarImage src={profile?.avatar_url || undefined} alt={profile?.username || authUser.email} />
+                        <AvatarImage src={profile?.avatar_url || undefined} alt={profile?.full_name || authUser.email} />
                         <AvatarFallback>{authUser.email?.charAt(0).toUpperCase() || 'U'}</AvatarFallback>
                     </Avatar>
                   </TableCell>
                   <TableCell className="font-medium">{authUser.email}</TableCell>
-                  <TableCell className="text-muted-foreground">{profile?.username || "N/A"}</TableCell>
                   <TableCell className="text-muted-foreground">{profile?.full_name || "N/A"}</TableCell>
+                  <TableCell className="text-muted-foreground">{profile?.github_username || "-"}</TableCell>
                   <TableCell>
                     <Badge variant={
                         profile?.role === "ADMIN" ? "destructive" :
@@ -156,7 +161,7 @@ export default async function CmsUsersListPage() {
                   <TableCell className="text-right">
                     <DropdownMenu>
                       <DropdownMenuTrigger asChild>
-                        <Button variant="ghost" size="icon" disabled={authUser.id === currentAdmin.id}>
+                        <Button id={`user-trigger-${authUser.id}`} variant="ghost" size="icon">
                           <MoreHorizontal className="h-4 w-4" />
                           <span className="sr-only">User actions</span>
                         </Button>

package/templates/nextblock-template/app/globals.css

@@ -3,6 +3,15 @@
 @import 'tailwindcss/theme';
 @import 'tailwindcss/utilities';
 
+/*─────────────────────────────────────────────────────────────────────────────
+  Dynamic class safelist for custom blocks.
+  Custom block layouts store Tailwind classes in the database (authored by
+  Cortex AI or by hand), which Tailwind cannot discover by scanning source.
+  The color utility families are force-generated by listing them as literal
+  tokens in apps/nextblock/lib/custom-block-safelist.ts (picked up by the Tailwind
+  content scanner). Regenerate via: node tools/scripts/gen-custom-block-safelist.js
+─────────────────────────────────────────────────────────────────────────────*/
+
 /*─────────────────────────────────────────────────────────────────────────────
   globals.css — modularized
 ─────────────────────────────────────────────────────────────────────────────*/