diff --git a/app/actions.tsx b/app/actions.tsx
index 7871933a..50e985bf 100644
--- a/app/actions.tsx
+++ b/app/actions.tsx
@@ -7,7 +7,7 @@ import {
   getMutableAIState
 } from 'ai/rsc'
 import { CoreMessage, ToolResultPart } from 'ai'
-import { nanoid } from 'nanoid'
+import { nanoid } from '@/lib/utils'
 import type { FeatureCollection } from 'geojson'
 import { Spinner } from '@/components/ui/spinner'
 import { Section } from '@/components/section'
diff --git a/app/page.tsx b/app/page.tsx
index 051e54bb..e098417e 100644
--- a/app/page.tsx
+++ b/app/page.tsx
@@ -1,5 +1,5 @@
 import { Chat } from '@/components/chat'
-import {nanoid } from 'nanoid'
+import { nanoid } from '@/lib/utils'
 import { AI } from './actions'
 
 export const maxDuration = 60
diff --git a/components/chat-panel.tsx b/components/chat-panel.tsx
index 012db1bd..ca2fbc6f 100644
--- a/components/chat-panel.tsx
+++ b/components/chat-panel.tsx
@@ -8,7 +8,7 @@ import { UserMessage } from './user-message'
 import { Button } from './ui/button'
 import { ArrowRight, Plus, Paperclip, X, Sprout } from 'lucide-react'
 import Textarea from 'react-textarea-autosize'
-import { nanoid } from 'nanoid'
+import { nanoid } from '@/lib/utils'
 import { useSettingsStore } from '@/lib/store/settings'
 import { PartialRelated } from '@/lib/schema/related'
 import { getSuggestions } from '@/lib/actions/suggest'
diff --git a/components/header-search-button.tsx b/components/header-search-button.tsx
index 1923e596..04896457 100644
--- a/components/header-search-button.tsx
+++ b/components/header-search-button.tsx
@@ -7,7 +7,7 @@ import { Search } from 'lucide-react'
 import { useMap } from './map/map-context'
 import { useActions, useUIState } from 'ai/rsc'
 import { AI } from '@/app/actions'
-import { nanoid } from 'nanoid'
+import { nanoid } from '@/lib/utils'
 import { UserMessage } from './user-message'
 import { toast } from 'sonner'
 import { useSettingsStore } from '@/lib/store/settings'
diff --git a/components/history-list.tsx b/components/history-list.tsx
index 5713bd2e..5b67c538 100644
--- a/components/history-list.tsx
+++ b/components/history-list.tsx
@@ -2,31 +2,13 @@ import React, { cache } from 'react';
 import HistoryItem from './history-item';
 import { ClearHistory } from './clear-history';
 import { getChats } from '@/lib/actions/chat';
-
-// Define the type for the chat data returned by getChats
-type ChatData = {
-  userId: string;
-  id: string;
-  title: string;
-  createdAt: Date;
-  visibility: string | null;
-};
-
-// Define the Chat type expected by HistoryItem
-type Chat = {
-  userId: string;
-  id: string;
-  title: string;
-  createdAt: Date;
-  visibility: string | null;
-  path: string;
-};
+import type { Chat as DrizzleChat } from '@/lib/actions/chat-db';
 
 type HistoryListProps = {
   userId?: string;
 };
 
-const loadChats = cache(async (userId?: string): Promise<ChatData[] | null> => {
+const loadChats = cache(async (userId?: string): Promise<DrizzleChat[] | null> => {
   return await getChats(userId);
 });
 
@@ -52,12 +34,12 @@ export async function HistoryList({ userId }: HistoryListProps) {
               No search history
             </div>
           ) : (
-            chats.map((chat: ChatData) => (
+            chats.map((chat: DrizzleChat) => (
               <HistoryItem
                 key={chat.id}
                 chat={{
                   ...chat,
-                  path: '', // Provide default or derived value
+                  path: chat.path || `/search/${chat.id}`,
                 }}
               />
             ))
diff --git a/components/resolution-carousel.tsx b/components/resolution-carousel.tsx
index e6fa46c8..1b28cbf7 100644
--- a/components/resolution-carousel.tsx
+++ b/components/resolution-carousel.tsx
@@ -12,7 +12,7 @@ import { ResolutionImage } from './resolution-image'
 import { Button } from './ui/button'
 import { useActions, useUIState } from 'ai/rsc'
 import { AI } from '@/app/actions'
-import { nanoid } from 'nanoid'
+import { nanoid } from '@/lib/utils'
 import { UserMessage } from './user-message'
 import { toast } from 'sonner'
 import { CompareSlider } from './compare-slider'
diff --git a/components/search-related.tsx b/components/search-related.tsx
index a03901c5..3dbb49c8 100644
--- a/components/search-related.tsx
+++ b/components/search-related.tsx
@@ -12,7 +12,7 @@ import {
 import { AI } from '@/app/actions'
 import { UserMessage } from './user-message'
 import { PartialRelated } from '@/lib/schema/related'
-import { nanoid } from 'nanoid'
+import { nanoid } from '@/lib/utils'
 
 export interface SearchRelatedProps {
   relatedQueries: StreamableValue<PartialRelated, any>
diff --git a/components/settings/components/settings.tsx b/components/settings/components/settings.tsx
index 0d201916..7a526e18 100644
--- a/components/settings/components/settings.tsx
+++ b/components/settings/components/settings.tsx
@@ -1,19 +1,18 @@
-"use client"
-
-import { useState, useEffect } from "react"
-import { useRouter } from "next/navigation"
-import { zodResolver } from "@hookform/resolvers/zod"
-import { useForm } from "react-hook-form"
-import { z } from "zod"
-import * as Tabs from "@radix-ui/react-tabs";
-import { Button } from "@/components/ui/button"
-import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card"
-import { FormProvider, UseFormReturn } from "react-hook-form"; import React from "react";
-import { Loader2, Save, RotateCcw } from "lucide-react"
-import { motion, AnimatePresence } from "framer-motion"
-// Or, if the file does not exist, create it as shown below.
-import { SystemPromptForm } from "./system-prompt-form"
-import { ModelSelectionForm } from "./model-selection-form"
+'use client'
+
+import React, { useState, useEffect } from 'react'
+import { motion, AnimatePresence } from 'framer-motion'
+import * as Tabs from '@radix-ui/react-tabs'
+import { useRouter } from 'next/navigation'
+import { zodResolver } from '@hookform/resolvers/zod'
+import { useForm } from 'react-hook-form'
+import * as z from 'zod'
+import { Loader2, Save, RotateCcw } from 'lucide-react'
+
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from '@/components/ui/card'
+import { SystemPromptForm } from './system-prompt-form'
+import { ModelSelectionForm } from './model-selection-form'
 import { UserManagementForm } from './user-management-form';
 import { Form } from "@/components/ui/form"
 import { useSettingsStore, MapProvider } from "@/lib/store/settings";
@@ -22,8 +21,10 @@ import { Label } from "@/components/ui/label";
 import { useToast } from "@/components/ui/hooks/use-toast"
 import { getSystemPrompt, saveSystemPrompt } from "../../../lib/actions/chat"
 import { getSelectedModel, saveSelectedModel } from "../../../lib/actions/users"
+import { useCurrentUser } from "@/lib/auth/use-current-user"
+import { SettingsSkeleton } from './settings-skeleton'
 
-// Define the form schema
+// Define the form schema with enum validation for roles
 const settingsFormSchema = z.object({
   systemPrompt: z
     .string()
@@ -43,7 +44,7 @@ const settingsFormSchema = z.object({
       role: z.enum(["admin", "editor", "viewer"]),
     }),
   ),
-  newUserEmail: z.string().email().optional(),
+  newUserEmail: z.string().email().optional().or(z.literal('')),
   newUserRole: z.enum(["admin", "editor", "viewer"]).optional(),
 })
 
@@ -54,10 +55,7 @@ const defaultValues: Partial<SettingsFormValues> = {
   systemPrompt:
     "You are a planetary copilot, an AI assistant designed to help users with information about planets, space exploration, and astronomy. Provide accurate, educational, and engaging responses about our solar system and beyond.",
   selectedModel: "Grok 4.2",
-  users: [
-    { id: "1", email: "admin@example.com", role: "admin" },
-    { id: "2", email: "user@example.com", role: "editor" },
-  ],
+  users: [],
 }
 
 interface SettingsProps {
@@ -67,16 +65,16 @@ interface SettingsProps {
 export function Settings({ initialTab = "system-prompt" }: SettingsProps) {
   const { toast } = useToast()
   const router = useRouter()
-  const [isLoading, setIsLoading] = useState(false)
+  const [isSaving, setIsSaving] = useState(false)
   const [currentTab, setCurrentTab] = useState(initialTab);
   const { mapProvider, setMapProvider } = useSettingsStore();
+  const { user, loading: authLoading } = useCurrentUser();
 
   useEffect(() => {
     setCurrentTab(initialTab);
   }, [initialTab]);
 
-  // TODO: Replace 'anonymous' with actual user ID from session/auth context
-  const userId = 'anonymous';
+  const userId = user?.id;
 
   const form = useForm<SettingsFormValues>({
     resolver: zodResolver(settingsFormSchema),
@@ -85,6 +83,8 @@ export function Settings({ initialTab = "system-prompt" }: SettingsProps) {
 
   useEffect(() => {
     async function fetchData() {
+      if (!userId || authLoading) return;
+
       const [existingPrompt, selectedModel] = await Promise.all([
         getSystemPrompt(userId),
         getSelectedModel(),
@@ -98,10 +98,23 @@ export function Settings({ initialTab = "system-prompt" }: SettingsProps) {
       }
     }
     fetchData();
-  }, [form, userId]);
+  }, [form, userId, authLoading]);
+
+  if (authLoading) {
+    return <SettingsSkeleton />;
+  }
 
   async function onSubmit(data: SettingsFormValues) {
-    setIsLoading(true)
+    if (!userId) {
+      toast({
+        title: "Error",
+        description: "You must be logged in to save settings.",
+        variant: "destructive",
+      });
+      return;
+    }
+
+    setIsSaving(true)
 
     try {
       // Save the system prompt and selected model
@@ -124,9 +137,6 @@ export function Settings({ initialTab = "system-prompt" }: SettingsProps) {
         title: "Settings updated",
         description: "Your settings have been saved successfully.",
       })
-
-      // Refresh the page to reflect changes
-      // router.refresh(); // Consider if refresh is needed or if optimistic update is enough
     } catch (error: any) {
       // Error notification
       toast({
@@ -135,7 +145,7 @@ export function Settings({ initialTab = "system-prompt" }: SettingsProps) {
         variant: "destructive",
       })
     } finally {
-      setIsLoading(false)
+      setIsSaving(false)
     }
   }
 
@@ -223,12 +233,12 @@ export function Settings({ initialTab = "system-prompt" }: SettingsProps) {
 
           <Card>
             <CardFooter className="flex justify-between pt-6">
-              <Button type="button" variant="outline" onClick={onReset} disabled={isLoading}>
+              <Button type="button" variant="outline" onClick={onReset} disabled={isSaving}>
                 <RotateCcw className="mr-2 h-4 w-4" />
                 Reset to Defaults
               </Button>
-              <Button type="submit" disabled={isLoading}>
-                {isLoading ? (
+              <Button type="submit" disabled={isSaving}>
+                {isSaving ? (
                   <>
                     <Loader2 className="mr-2 h-4 w-4 animate-spin" />
                     Saving...
diff --git a/components/settings/components/user-management-form.tsx b/components/settings/components/user-management-form.tsx
index 2f9521df..9c991a10 100644
--- a/components/settings/components/user-management-form.tsx
+++ b/components/settings/components/user-management-form.tsx
@@ -1,4 +1,3 @@
-// File: components/settings/components/user-management-form.tsx
 import React, { useState } from 'react';
 import { UseFormReturn, useFieldArray } from 'react-hook-form';
 import { Button } from '@/components/ui/button';
@@ -9,7 +8,7 @@ import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@
 import { FormField, FormItem, FormLabel, FormControl, FormMessage } from "@/components/ui/form";
 import { Trash2, Edit3, UserPlus, Loader2 } from 'lucide-react';
 import { useToast } from '@/components/ui/hooks/use-toast';
-import { addUser } from '@/lib/actions/users';
+import { addUser, type UserRole } from '@/lib/actions/users';
 import type { SettingsFormValues } from './settings';
 
 interface UserManagementFormProps {
@@ -24,15 +23,11 @@ export function UserManagementForm({ form }: UserManagementFormProps) {
   const { toast } = useToast();
   const [isAddingUser, setIsAddingUser] = useState(false);
 
-  // const watchNewUserEmail = form.watch("newUserEmail", ""); // Not strictly needed for logic below
-  // const watchNewUserRole = form.watch("newUserRole", "viewer"); // Not strictly needed for logic below
-
   const handleAddUser = async () => {
     setIsAddingUser(true);
     const newUserEmail = form.getValues("newUserEmail");
-    const newUserRole = form.getValues("newUserRole") || "viewer"; // Ensure role has a default
+    const newUserRole = form.getValues("newUserRole") || "viewer";
 
-    // Client-side validation first
     if (!newUserEmail) {
       form.setError("newUserEmail", { type: "manual", message: "Email is required." });
       setIsAddingUser(false);
@@ -43,27 +38,29 @@ export function UserManagementForm({ form }: UserManagementFormProps) {
       setIsAddingUser(false);
       return;
     }
-    // Client-side check if user already exists in the local list
     if (fields.some(user => user.email === newUserEmail)) {
       form.setError("newUserEmail", { type: "manual", message: "User with this email already exists locally." });
       setIsAddingUser(false);
       return;
     }
-    // Clear any previous local errors for newUserEmail if client checks pass
     form.clearErrors("newUserEmail");
 
     try {
-      const result = await addUser('default-user', { email: newUserEmail, role: newUserRole });
+      const result = await addUser({ email: newUserEmail, role: newUserRole as UserRole });
 
       if (result.error) {
         toast({ title: 'Error adding user', description: result.error, variant: 'destructive' });
-        form.setError("newUserEmail", { type: "manual", message: result.error }); // Show server error on field
+        form.setError("newUserEmail", { type: "manual", message: result.error });
       } else if (result.user) {
         toast({ title: 'User Added', description: `${result.user.email} was successfully added.` });
-        append(result.user); // Add user with ID from server
+        append({
+          id: result.user.id,
+          email: result.user.email || '',
+          role: result.user.role || 'viewer'
+        });
         form.resetField("newUserEmail");
-        form.resetField("newUserRole"); // Or set to default: form.setValue("newUserRole", "viewer");
-        form.clearErrors("newUserEmail"); // Clear any previous errors
+        form.resetField("newUserRole");
+        form.clearErrors("newUserEmail");
       }
     } catch (error) {
       console.error("Failed to add user:", error);
diff --git a/lib/actions/chat-db.ts b/lib/actions/chat-db.ts
index 4f0559ec..e15ea4ad 100644
--- a/lib/actions/chat-db.ts
+++ b/lib/actions/chat-db.ts
@@ -99,7 +99,7 @@ export async function saveChat(chatData: NewChat, messagesData: Omit<NewMessage,
       } else {
         // Optionally update chat metadata here if needed, e.g., title
         if (chatData.title) {
-          await tx.update(chats).set({ title: chatData.title }).where(eq(chats.id, chatId));
+          await tx.update(chats).set({ title: chatData.title, visibility: chatData.visibility, updatedAt: chatData.updatedAt }).where(eq(chats.id, chatId));
         }
       }
     } else { // No chat ID, create new chat
@@ -119,7 +119,7 @@ export async function saveChat(chatData: NewChat, messagesData: Omit<NewMessage,
         chatId: chatId!, // Ensure chatId is set for all messages
         userId: msg.userId || chatData.userId!, // Ensure userId is set
       }));
-      await tx.insert(messages).values(messagesToInsert);
+      await tx.insert(messages).values(messagesToInsert).onConflictDoUpdate({ target: messages.id, set: { content: sql`EXCLUDED.content`, role: sql`EXCLUDED.role` } });
     }
     return chatId;
   });
diff --git a/lib/actions/chat.ts b/lib/actions/chat.ts
index c257d6e8..f36f2cf6 100644
--- a/lib/actions/chat.ts
+++ b/lib/actions/chat.ts
@@ -2,26 +2,23 @@
 
 import { revalidatePath } from 'next/cache'
 import { redirect } from 'next/navigation'
-import { type Chat as OldChatType, type AIMessage } from '@/lib/types' // Added AIMessage, OldChatType for transition
+import { type Chat as OldChatType, type AIMessage } from '@/lib/types'
 import {
   getChatsPage as dbGetChatsPage,
   getChat as dbGetChat,
   clearHistory as dbClearHistory,
   saveChat as dbSaveChat,
   createMessage as dbCreateMessage,
-  getMessagesByChatId as dbGetMessagesByChatId, // Added
+  getMessagesByChatId as dbGetMessagesByChatId,
   type Chat as DrizzleChat,
-  type Message as DrizzleMessage, // Added
+  type Message as DrizzleMessage,
   type NewChat as DbNewChat,
   type NewMessage as DbNewMessage
 } from '@/lib/actions/chat-db'
-import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user' // For operations needing current user
-
-// TODO: Migrate Redis-based functions below (saveSystemPrompt, getSystemPrompt) if needed.
-// const redis = new Redis({
-//   url: process.env.UPSTASH_REDIS_REST_URL?.trim() || '',
-//   token: process.env.UPSTASH_REDIS_REST_TOKEN || ''
-// })
+import { db } from '@/lib/db'
+import { users } from '@/lib/db/schema'
+import { eq } from 'drizzle-orm'
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user'
 
 export async function getChats(userId?: string | null): Promise<DrizzleChat[]> {
   if (!userId) {
@@ -30,7 +27,6 @@ export async function getChats(userId?: string | null): Promise<DrizzleChat[]> {
   }
 
   try {
-    // Using a default limit and offset for now
     const { chats } = await dbGetChatsPage(userId, 20, 0)
     return chats
   } catch (error) {
@@ -40,11 +36,8 @@ export async function getChats(userId?: string | null): Promise<DrizzleChat[]> {
 }
 
 export async function getChat(id: string, userId: string): Promise<DrizzleChat | null> {
-  // userId is now mandatory for dbGetChat to check ownership or public status
   if (!userId) {
     console.warn('getChat called without userId.')
-    // Optionally, could try to fetch only public chat if that's a use case
-    // return await dbGetChat(id, ''); // Pass empty or a specific marker for anonymous
     return null;
   }
   try {
@@ -58,8 +51,6 @@ export async function getChat(id: string, userId: string): Promise<DrizzleChat |
 
 /**
  * Retrieves all messages for a specific chat.
- * @param chatId The ID of the chat.
- * @returns A promise that resolves to an array of DrizzleMessage objects.
  */
 export async function getChatMessages(chatId: string): Promise<DrizzleMessage[]> {
   if (!chatId) {
@@ -75,8 +66,8 @@ export async function getChatMessages(chatId: string): Promise<DrizzleMessage[]>
 }
 
 export async function clearChats(
-  userId?: string | null // Changed to optional, will try to get current user if not provided
-): Promise<{ error?: string } | void> { // void for success
+  userId?: string | null
+): Promise<{ error?: string } | void> {
   const currentUserId = userId || (await getCurrentUserIdOnServer())
   if (!currentUserId) {
     console.error('clearChats: No user ID provided or found.')
@@ -88,8 +79,6 @@ export async function clearChats(
     if (!success) {
       return { error: 'Failed to clear chats from database.' }
     }
-    // Revalidation and redirect should ideally be handled by the caller (e.g., Server Action, API route)
-    // For now, keeping them as they were, but this makes the function less reusable.
     revalidatePath('/')
     redirect('/')
   } catch (error) {
@@ -99,8 +88,6 @@ export async function clearChats(
 }
 
 export async function saveChat(chat: OldChatType, userId: string): Promise<string | null> {
-  // This function now maps the old Chat type to new Drizzle types
-  // and calls the new dbSaveChat function.
   if (!userId && !chat.userId) {
     console.error('saveChat: userId is required either as a parameter or in chat object.')
     return null;
@@ -108,22 +95,20 @@ export async function saveChat(chat: OldChatType, userId: string): Promise<strin
   const effectiveUserId = userId || chat.userId;
 
   const newChatData: DbNewChat = {
-    id: chat.id, // Keep existing ID if present (for updates)
+    id: chat.id,
     userId: effectiveUserId,
     title: chat.title || 'Untitled Chat',
-    createdAt: chat.createdAt ? new Date(chat.createdAt) : new Date(), // Ensure Date object
-    visibility: 'private', // Default or map from old chat if available
-    // sharePath: chat.sharePath, // sharePath is not in new schema by default
+    createdAt: chat.createdAt ? new Date(chat.createdAt) : new Date(),
+    visibility: 'private',
+    updatedAt: new Date(),
   };
 
   const newMessagesData: Omit<DbNewMessage, 'chatId'>[] = chat.messages.map(msg => ({
-    id: msg.id, // Keep existing ID
-    userId: effectiveUserId, // Ensure messages have a userId
-    role: msg.role, // Allow all AIMessage roles to pass through
+    id: msg.id,
+    userId: effectiveUserId,
+    role: msg.role,
     content: typeof msg.content === 'object' ? JSON.stringify(msg.content) : msg.content,
     createdAt: msg.createdAt ? new Date(msg.createdAt) : new Date(),
-    // attachments: (msg as any).attachments, // If AIMessage had attachments
-    // type: (msg as any).type // If AIMessage had a type
   }));
 
   try {
@@ -135,68 +120,26 @@ export async function saveChat(chat: OldChatType, userId: string): Promise<strin
   }
 }
 
-// TODO: Re-evaluate sharing functionality with Supabase if needed.
-// PR #533 removes the share page, so these are likely deprecated for now.
-// export async function getSharedChat(id: string) {
-//   // This would need to be reimplemented using dbGetChat with public visibility logic
-//   // const chat = await dbGetChat(id, ''); // Need a way to signify public access
-//   // if (!chat || chat.visibility !== 'public') { // Assuming 'public' visibility for shared
-//   //   return null;
-//   // }
-//   // return chat;
-//   console.warn("getSharedChat is deprecated and needs reimplementation with new DB structure.");
-//   return null;
-// }
-
-// export async function shareChat(id: string, userId: string) {
-//   // This would involve updating a chat's visibility to 'public' in the DB
-//   // and potentially creating a unique share link if `sharePath` is not just derived.
-//   // const chat = await dbGetChat(id, userId);
-//   // if (!chat) {
-//   //   return null;
-//   // }
-//   // // Update chat visibility to public
-//   // // const updatedChat = await db.update(chatsTable).set({ visibility: 'public' }).where(eq(chatsTable.id, id)).returning();
-//   // // return updatedChat[0];
-//   console.warn("shareChat is deprecated and needs reimplementation with new DB structure.");
-//   return null;
-// }
-
 export async function updateDrawingContext(chatId: string, contextData: { drawnFeatures: any[], cameraState: any }) {
-  'use server';
-  console.log('[Action] updateDrawingContext called for chatId:', chatId);
-
-  const userId = await getCurrentUserIdOnServer(); // Essential for creating a user-associated message
+  const userId = await getCurrentUserIdOnServer();
   if (!userId) {
-    console.error('updateDrawingContext: Could not get current user ID. User must be authenticated.');
+    console.error('updateDrawingContext: Could not get current user ID.');
     return { error: 'User not authenticated' };
   }
 
-  // The old version fetched the whole chat. Now we just create a new message.
-  // The AIMessage type might be from '@/lib/types' and need mapping to DbNewMessage
-  const newDrawingMessage: Omit<DbNewMessage, 'chatId'> = {
-    // id: `drawnData-${Date.now().toString()}`, // Let DB generate UUID
+  const newDrawingMessage: DbNewMessage = {
     userId: userId,
-    role: 'data' as 'user' | 'assistant' | 'system' | 'tool' | 'data', // Cast 'data' if not in standard roles
-    content: JSON.stringify(contextData), // Store both features and camera state as stringified JSON
-    // type: 'drawing_context', // This field is not in the Drizzle 'messages' schema.
-    // If `type` is important, the schema needs to be updated or content needs to reflect it.
-    // For now, we'll assume 'content' holds the necessary info and role='data' signifies it.
+    chatId: chatId,
+    role: 'data',
+    content: JSON.stringify(contextData),
     createdAt: new Date(),
   };
 
   try {
-    // We need to ensure the message is associated with the chat.
-    // dbCreateMessage requires chatId.
-    const messageToSave: DbNewMessage = {
-      ...newDrawingMessage,
-      chatId: chatId,
-    };
-    const savedMessage = await dbCreateMessage(messageToSave);
+    const savedMessage = await dbCreateMessage(newDrawingMessage);
     if (!savedMessage) {
       throw new Error('Failed to save drawing context message.');
     }
-    console.log('Drawing context message added to chat:', chatId, 'messageId:', savedMessage.id);
     return { success: true, messageId: savedMessage.id };
   } catch (error) {
     console.error('updateDrawingContext: Error saving drawing context message:', error);
@@ -204,34 +147,21 @@ export async function updateDrawingContext(chatId: string, contextData: { drawnF
   }
 }
 
-// TODO: These Redis-based functions for system prompt need to be migrated
-// if their functionality is still required and intended to use the new DB.
-// For now, they are left as is, but will likely fail if Redis config is removed.
-// @ts-ignore - Ignoring Redis import error for now as it might be removed or replaced
-import { Redis } from '@upstash/redis'; // This will cause issues if REDIS_URL is not configured.
-const redis = new Redis({
-  url: process.env.UPSTASH_REDIS_REST_URL?.trim() || '',
-  token: process.env.UPSTASH_REDIS_REST_TOKEN || ''
-});
-
-
 export async function saveSystemPrompt(
   userId: string,
   prompt: string
 ): Promise<{ success?: boolean; error?: string }> {
-  if (!userId) {
-    return { error: 'User ID is required' }
-  }
-
-  if (!prompt) {
-    return { error: 'Prompt is required' }
-  }
+  if (!userId) return { error: 'User ID is required' }
+  if (!prompt) return { error: 'Prompt is required' }
 
   try {
-    await redis.set(`system_prompt:${userId}`, prompt)
+    await db.update(users)
+      .set({ systemPrompt: prompt })
+      .where(eq(users.id, userId));
+
     return { success: true }
   } catch (error) {
-    console.error('saveSystemPrompt: Error saving system prompt:', error)
+    console.error('saveSystemPrompt: Error:', error)
     return { error: 'Failed to save system prompt' }
   }
 }
@@ -239,16 +169,17 @@ export async function saveSystemPrompt(
 export async function getSystemPrompt(
   userId: string
 ): Promise<string | null> {
-  if (!userId) {
-    console.error('getSystemPrompt: User ID is required')
-    return null
-  }
+  if (!userId) return null
 
   try {
-    const prompt = await redis.get<string>(`system_prompt:${userId}`)
-    return prompt
+    const result = await db.select({ systemPrompt: users.systemPrompt })
+      .from(users)
+      .where(eq(users.id, userId))
+      .limit(1);
+
+    return result[0]?.systemPrompt || null;
   } catch (error) {
-    console.error('getSystemPrompt: Error retrieving system prompt:', error)
+    console.error('getSystemPrompt: Error:', error)
     return null
   }
 }
diff --git a/lib/actions/users.ts b/lib/actions/users.ts
index 65a00de3..6fba7f8b 100644
--- a/lib/actions/users.ts
+++ b/lib/actions/users.ts
@@ -1,155 +1,211 @@
-// File: lib/actions/users.ts
 'use server';
 
 import { revalidatePath, unstable_noStore as noStore } from 'next/cache';
-import fs from 'fs/promises';
-import path from 'path';
+import { db } from '@/lib/db';
+import { users } from '@/lib/db/schema';
+import { eq, ilike } from 'drizzle-orm';
+import { getCurrentUserIdOnServer } from '@/lib/auth/get-current-user';
 
-// This is a placeholder for a database or other storage.
-// In a real application, you would interact with your database here.
-
-// Define UserRole and User types
 export type UserRole = "admin" | "editor" | "viewer";
 
 export interface User {
   id: string;
-  email: string;
-  role: UserRole;
+  email: string | null;
+  role: UserRole | null;
 }
 
-let usersStore: Record<string, Array<User>> = {
-  'default-user': [ // Simulate a default user having some initial users
-    { id: '1', email: 'admin@example.com', role: 'admin' },
-    { id: '2', email: 'editor@example.com', role: 'editor' },
-  ],
-};
+/**
+ * Ensures the current user is an admin.
+ * Throws an error if not authorized.
+ */
+async function requireAdmin() {
+  const userId = await getCurrentUserIdOnServer();
+  if (!userId) {
+    throw new Error('Unauthorized: User not authenticated');
+  }
 
-// Simulate a delay to mimic network latency
-const simulateDBDelay = () => new Promise(resolve => setTimeout(resolve, 500));
+  const [user] = await db.select({ role: users.role })
+    .from(users)
+    .where(eq(users.id, userId))
+    .limit(1);
 
-export async function getUsers(userId: string = 'default-user'): Promise<{ users: User[] }> {
-  await simulateDBDelay();
-  if (!usersStore[userId]) {
-    usersStore[userId] = [];
+  if (!user || user.role !== 'admin') {
+    throw new Error('Unauthorized: Admin access required');
   }
-  console.log(`[Action: getUsers] Fetched users for ${userId}:`, usersStore[userId]);
-  return { users: usersStore[userId] };
 }
 
-export async function addUser(userId: string = 'default-user', newUser: { email: string; role: UserRole }): Promise<{ user?: User; error?: string }> {
-  await simulateDBDelay();
-  if (!usersStore[userId]) {
-    usersStore[userId] = [];
+/**
+ * Retrieves all users from the database.
+ * Restricted to admins.
+ */
+export async function getUsers(): Promise<{ users: User[] }> {
+  noStore();
+  try {
+    await requireAdmin();
+    const result = await db.select({
+      id: users.id,
+      email: users.email,
+      role: users.role,
+    }).from(users);
+
+    // Type cast since we know roles in DB match UserRole or null
+    return { users: result as User[] };
+  } catch (error: any) {
+    console.error('[Action: getUsers] Error:', error.message);
+    return { users: [] };
   }
+}
 
-  // Check if user already exists (simple check, real DB would handle this better)
-  if (usersStore[userId].some(user => user.email === newUser.email)) {
-    console.warn(`[Action: addUser] User ${newUser.email} already exists for ${userId}`);
-    return { error: 'User with this email already exists.' };
-  }
+/**
+ * Adds a new user to the database.
+ * Restricted to admins.
+ */
+export async function addUser(newUser: { email: string; role: UserRole }): Promise<{ user?: User; error?: string }> {
+  try {
+    await requireAdmin();
+
+    // Check if email already exists to provide a clear error message
+    const [existing] = await db.select({ id: users.id })
+      .from(users)
+      .where(eq(users.email, newUser.email))
+      .limit(1);
+
+    if (existing) {
+      return { error: 'A user with this email already exists.' };
+    }
+
+    const [insertedUser] = await db.insert(users).values({
+      email: newUser.email,
+      role: newUser.role,
+    }).returning({
+      id: users.id,
+      email: users.email,
+      role: users.role,
+    });
 
-  const userToAdd: User = { ...newUser, id: Math.random().toString(36).substr(2, 9) };
-  usersStore[userId].push(userToAdd);
-  console.log(`[Action: addUser] Added user ${newUser.email} for ${userId}:`, userToAdd);
-  revalidatePath('/settings'); // Assuming settings page path, adjust if needed
-  return { user: userToAdd };
+    revalidatePath('/settings');
+    return { user: insertedUser as User };
+  } catch (error: any) {
+    console.error('[Action: addUser] Error:', error.message);
+    return { error: error.message || 'Failed to add user.' };
+  }
 }
 
-export async function updateUserRole(userId: string = 'default-user', userEmail: string, newRole: UserRole): Promise<{ user?: User; error?: string }> {
-  await simulateDBDelay();
-  if (!usersStore[userId]) {
-    return { error: 'User list not found.' };
-  }
+/**
+ * Updates a user's role by their email.
+ * Restricted to admins.
+ */
+export async function updateUserRole(userEmail: string, newRole: UserRole): Promise<{ user?: User; error?: string }> {
+  try {
+    await requireAdmin();
+    const [updatedUser] = await db.update(users)
+      .set({ role: newRole })
+      .where(eq(users.email, userEmail))
+      .returning({
+        id: users.id,
+        email: users.email,
+        role: users.role,
+      });
+
+    if (!updatedUser) {
+      return { error: 'User not found.' };
+    }
 
-  const userIndex = usersStore[userId].findIndex(user => user.email === userEmail);
-  if (userIndex === -1) {
-    console.warn(`[Action: updateUserRole] User ${userEmail} not found for ${userId}`);
-    return { error: 'User not found.' };
+    revalidatePath('/settings');
+    return { user: updatedUser as User };
+  } catch (error: any) {
+    console.error('[Action: updateUserRole] Error:', error.message);
+    return { error: error.message || 'Failed to update user role.' };
   }
-
-  usersStore[userId][userIndex].role = newRole;
-  console.log(`[Action: updateUserRole] Updated role for ${userEmail} to ${newRole} for ${userId}`);
-  revalidatePath('/settings');
-  return { user: usersStore[userId][userIndex] };
 }
 
-export async function removeUser(userId: string = 'default-user', userEmail: string): Promise<{ success?: boolean; error?: string }> {
-  await simulateDBDelay();
-  if (!usersStore[userId]) {
-    return { error: 'User list not found.' };
-  }
+/**
+ * Removes a user from the database by their email.
+ * Restricted to admins.
+ */
+export async function removeUser(userEmail: string): Promise<{ success?: boolean; error?: string }> {
+  try {
+    await requireAdmin();
+    const result = await db.delete(users).where(eq(users.email, userEmail)).returning();
 
-  const initialLength = usersStore[userId].length;
-  usersStore[userId] = usersStore[userId].filter(user => user.email !== userEmail);
+    if (result.length === 0) {
+      return { error: 'User not found.' };
+    }
 
-  if (usersStore[userId].length === initialLength) {
-    console.warn(`[Action: removeUser] User ${userEmail} not found for ${userId}`);
-    return { error: 'User not found.' };
+    revalidatePath('/settings');
+    return { success: true };
+  } catch (error: any) {
+    console.error('[Action: removeUser] Error:', error.message);
+    return { error: error.message || 'Failed to remove user.' };
   }
-
-  console.log(`[Action: removeUser] Removed user ${userEmail} for ${userId}`);
-  revalidatePath('/settings');
-  return { success: true };
-}
-
-// Example of how the settings form might use these actions (conceptual)
-export async function updateSettingsAndUsers(
-  userId: string = 'default-user',
-  formData: { users: Array<Omit<User, 'id'> & { id?: string }> } // Looser type for incoming, stricter for store
-): Promise<{ success: boolean; message?: string; users?: User[] }> {
-  // formData would contain systemPrompt, selectedModel, and the users array
-  console.log('[Action: updateSettingsAndUsers] Received data:', formData);
-
-  // Simulate saving systemPrompt and selectedModel
-  // ... (logic for other settings)
-
-  // For users, the frontend form already constructs the 'users' array.
-  // Here, we could compare the incoming users list with the stored one
-  // and make granular calls to addUser, updateUserRole, removeUser if needed,
-  // or simply replace the user list if that's the desired behavior.
-  // For simplicity in this simulation, let's assume the form sends the complete new user list.
-
-  await simulateDBDelay();
-  usersStore[userId] = formData.users.map((u): User => ({
-    id: u.id || Math.random().toString(36).substr(2, 9),
-    email: u.email,
-    role: u.role, // Assumes u.role is already UserRole, validation should occur before this action
-  }));
-
-  console.log(`[Action: updateSettingsAndUsers] Updated users for ${userId}:`, usersStore[userId]);
-  revalidatePath('/settings');
-  return { success: true, message: 'Settings and users updated successfully.', users: usersStore[userId] };
 }
 
-const modelConfigPath = path.resolve(process.cwd(), 'config', 'model.json');
-
+/**
+ * Fetches the selected model for the current user.
+ */
 export async function getSelectedModel(): Promise<string | null> {
   noStore();
-  console.log(`[DEBUG] getSelectedModel - Reading from path: "${modelConfigPath}"`);
+  const userId = await getCurrentUserIdOnServer();
+  if (!userId) return null;
+
   try {
-    const data = await fs.readFile(modelConfigPath, 'utf8');
-    console.log(`[DEBUG] getSelectedModel - Raw file content: "${data}"`);
-    const config = JSON.parse(data);
-    return config.selectedModel || null;
+    const result = await db.select({ selectedModel: users.selectedModel })
+      .from(users)
+      .where(eq(users.id, userId))
+      .limit(1);
+
+    return result[0]?.selectedModel || null;
   } catch (error) {
-    console.error('Error reading model config:', error);
-    console.log(`[DEBUG] getSelectedModel - Error reading file:`, error);
+    console.error('[Action: getSelectedModel] Error:', error);
     return null;
   }
 }
 
+/**
+ * Saves the selected model for the current user.
+ */
 export async function saveSelectedModel(model: string): Promise<{ success: boolean; error?: string }> {
-  console.log(`[DEBUG] saveSelectedModel - Received model selection: "${model}"`);
-  console.log(`[DEBUG] saveSelectedModel - Writing to path: "${modelConfigPath}"`);
+  const userId = await getCurrentUserIdOnServer();
+  if (!userId) return { success: false, error: 'Not authenticated' };
+
   try {
-    const data = JSON.stringify({ selectedModel: model }, null, 2);
-    await fs.writeFile(modelConfigPath, data, 'utf8');
-    console.log(`[DEBUG] saveSelectedModel - Successfully wrote to file.`);
+    await db.update(users)
+      .set({ selectedModel: model })
+      .where(eq(users.id, userId));
+
     revalidatePath('/settings');
     return { success: true };
   } catch (error) {
-    console.error('Error saving model config:', error);
-    console.log(`[DEBUG] saveSelectedModel - Error writing to file:`, error);
+    console.error('[Action: saveSelectedModel] Error:', error);
     return { success: false, error: 'Failed to save selected model.' };
   }
 }
+
+/**
+ * Searches users by email.
+ * Restricted to authenticated users.
+ */
+export async function searchUsers(query: string) {
+  noStore();
+  if (!query) return [];
+
+  const userId = await getCurrentUserIdOnServer();
+  if (!userId) {
+    throw new Error('Unauthorized');
+  }
+
+  try {
+    const result = await db.select({
+      id: users.id,
+      email: users.email,
+    })
+    .from(users)
+    .where(ilike(users.email, `%${query}%`))
+    .limit(10);
+
+    return result;
+  } catch (error) {
+    console.error('[Action: searchUsers] Error:', error);
+    return [];
+  }
+}
diff --git a/lib/db/schema.ts b/lib/db/schema.ts
index 4b7ef891..e8e6b943 100644
--- a/lib/db/schema.ts
+++ b/lib/db/schema.ts
@@ -1,42 +1,94 @@
-import { pgTable, text, timestamp, uuid, varchar, jsonb, boolean } from 'drizzle-orm/pg-core';
+import { pgTable, text, timestamp, uuid, jsonb, customType, unique } from 'drizzle-orm/pg-core';
 import { relations } from 'drizzle-orm';
 
-// Users Table (assuming Supabase Auth uses its own users table,
-// but a local reference might be used or this could be a public profile table)
-// For now, let's assume a simple users table if PR #533 implies one in schema.ts
-// If PR #533 relies purely on Supabase Auth's user IDs without a separate 'users' table managed by Drizzle for chat context,
-// then this table might be simpler or not needed. Given the PR title focuses on chat migration,
-// we'll include a basic one that can be referenced by chats and messages.
+// Custom type for PostGIS geometry
+const geometry = customType<{ data: string }>({
+  dataType() {
+    return 'geometry(GEOMETRY, 4326)';
+  },
+});
+
+/**
+ * Custom type for vector embeddings.
+ * Currently assumed to use text-embedding-ada-002 => 1536 dimensions.
+ * Switching to models like text-embedding-3-large (3072) requires a migration.
+ */
+const vector = customType<{ data: number[] }>({
+  dataType() {
+    return 'vector(1536)';
+  },
+});
+
 export const users = pgTable('users', {
-  id: uuid('id').primaryKey().defaultRandom(), // Assuming Supabase user IDs are UUIDs
-  // email: text('email'), // Supabase handles this in auth.users
-  // Other profile fields if necessary
+  id: uuid('id').primaryKey().defaultRandom(),
+  email: text('email').unique(), // Enforced unique for user identity
+  role: text('role').default('viewer'),
+  selectedModel: text('selected_model'),
+  systemPrompt: text('system_prompt'),
 });
 
 export const chats = pgTable('chats', {
   id: uuid('id').primaryKey().defaultRandom(),
-  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }), // References a user ID
-  title: varchar('title', { length: 256 }).notNull().default('Untitled Chat'),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  title: text('title').notNull().default('Untitled Chat'),
+  visibility: text('visibility').default('private'),
+  path: text('path'),
+  sharePath: text('share_path'),
+  shareableLinkId: uuid('shareable_link_id').defaultRandom().unique(),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
+export const locations = pgTable('locations', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  chatId: uuid('chat_id').references(() => chats.id, { onDelete: 'cascade' }),
+  geojson: jsonb('geojson').notNull(),
+  geometry: geometry('geometry'),
+  name: text('name'),
   createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
-  // RLS in Supabase will use policies, but marking public visibility can be a column
-  visibility: varchar('visibility', { length: 50 }).default('private'), // e.g., 'private', 'public'
-  // any other metadata for the chat
 });
 
 export const messages = pgTable('messages', {
   id: uuid('id').primaryKey().defaultRandom(),
   chatId: uuid('chat_id').notNull().references(() => chats.id, { onDelete: 'cascade' }),
-  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }), // Who sent the message
-  role: varchar('role', { length: 50 }).notNull(), // e.g., 'user', 'assistant', 'system', 'tool'
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  role: text('role').notNull(),
   content: text('content').notNull(),
+  embedding: vector('embedding'),
+  locationId: uuid('location_id').references(() => locations.id, { onDelete: 'set null' }),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
+export const chatParticipants = pgTable('chat_participants', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  chatId: uuid('chat_id').notNull().references(() => chats.id, { onDelete: 'cascade' }),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  role: text('role').notNull().default('collaborator'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  // Prevent duplicate participants in the same chat
+  chatUserUnique: unique('chat_participants_chat_user_unique').on(t.chatId, t.userId),
+}));
+
+export const systemPrompts = pgTable('system_prompts', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  prompt: text('prompt').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
+export const visualizations = pgTable('visualizations', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  chatId: uuid('chat_id').references(() => chats.id, { onDelete: 'cascade' }),
+  type: text('type').notNull().default('map_layer'),
+  data: jsonb('data').notNull(),
+  geometry: geometry('geometry'),
   createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
-  // attachments: jsonb('attachments'), // As per PR commit: "feat: remove updatedAt and add attachments field to messages"
-  // toolName: varchar('tool_name', { length: 100 }), // If messages can be from tools
-  // toolCallId: varchar('tool_call_id', {length: 100}), // if tracking specific tool calls
-  // type: varchar('type', { length: 50 }) // As per app/actions.tsx AIMessage type
 });
 
-// Calendar Notes Table
 export const calendarNotes = pgTable('calendar_notes', {
   id: uuid('id').primaryKey().defaultRandom(),
   userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
@@ -55,6 +107,10 @@ export const usersRelations = relations(users, ({ many }) => ({
   chats: many(chats),
   messages: many(messages),
   calendarNotes: many(calendarNotes),
+  chatParticipants: many(chatParticipants),
+  systemPrompts: many(systemPrompts),
+  locations: many(locations),
+  visualizations: many(visualizations),
 }));
 
 export const chatsRelations = relations(chats, ({ one, many }) => ({
@@ -64,6 +120,9 @@ export const chatsRelations = relations(chats, ({ one, many }) => ({
   }),
   messages: many(messages),
   calendarNotes: many(calendarNotes),
+  participants: many(chatParticipants),
+  locations: many(locations),
+  visualizations: many(visualizations),
 }));
 
 export const messagesRelations = relations(messages, ({ one }) => ({
@@ -75,6 +134,51 @@ export const messagesRelations = relations(messages, ({ one }) => ({
     fields: [messages.userId],
     references: [users.id],
   }),
+  location: one(locations, {
+    fields: [messages.locationId],
+    references: [locations.id],
+  }),
+}));
+
+export const chatParticipantsRelations = relations(chatParticipants, ({ one }) => ({
+  chat: one(chats, {
+    fields: [chatParticipants.chatId],
+    references: [chats.id],
+  }),
+  user: one(users, {
+    fields: [chatParticipants.userId],
+    references: [users.id],
+  }),
+}));
+
+export const systemPromptsRelations = relations(systemPrompts, ({ one }) => ({
+  user: one(users, {
+    fields: [systemPrompts.userId],
+    references: [users.id],
+  }),
+}));
+
+export const locationsRelations = relations(locations, ({ one, many }) => ({
+  user: one(users, {
+    fields: [locations.userId],
+    references: [users.id],
+  }),
+  chat: one(chats, {
+    fields: [locations.chatId],
+    references: [chats.id],
+  }),
+  messages: many(messages),
+}));
+
+export const visualizationsRelations = relations(visualizations, ({ one }) => ({
+  user: one(users, {
+    fields: [visualizations.userId],
+    references: [users.id],
+  }),
+  chat: one(chats, {
+    fields: [visualizations.chatId],
+    references: [chats.id],
+  }),
 }));
 
 export const calendarNotesRelations = relations(calendarNotes, ({ one }) => ({
diff --git a/lib/utils/index.ts b/lib/utils/index.ts
index f9b7eeb5..5303da34 100644
--- a/lib/utils/index.ts
+++ b/lib/utils/index.ts
@@ -15,6 +15,12 @@ export function generateUUID(): string {
   return uuidv4();
 }
 
+/**
+ * Re-export generateUUID as nanoid for shorter naming and compatibility with existing code.
+ * Returns a UUID v4 string.
+ */
+export { generateUUID as nanoid };
+
 export async function getModel(requireVision: boolean = false) {
   const selectedModel = await getSelectedModel();