chore: update version number to 0.1.13

feat: enhance attachment handling in ComposeScreen with file picker and updated UI options
feat: add restoreEmailMailboxes mock to email store tests
2026-11-01 16:05:39 +00:00 · 2026-05-02 14:44:00 +02:00 · 2026-05-02 14:43:45 +02:00 · 2026-05-02 14:32:15 +02:00 · 2026-05-02 14:31:50 +02:00 · 2026-05-02 14:27:15 +02:00
20 changed files with 961 additions and 241 deletions
@@ -1 +1 @@
-0.1.12
+0.1.13
@@ -450,6 +450,8 @@
    "send": "Send",
    "cancel": "Cancel",
    "attach": "Attach",
+    "attach_photos": "Photos & Videos",
+    "attach_files": "Files",
    "discard": "Discard",
    "discard_draft_title": "Discard draft?",
    "discard_draft_confirm": "You have unsaved changes. Do you want to discard this draft?",
@@ -1,12 +1,12 @@
 {
  "name": "bulwark-mobile",
-  "version": "0.1.12",
+  "version": "0.1.13",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "bulwark-mobile",
-      "version": "0.1.12",
+      "version": "0.1.13",
      "license": "AGPL-3.0-only",
      "dependencies": {
        "@react-native-async-storage/async-storage": "2.2.0",
@@ -1,6 +1,6 @@
 {
  "name": "bulwark-mobile",
-  "version": "0.1.12",
+  "version": "0.1.13",
  "license": "AGPL-3.0-only",
  "main": "index.ts",
  "scripts": {
@@ -1,5 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';

+vi.mock('expo-file-system', () => ({
+  File: class {
+    constructor(public uri: string) {}
+    async bytes() { return new Uint8Array(); }
+  },
+}));
+
 vi.mock('../jmap-client', () => ({
  jmapClient: {
    accountId: 'acc-1',
@@ -1,3 +1,4 @@
+import { File } from 'expo-file-system';
 import { jmapClient } from './jmap-client';

 export async function uploadBlob(
@@ -7,11 +8,14 @@ export async function uploadBlob(
  const session = jmapClient.currentSession;
  if (!session) throw new Error('Not connected');

-  const uploadUrl = session.uploadUrl.replace('{accountId}', jmapClient.accountId);
+  const uploadUrl = session.uploadUrl.replace(
+    '{accountId}',
+    encodeURIComponent(jmapClient.accountId),
+  );

-  // Fetch local file as blob
-  const fileResponse = await fetch(uri);
-  const blob = await fileResponse.blob();
+  // Read the source via the file-system API so this works for both `file://`
+  // (image picker, iOS document picker) and `content://` (Android SAF) URIs.
+  const bytes = await new File(uri).bytes();

  const response = await fetch(uploadUrl, {
    method: 'POST',
@@ -19,11 +23,12 @@ export async function uploadBlob(
      'Content-Type': type,
      Authorization: (jmapClient as any).authHeader,
    },
-    body: blob,
+    body: bytes as unknown as BodyInit,
  });

  if (!response.ok) {
-    throw new Error(`Upload failed: ${response.status}`);
+    const detail = await response.text().catch(() => '');
+    throw new Error(`Upload failed: ${response.status}${detail ? ` ${detail}` : ''}`);
  }

  return response.json();
@@ -1,6 +1,6 @@
 import { jmapClient } from './jmap-client';
 import { CAPABILITIES } from './types';
-import type { Email, EmailAddress, Mailbox, Thread } from './types';
+import type { Email, EmailAddress, JMAPMethodCall, Mailbox, Thread } from './types';
 import { toWildcardQuery } from '../lib/search-utils';

 const EMAIL_LIST_PROPERTIES = [
@@ -111,6 +111,144 @@ export async function moveEmail(
  ]);
 }

+// Restore each email's mailboxIds to the snapshot supplied. Used by undo to
+// reverse a move/archive/spam in one round-trip. JMAP "mailboxIds" replaces
+// the entire map, so we don't need to compute a diff against the current state.
+export async function restoreEmailMailboxes(
+  items: Array<{ id: string; mailboxIds: Record<string, boolean> }>,
+): Promise<void> {
+  if (items.length === 0) return;
+  const accountId = jmapClient.accountId;
+  const update: Record<string, { mailboxIds: Record<string, true> }> = {};
+  for (const item of items) {
+    const onlyTrue: Record<string, true> = {};
+    for (const [id, present] of Object.entries(item.mailboxIds)) {
+      if (present) onlyTrue[id] = true;
+    }
+    update[item.id] = { mailboxIds: onlyTrue };
+  }
+  await jmapClient.request([
+    ['Email/set', { accountId, update }, '0'],
+  ]);
+}
+
+// Archive one or more emails into the archive mailbox, optionally auto-sorting
+// into year or year/month subfolders. Mirrors the webmail implementation in
+// lib/jmap/client.ts so behavior stays in sync between platforms.
+export async function archiveEmails(
+  emails: Array<{ id: string; receivedAt: string }>,
+  archiveMailboxId: string,
+  mode: 'single' | 'year' | 'month',
+  existingMailboxes: Mailbox[],
+): Promise<void> {
+  if (emails.length === 0) return;
+  const accountId = jmapClient.accountId;
+
+  if (mode === 'single') {
+    const updates = Object.fromEntries(
+      emails.map((e) => [e.id, { mailboxIds: { [archiveMailboxId]: true } }]),
+    );
+    await jmapClient.request([
+      ['Email/set', { accountId, update: updates }, '0'],
+    ]);
+    return;
+  }
+
+  type Dest = { year: string; month?: string };
+  const destFor = new Map<string, Dest>();
+  for (const e of emails) {
+    const d = new Date(e.receivedAt);
+    const year = d.getFullYear().toString();
+    const month = (d.getMonth() + 1).toString().padStart(2, '0');
+    destFor.set(e.id, mode === 'year' ? { year } : { year, month });
+  }
+
+  // Resolve each destination folder to either an existing id or a creation-id reference ("#<cid>").
+  const yearIdFor = new Map<string, string>();
+  const monthIdFor = new Map<string, string>();
+  const createEntries: Record<string, Record<string, unknown>> = {};
+
+  const findExisting = (name: string, parentId: string) =>
+    existingMailboxes.find(
+      (m) => m.name === name && m.parentId === parentId,
+    );
+
+  for (const dest of destFor.values()) {
+    if (!yearIdFor.has(dest.year)) {
+      const existing = findExisting(dest.year, archiveMailboxId);
+      if (existing) {
+        yearIdFor.set(dest.year, existing.id);
+      } else {
+        const cid = `year-${dest.year}`;
+        createEntries[cid] = { name: dest.year, parentId: archiveMailboxId };
+        yearIdFor.set(dest.year, `#${cid}`);
+      }
+    }
+
+    if (mode === 'month' && dest.month) {
+      const monthKey = `${dest.year}/${dest.month}`;
+      if (!monthIdFor.has(monthKey)) {
+        const yearRef = yearIdFor.get(dest.year)!;
+        const existingMonth = yearRef.startsWith('#')
+          ? undefined
+          : findExisting(dest.month, yearRef);
+        if (existingMonth) {
+          monthIdFor.set(monthKey, existingMonth.id);
+        } else {
+          const cid = `month-${dest.year}-${dest.month}`;
+          createEntries[cid] = { name: dest.month, parentId: yearRef };
+          monthIdFor.set(monthKey, `#${cid}`);
+        }
+      }
+    }
+  }
+
+  const updates: Record<string, { mailboxIds: Record<string, true> }> = {};
+  for (const [emailId, dest] of destFor.entries()) {
+    const destId = mode === 'month' && dest.month
+      ? monthIdFor.get(`${dest.year}/${dest.month}`)!
+      : yearIdFor.get(dest.year)!;
+    updates[emailId] = { mailboxIds: { [destId]: true } };
+  }
+
+  const methodCalls: JMAPMethodCall[] = [];
+  const hasCreates = Object.keys(createEntries).length > 0;
+  if (hasCreates) {
+    methodCalls.push(['Mailbox/set', { accountId, create: createEntries }, '0']);
+  }
+  methodCalls.push(['Email/set', { accountId, update: updates }, String(methodCalls.length)]);
+
+  const response = await jmapClient.request(methodCalls);
+
+  if (hasCreates) {
+    const mailboxResult = response.methodResponses?.[0]?.[1];
+    const notCreated = mailboxResult?.notCreated as
+      | Record<string, { type?: string; properties?: string[]; description?: string }>
+      | undefined;
+    const failures = notCreated ? Object.entries(notCreated) : [];
+    if (failures.length > 0) {
+      const [cid, err] = failures[0];
+      const parts = [err.type || 'unknown'];
+      if (err.properties?.length) parts.push(`properties=[${err.properties.join(', ')}]`);
+      if (err.description) parts.push(err.description);
+      throw new Error(`Failed to create archive folder '${cid}': ${parts.join(' – ')}`);
+    }
+  }
+
+  const emailIdx = hasCreates ? 1 : 0;
+  const emailResult = response.methodResponses?.[emailIdx]?.[1];
+  const notUpdated = emailResult?.notUpdated as
+    | Record<string, { type?: string; description?: string }>
+    | undefined;
+  const emailFailures = notUpdated ? Object.entries(notUpdated) : [];
+  if (emailFailures.length > 0) {
+    const [id, err] = emailFailures[0];
+    throw new Error(
+      `Failed to archive ${emailFailures.length} email(s), first: ${id} – ${err.type || 'unknown'}${err.description ? ` (${err.description})` : ''}`,
+    );
+  }
+}
+
 export async function deleteEmail(
  emailId: string,
  trashMailboxId: string,
@@ -0,0 +1,199 @@
+import React from 'react';
+import {
+  View, Text, StyleSheet, ScrollView, Pressable, Modal, Animated, Easing,
+} from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import {
+  Inbox, Send, File as FileIcon, Trash2, Ban, Archive, Folder,
+  X, Check, type LucideIcon,
+} from 'lucide-react-native';
+import { spacing, radius, typography, type ThemePalette } from '../theme/tokens';
+import { useColors } from '../theme/colors';
+import { buildMailboxTree, flattenVisible, type MailboxNode } from '../lib/mailbox-tree';
+import { useSheetDrag } from '../lib/use-sheet-drag';
+import type { Mailbox } from '../api/types';
+
+function moveTargetIcon(role: string | null | undefined, name: string): LucideIcon {
+  const lower = name.toLowerCase();
+  if (role === 'inbox' || lower.includes('inbox')) return Inbox;
+  if (role === 'sent' || lower.includes('sent')) return Send;
+  if (role === 'drafts' || lower.includes('draft')) return FileIcon;
+  if (role === 'trash' || lower.includes('trash') || lower.includes('deleted')) return Trash2;
+  if (role === 'junk' || role === 'spam' || lower.includes('junk') || lower.includes('spam')) return Ban;
+  if (role === 'archive' || lower.includes('archive')) return Archive;
+  return Folder;
+}
+
+interface MoveSheetProps {
+  visible: boolean;
+  onClose: () => void;
+  mailboxes: Mailbox[];
+  /** Folder the email is currently in - shown with a check, not selectable. */
+  currentMailboxId: string | null;
+  onPick: (id: string) => void;
+}
+
+export function MoveSheet({
+  visible, onClose, mailboxes, currentMailboxId, onPick,
+}: MoveSheetProps) {
+  const c = useColors();
+  const styles = React.useMemo(() => makeStyles(c), [c]);
+  const insets = useSafeAreaInsets();
+  const slideY = React.useRef(new Animated.Value(500)).current;
+  const overlayOpacity = React.useRef(new Animated.Value(0)).current;
+  const dragHandlers = useSheetDrag({ slideY, closedY: 500, onClose });
+
+  React.useEffect(() => {
+    if (visible) {
+      Animated.parallel([
+        Animated.timing(slideY, { toValue: 0, duration: 220, easing: Easing.out(Easing.cubic), useNativeDriver: true }),
+        Animated.timing(overlayOpacity, { toValue: 1, duration: 220, useNativeDriver: true }),
+      ]).start();
+    } else {
+      Animated.parallel([
+        Animated.timing(slideY, { toValue: 500, duration: 180, easing: Easing.in(Easing.cubic), useNativeDriver: true }),
+        Animated.timing(overlayOpacity, { toValue: 0, duration: 180, useNativeDriver: true }),
+      ]).start();
+    }
+  }, [visible, slideY, overlayOpacity]);
+
+  const visibleNodes = React.useMemo(() => {
+    const tree = buildMailboxTree(mailboxes);
+    const expanded = new Set<string>();
+    const collect = (nodes: MailboxNode[]) => {
+      for (const n of nodes) {
+        if (n.children.length > 0) {
+          expanded.add(n.id);
+          collect(n.children);
+        }
+      }
+    };
+    collect(tree);
+    return flattenVisible(tree, expanded);
+  }, [mailboxes]);
+
+  return (
+    <Modal visible={visible} transparent animationType="none" onRequestClose={onClose} statusBarTranslucent>
+      <Animated.View style={[styles.sheetOverlay, { opacity: overlayOpacity }]}>
+        <Pressable style={styles.sheetOverlayPress} onPress={onClose} />
+      </Animated.View>
+      <Animated.View
+        style={[
+          styles.sheet,
+          { paddingBottom: Math.max(insets.bottom, spacing.md), transform: [{ translateY: slideY }] },
+        ]}
+      >
+        <View {...dragHandlers}>
+          <View style={styles.sheetHandleHit}>
+            <View style={styles.sheetHandle} />
+          </View>
+          <View style={styles.sheetHeader}>
+            <Text style={styles.sheetTitle}>Move to folder</Text>
+            <Pressable onPress={onClose} hitSlop={8} style={styles.sheetClose}>
+              <X size={18} color={c.textSecondary} />
+            </Pressable>
+          </View>
+        </View>
+        <ScrollView>
+          {visibleNodes.map((node) => {
+            const Icon = moveTargetIcon(node.role, node.name);
+            const isCurrent = node.id === currentMailboxId;
+            const canTarget = node.myRights?.mayAddItems !== false && !isCurrent;
+            return (
+              <Pressable
+                key={node.id}
+                onPress={canTarget ? () => onPick(node.id) : undefined}
+                disabled={!canTarget}
+                style={({ pressed }) => [
+                  styles.moveRow,
+                  pressed && canTarget && styles.moveRowPressed,
+                  { paddingLeft: spacing.lg + node.depth * 16 },
+                ]}
+              >
+                <Icon size={16} color={canTarget ? c.textSecondary : c.textMuted} />
+                <Text
+                  style={[styles.moveRowLabel, !canTarget && styles.moveRowLabelDisabled]}
+                  numberOfLines={1}
+                >
+                  {node.name}
+                </Text>
+                {isCurrent && <Check size={14} color={c.textMuted} />}
+              </Pressable>
+            );
+          })}
+        </ScrollView>
+      </Animated.View>
+    </Modal>
+  );
+}
+
+function makeStyles(c: ThemePalette) {
+  return StyleSheet.create({
+    sheetOverlay: {
+      ...StyleSheet.absoluteFillObject,
+      backgroundColor: 'rgba(0,0,0,0.5)',
+    },
+    sheetOverlayPress: { flex: 1 },
+    sheet: {
+      position: 'absolute',
+      left: 0,
+      right: 0,
+      bottom: 0,
+      maxHeight: '75%',
+      backgroundColor: c.popover,
+      borderTopLeftRadius: radius.lg,
+      borderTopRightRadius: radius.lg,
+      borderTopWidth: 1,
+      borderColor: c.border,
+      paddingTop: spacing.sm,
+    },
+    sheetHandleHit: {
+      alignItems: 'center',
+      paddingTop: spacing.xs,
+      paddingBottom: spacing.sm,
+    },
+    sheetHandle: {
+      width: 36,
+      height: 4,
+      borderRadius: 2,
+      backgroundColor: c.border,
+    },
+    sheetHeader: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      justifyContent: 'space-between',
+      paddingHorizontal: spacing.lg,
+      paddingBottom: spacing.sm,
+      borderBottomWidth: 1,
+      borderBottomColor: c.border,
+    },
+    sheetTitle: {
+      ...typography.bodySemibold,
+      color: c.text,
+    },
+    sheetClose: {
+      width: 28,
+      height: 28,
+      alignItems: 'center',
+      justifyContent: 'center',
+      borderRadius: radius.xs,
+    },
+    moveRow: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      gap: spacing.sm,
+      paddingRight: spacing.lg,
+      paddingVertical: spacing.sm + 2,
+      minHeight: 44,
+    },
+    moveRowPressed: { backgroundColor: c.surfaceHover },
+    moveRowLabel: {
+      ...typography.body,
+      color: c.text,
+      flex: 1,
+    },
+    moveRowLabelDisabled: {
+      color: c.textMuted,
+    },
+  });
+}
@@ -1,9 +1,9 @@
-import React, { useRef, useState } from 'react';
+import React, { useRef } from 'react';
 import {
-  View, Text, StyleSheet, Animated, PanResponder, Pressable, Dimensions,
+  View, Text, StyleSheet, Animated, PanResponder, Dimensions,
 } from 'react-native';
 import {
-  Archive, Trash2, ShieldAlert, MailOpen, Mail, Star,
+  Archive, Trash2, ShieldAlert, MailOpen, Star, Pin, FolderInput,
  type LucideIcon,
 } from 'lucide-react-native';
 import { typography, type ThemePalette } from '../theme/tokens';
@@ -17,15 +17,18 @@ interface SwipeableRowProps {
  /** Left-to-right swipe action (revealed under a rightward drag, sits at left edge). */
  rightAction: SwipeAction;
  /** Pass the row state used to compute action labels (e.g. unread/starred toggling). */
-  context: { unread: boolean; starred: boolean };
+  context: { unread: boolean; starred: boolean; pinned: boolean };
  onAction: (action: SwipeAction) => void;
 }

-const REVEAL_WIDTH = 88;          // px shown when fully revealed
-const ACTIVATION_THRESHOLD = 32;  // px past which release snaps open instead of closing
+// Distance (px) of horizontal travel needed to commit the action on release.
+// Drag less than this and the row snaps back without firing.
+const COMMIT_THRESHOLD = 96;
 const DIRECTION_BIAS = 1.5;       // dx must dominate dy by this factor
 const MIN_DX_TO_CLAIM = 6;
-const MAX_DRAG_OVERSHOOT = REVEAL_WIDTH * 1.4;
+const MAX_DRAG_OVERSHOOT = 240;
+// Distance the row flies off-screen by before the action callback fires.
+const EXIT_DISTANCE = 600;

 const ACTION_META: Record<Exclude<SwipeAction, 'none'>, { icon: LucideIcon; bg: string; defaultLabel: string }> = {
  archive: { icon: Archive,      bg: '#1d4ed8', defaultLabel: 'Archive' },
@@ -33,15 +36,24 @@ const ACTION_META: Record<Exclude<SwipeAction, 'none'>, { icon: LucideIcon; bg:
  spam:    { icon: ShieldAlert,  bg: '#a16207', defaultLabel: 'Spam' },
  read:    { icon: MailOpen,     bg: '#0f766e', defaultLabel: 'Read' },
  star:    { icon: Star,         bg: '#a16207', defaultLabel: 'Star' },
+  pin:     { icon: Pin,          bg: '#7c3aed', defaultLabel: 'Pin' },
+  move:    { icon: FolderInput,  bg: '#475569', defaultLabel: 'Move' },
 };

-function actionLabel(action: SwipeAction, context: { unread: boolean; starred: boolean }): string {
+function actionLabel(action: SwipeAction, context: { unread: boolean; starred: boolean; pinned: boolean }): string {
  if (action === 'read') return context.unread ? 'Read' : 'Unread';
  if (action === 'star') return context.starred ? 'Unstar' : 'Star';
+  if (action === 'pin') return context.pinned ? 'Unpin' : 'Pin';
  if (action === 'none') return '';
  return ACTION_META[action].defaultLabel;
 }

+// Actions that visibly remove the row from the list (so the row should fly off
+// instead of snapping back). Toggle-style actions stay in place.
+function exitsRow(action: SwipeAction): boolean {
+  return action === 'archive' || action === 'delete' || action === 'spam' || action === 'move';
+}
+
 export function SwipeableRow({
  children, leftAction, rightAction, context, onAction,
 }: SwipeableRowProps) {
@@ -50,25 +62,31 @@ export function SwipeableRow({
  const dx = useRef(new Animated.Value(0)).current;
  const claimed = useRef(false);
  const widthRef = useRef(Dimensions.get('window').width);
-  const openSideRef = useRef<'left' | 'right' | null>(null);
-  const [openSide, setOpenSide] = useState<'left' | 'right' | null>(null);

-  const close = () => {
+  const snapBack = () => {
    Animated.spring(dx, { toValue: 0, useNativeDriver: true, speed: 24, bounciness: 4 }).start();
-    openSideRef.current = null;
-    setOpenSide(null);
  };

-  const openRight = () => {
-    Animated.spring(dx, { toValue: REVEAL_WIDTH, useNativeDriver: true, speed: 24, bounciness: 4 }).start();
-    openSideRef.current = 'right';
-    setOpenSide('right');
-  };
-
-  const openLeft = () => {
-    Animated.spring(dx, { toValue: -REVEAL_WIDTH, useNativeDriver: true, speed: 24, bounciness: 4 }).start();
-    openSideRef.current = 'left';
-    setOpenSide('left');
+  const fly = (toValue: number, action: SwipeAction) => {
+    // For destructive/move actions: race the row off-screen and fire the
+    // action - the parent will remove the row from the list. For toggle
+    // actions: fire immediately and snap back so the same row can update in
+    // place.
+    if (exitsRow(action)) {
+      Animated.timing(dx, {
+        toValue,
+        duration: 180,
+        useNativeDriver: true,
+      }).start(() => {
+        onAction(action);
+        // The row is about to be removed; reset translation in case it isn't
+        // (e.g. the action failed silently) so we don't leave it off-screen.
+        dx.setValue(0);
+      });
+    } else {
+      onAction(action);
+      snapBack();
+    }
  };

  const responder = useRef(
@@ -77,65 +95,59 @@ export function SwipeableRow({
      onMoveShouldSetPanResponder: (_, g) => {
        if (Math.abs(g.dx) < MIN_DX_TO_CLAIM) return false;
        if (Math.abs(g.dx) < Math.abs(g.dy) * DIRECTION_BIAS) return false;
-        // If a side is already open, allow the gesture so the user can drag it closed.
-        if (openSideRef.current === null) {
-          if (g.dx > 0 && rightAction === 'none') return false;
-          if (g.dx < 0 && leftAction === 'none') return false;
-        }
+        if (g.dx > 0 && rightAction === 'none') return false;
+        if (g.dx < 0 && leftAction === 'none') return false;
        claimed.current = true;
        return true;
      },
      onPanResponderMove: (_, g) => {
-        const base = openSideRef.current === 'right' ? REVEAL_WIDTH : openSideRef.current === 'left' ? -REVEAL_WIDTH : 0;
-        const next = base + g.dx;
-        const clamped = Math.max(-MAX_DRAG_OVERSHOOT, Math.min(MAX_DRAG_OVERSHOOT, next));
+        const clamped = Math.max(-MAX_DRAG_OVERSHOOT, Math.min(MAX_DRAG_OVERSHOOT, g.dx));
        dx.setValue(clamped);
      },
      onPanResponderRelease: (_, g) => {
-        const base = openSideRef.current === 'right' ? REVEAL_WIDTH : openSideRef.current === 'left' ? -REVEAL_WIDTH : 0;
-        const finalDx = base + g.dx;
-
-        if (finalDx > ACTIVATION_THRESHOLD && rightAction !== 'none') {
-          openRight();
-        } else if (finalDx < -ACTIVATION_THRESHOLD && leftAction !== 'none') {
-          openLeft();
-        } else {
-          close();
-        }
        claimed.current = false;
+        if (g.dx >= COMMIT_THRESHOLD && rightAction !== 'none') {
+          fly(widthRef.current || EXIT_DISTANCE, rightAction);
+        } else if (g.dx <= -COMMIT_THRESHOLD && leftAction !== 'none') {
+          fly(-(widthRef.current || EXIT_DISTANCE), leftAction);
+        } else {
+          snapBack();
+        }
      },
      onPanResponderTerminate: () => {
-        close();
+        snapBack();
        claimed.current = false;
      },
      onPanResponderTerminationRequest: () => !claimed.current,
    }),
  ).current;

-  const fireAction = (action: SwipeAction) => {
-    close();
-    if (action !== 'none') onAction(action);
-  };
-
  const renderBand = (action: SwipeAction, side: 'left' | 'right') => {
    if (action === 'none') return null;
    const meta = ACTION_META[action];
    const Icon = meta.icon;
    const label = actionLabel(action, context);
+    // Band stretches to fill the gap behind the row as it's dragged. We
+    // animate the icon a touch to signal commit-readiness.
+    const inputRange = side === 'left' ? [0, COMMIT_THRESHOLD] : [-COMMIT_THRESHOLD, 0];
+    const iconScale = dx.interpolate({
+      inputRange,
+      outputRange: side === 'left' ? [0.85, 1.15] : [1.15, 0.85],
+      extrapolate: 'clamp',
+    });
    return (
-      <Pressable
-        onPress={() => fireAction(action)}
+      <View
        style={[
          styles.band,
-          side === 'left' ? { left: 0, alignItems: 'flex-start' } : { right: 0, alignItems: 'flex-end' },
-          { backgroundColor: meta.bg, width: REVEAL_WIDTH },
+          { backgroundColor: meta.bg },
+          side === 'left' ? { justifyContent: 'flex-start' } : { justifyContent: 'flex-end' },
        ]}
      >
-        <View style={styles.bandInner}>
-          <Icon size={20} color="#fff" />
+        <Animated.View style={[styles.bandInner, { transform: [{ scale: iconScale }] }]}>
+          <Icon size={22} color="#fff" />
          <Text style={styles.bandLabel}>{label}</Text>
-        </View>
-      </Pressable>
+        </Animated.View>
+      </View>
    );
  };

@@ -143,20 +155,29 @@ export function SwipeableRow({
    widthRef.current = e.nativeEvent.layout.width;
  };

+  // Show the matching band based on current drag direction. Both bands occupy
+  // the full row, so we fade the inactive one out to avoid bleed-through.
+  const rightBandOpacity = dx.interpolate({
+    inputRange: [-1, 0, 1],
+    outputRange: [0, 0, 1],
+    extrapolate: 'clamp',
+  });
+  const leftBandOpacity = dx.interpolate({
+    inputRange: [-1, 0, 1],
+    outputRange: [1, 0, 0],
+    extrapolate: 'clamp',
+  });
+
  return (
    <View style={styles.wrap} onLayout={onLayout} {...responder.panHandlers}>
-      {renderBand(rightAction, 'left')}
-      {renderBand(leftAction, 'right')}
+      <Animated.View style={[StyleSheet.absoluteFill, { opacity: rightBandOpacity }]} pointerEvents="none">
+        {renderBand(rightAction, 'left')}
+      </Animated.View>
+      <Animated.View style={[StyleSheet.absoluteFill, { opacity: leftBandOpacity }]} pointerEvents="none">
+        {renderBand(leftAction, 'right')}
+      </Animated.View>
      <Animated.View style={[styles.content, { transform: [{ translateX: dx }] }]}>
        {children}
-        {/* When an action is revealed, an overlay absorbs taps on the row so a
-            tap closes the swipe instead of opening the email. */}
-        {openSide ? (
-          <Pressable
-            style={StyleSheet.absoluteFill}
-            onPress={close}
-          />
-        ) : null}
      </Animated.View>
    </View>
  );
@@ -164,14 +185,13 @@ export function SwipeableRow({

 function makeStyles(c: ThemePalette) {
  return StyleSheet.create({
-  wrap: { position: 'relative', backgroundColor: c.background },
+  wrap: { position: 'relative', backgroundColor: c.background, overflow: 'hidden' },
  content: { backgroundColor: c.background },
  band: {
-    position: 'absolute',
-    top: 0,
-    bottom: 0,
-    justifyContent: 'center',
-    paddingHorizontal: 16,
+    flex: 1,
+    flexDirection: 'row',
+    alignItems: 'center',
+    paddingHorizontal: 24,
  },
  bandInner: { alignItems: 'center', gap: 4 },
  bandLabel: { ...typography.caption, color: '#fff', fontWeight: '600' },
@@ -0,0 +1,120 @@
+import React from 'react';
+import { View, Text, StyleSheet, Pressable, Animated, Easing } from 'react-native';
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+import { spacing, radius, typography, type ThemePalette } from '../theme/tokens';
+import { useColors } from '../theme/colors';
+import { useEmailStore } from '../stores/email-store';
+
+const VISIBLE_MS = 5000;
+
+export function UndoSnackbar() {
+  const c = useColors();
+  const styles = React.useMemo(() => makeStyles(c), [c]);
+  const insets = useSafeAreaInsets();
+  const entry = useEmailStore((s) => s.pendingUndo);
+  const undoLast = useEmailStore((s) => s.undoLast);
+  const clearUndo = useEmailStore((s) => s.clearUndo);
+  const slideY = React.useRef(new Animated.Value(120)).current;
+  const opacity = React.useRef(new Animated.Value(0)).current;
+  // Remember the last non-null entry so the bar's text/handlers stay valid
+  // while it animates out after pendingUndo flips to null.
+  const [shown, setShown] = React.useState(entry);
+
+  React.useEffect(() => {
+    if (entry) setShown(entry);
+  }, [entry]);
+
+  // Drive the auto-dismiss off the entry's createdAt so re-renders during
+  // animation don't reset the timer, and so consecutive actions reset it.
+  React.useEffect(() => {
+    if (!entry) {
+      Animated.parallel([
+        Animated.timing(slideY, { toValue: 120, duration: 180, easing: Easing.in(Easing.cubic), useNativeDriver: true }),
+        Animated.timing(opacity, { toValue: 0, duration: 180, useNativeDriver: true }),
+      ]).start(({ finished }) => {
+        if (finished) setShown(null);
+      });
+      return;
+    }
+
+    Animated.parallel([
+      Animated.timing(slideY, { toValue: 0, duration: 220, easing: Easing.out(Easing.cubic), useNativeDriver: true }),
+      Animated.timing(opacity, { toValue: 1, duration: 220, useNativeDriver: true }),
+    ]).start();
+
+    const elapsed = Date.now() - entry.createdAt;
+    const remaining = Math.max(0, VISIBLE_MS - elapsed);
+    const id = setTimeout(() => {
+      // Only clear if the entry is still the same one we scheduled for.
+      if (useEmailStore.getState().pendingUndo === entry) {
+        clearUndo();
+      }
+    }, remaining);
+    return () => clearTimeout(id);
+  }, [entry, slideY, opacity, clearUndo]);
+
+  if (!shown) return null;
+
+  return (
+    <Animated.View
+      pointerEvents="box-none"
+      style={[
+        styles.wrap,
+        { bottom: insets.bottom + spacing.md, opacity, transform: [{ translateY: slideY }] },
+      ]}
+    >
+      <View style={styles.bar}>
+        <Text style={styles.label} numberOfLines={1}>{shown.label}</Text>
+        <Pressable
+          onPress={() => { void undoLast(); }}
+          hitSlop={8}
+          style={({ pressed }) => [styles.undoBtn, pressed && styles.undoBtnPressed]}
+        >
+          <Text style={styles.undoText}>UNDO</Text>
+        </Pressable>
+      </View>
+    </Animated.View>
+  );
+}
+
+function makeStyles(c: ThemePalette) {
+  return StyleSheet.create({
+    wrap: {
+      position: 'absolute',
+      left: spacing.md,
+      right: spacing.md,
+    },
+    bar: {
+      flexDirection: 'row',
+      alignItems: 'center',
+      paddingVertical: spacing.sm + 2,
+      paddingLeft: spacing.lg,
+      paddingRight: spacing.sm,
+      borderRadius: radius.md,
+      backgroundColor: c.text,
+      shadowColor: '#000',
+      shadowOpacity: 0.3,
+      shadowRadius: 12,
+      shadowOffset: { width: 0, height: 6 },
+      elevation: 8,
+    },
+    label: {
+      ...typography.body,
+      color: c.background,
+      flex: 1,
+    },
+    undoBtn: {
+      paddingHorizontal: spacing.md,
+      paddingVertical: spacing.sm,
+      borderRadius: radius.sm,
+    },
+    undoBtnPressed: {
+      backgroundColor: 'rgba(255,255,255,0.1)',
+    },
+    undoText: {
+      ...typography.bodySemibold,
+      color: c.primary,
+      letterSpacing: 0.5,
+    },
+  });
+}
@@ -13,6 +13,8 @@ const SWIPE_OPTIONS: { value: SwipeAction; label: string }[] = [
  { value: 'spam',    label: 'Spam' },
  { value: 'read',    label: 'Read/Unread' },
  { value: 'star',    label: 'Star' },
+  { value: 'pin',     label: 'Pin' },
+  { value: 'move',    label: 'Move to folder' },
 ];

 export function LayoutSettings() {
@@ -61,7 +63,7 @@ export function LayoutSettings() {

      <SettingItem
        label=""
-        description="Drag past about half a row to commit; lift earlier to cancel."
+        description="Swipe past the threshold and release to fire the action; release before to cancel."
      />
    </SettingsSection>
  );
@@ -1,14 +1,15 @@
 import React, { useEffect, useState } from 'react';
-import { View, Text, StyleSheet, Pressable, TextInput } from 'react-native';
+import { ActivityIndicator, View, Text, StyleSheet, Pressable, TextInput } from 'react-native';
 import { AlertTriangle, FolderSync, Mail, X } from 'lucide-react-native';
 import { SettingsSection, SettingItem, Select, RadioGroup, ToggleSwitch } from './settings-section';
 import { spacing, radius, typography, type ThemePalette } from '../../theme/tokens';
 import { useColors } from '../../theme/colors';
-import { useSettingsStore, type ExternalContentPolicy } from '../../stores/settings-store';
+import { useSettingsStore, type ArchiveMode, type ExternalContentPolicy } from '../../stores/settings-store';
+import { useEmailStore } from '../../stores/email-store';
+import { archiveEmails, queryEmails, getEmails } from '../../api/email';

 type MailLayout = 'split' | 'focus';
 type DeleteAction = 'trash' | 'permanent';
-type ArchiveMode = 'single' | 'year' | 'month';
 type AttachmentAction = 'preview' | 'download';
 type AttachmentPosition = 'beside-sender' | 'below-header';

@@ -77,6 +78,8 @@ export function ReadingSettings() {
  const removeTrustedSender = useSettingsStore((s) => s.removeTrustedSender);
  const hydrated = useSettingsStore((s) => s.hydrated);
  const hydrate = useSettingsStore((s) => s.hydrate);
+  const archiveMode = useSettingsStore((s) => s.archiveMode);
+  const setArchiveMode = useSettingsStore((s) => s.setArchiveMode);

  const [markAsReadDelay, setMarkAsReadDelay] = useState('0');
  const [deleteAction, setDeleteAction] = useState<DeleteAction>('trash');
@@ -90,7 +93,8 @@ export function ReadingSettings() {
  const [mailAttachmentAction, setMailAttachmentAction] = useState<AttachmentAction>('preview');
  const [attachmentPosition, setAttachmentPosition] = useState<AttachmentPosition>('beside-sender');
  const [emailAlwaysLightMode, setEmailAlwaysLightMode] = useState(false);
-  const [archiveMode, setArchiveMode] = useState<ArchiveMode>('single');
+  const [reorganizing, setReorganizing] = useState(false);
+  const [reorganizeResult, setReorganizeResult] = useState<string | null>(null);
  const [attachmentReminderEnabled, setAttachmentReminderEnabled] = useState(true);
  const [attachmentReminderKeywords, setAttachmentReminderKeywords] = useState<string[]>(DEFAULT_KEYWORDS);
  const [newKeyword, setNewKeyword] = useState('');
@@ -102,6 +106,61 @@ export function ReadingSettings() {
    if (!hydrated) void hydrate();
  }, [hydrated, hydrate]);

+  const handleReorganizeArchive = async () => {
+    const { mailboxes, fetchMailboxes } = useEmailStore.getState();
+    const archiveMailbox = mailboxes.find(
+      (m) => m.role === 'archive' || m.name.toLowerCase() === 'archive',
+    );
+    if (!archiveMailbox) {
+      setReorganizeResult('No archive folder found.');
+      return;
+    }
+
+    setReorganizing(true);
+    setReorganizeResult(null);
+
+    try {
+      // Drain the archive in pages so we don't OOM on huge mailboxes.
+      const PAGE = 100;
+      let position = 0;
+      let total = 0;
+      let moved = 0;
+
+      while (true) {
+        const { ids, total: pageTotal } = await queryEmails(archiveMailbox.id, {
+          position,
+          limit: PAGE,
+        });
+        if (position === 0) total = pageTotal;
+        if (ids.length === 0) break;
+
+        const list = await getEmails(ids);
+        const refreshed = useEmailStore.getState().mailboxes;
+        await archiveEmails(
+          list.map((e) => ({ id: e.id, receivedAt: e.receivedAt })),
+          archiveMailbox.id,
+          archiveMode,
+          refreshed,
+        );
+        moved += list.length;
+
+        // Newly-created year/month folders need to be visible to the next batch
+        // so we don't try to create the same folder twice.
+        await fetchMailboxes();
+
+        // Items just got moved out of the root archive view; the next page
+        // starts again at position 0 of the now-shorter list.
+        if (ids.length < PAGE) break;
+      }
+
+      setReorganizeResult(`Moved ${moved} of ${total} emails.`);
+    } catch (err) {
+      setReorganizeResult(err instanceof Error ? err.message : 'Reorganize failed.');
+    } finally {
+      setReorganizing(false);
+    }
+  };
+
  return (
    <SettingsSection title="Email Behavior" description="How your inbox behaves day to day.">
      <SettingItem label="Mark as Read" description="When to flag an email as read.">
@@ -148,10 +207,25 @@ export function ReadingSettings() {
          ]}
        />
        {archiveMode !== 'single' && (
-          <Pressable style={styles.inlineBtn}>
-            <FolderSync size={14} color={c.text} />
-            <Text style={styles.inlineBtnText}>Reorganize existing archive</Text>
-          </Pressable>
+          <>
+            <Pressable
+              style={[styles.inlineBtn, reorganizing && styles.inlineBtnDisabled]}
+              onPress={reorganizing ? undefined : handleReorganizeArchive}
+              disabled={reorganizing}
+            >
+              {reorganizing ? (
+                <ActivityIndicator size="small" color={c.text} />
+              ) : (
+                <FolderSync size={14} color={c.text} />
+              )}
+              <Text style={styles.inlineBtnText}>
+                {reorganizing ? 'Reorganizing…' : 'Reorganize existing archive'}
+              </Text>
+            </Pressable>
+            {reorganizeResult && (
+              <Text style={styles.reorganizeResult}>{reorganizeResult}</Text>
+            )}
+          </>
        )}
        <View style={styles.divider} />
      </View>
@@ -327,6 +401,14 @@ function makeStyles(c: ThemePalette) {
    ...typography.body,
    color: c.text,
  },
+  inlineBtnDisabled: {
+    opacity: 0.6,
+  },
+  reorganizeResult: {
+    ...typography.caption,
+    color: c.mutedForeground,
+    marginTop: spacing.xs,
+  },
  subLabel: {
    ...typography.bodyMedium,
    color: c.text,
@@ -1,3 +1,4 @@
+import { Platform } from 'react-native';
 import { File, Paths } from 'expo-file-system';
 import * as Sharing from 'expo-sharing';
 import { jmapClient } from '../api/jmap-client';
@@ -18,6 +19,15 @@ function safeAttachmentName(name: string | undefined, type: string | undefined):
  return `attachment.${fallbackExt}`;
 }

+// On Android, sharing a `file://` URI from the cache directory throws a
+// FileUriExposedException on modern OS versions; the system requires a
+// FileProvider-backed `content://` URI instead. expo-file-system exposes that
+// via `file.contentUri`, which is the only field iOS doesn't expose.
+function shareableUri(file: { uri: string; contentUri?: string }): string {
+  if (Platform.OS === 'android' && file.contentUri) return file.contentUri;
+  return file.uri;
+}
+
 export async function shareAttachment(
  blobId: string,
  name: string | undefined,
@@ -26,15 +36,15 @@ export async function shareAttachment(
  const filename = safeAttachmentName(name, type);
  const mimeType = type || 'application/octet-stream';
  const dest = new File(Paths.cache, filename);
-  if (dest.exists) dest.delete();
  const url = getDownloadUrl(blobId, filename, mimeType);
  const downloaded = await File.downloadFileAsync(url, dest, {
    headers: { Authorization: authHeader() },
+    idempotent: true,
  });
  if (!(await Sharing.isAvailableAsync())) {
    throw new Error('Sharing is not available on this device');
  }
-  await Sharing.shareAsync(downloaded.uri, {
+  await Sharing.shareAsync(shareableUri(downloaded), {
    mimeType,
    dialogTitle: filename,
  });
@@ -54,15 +64,15 @@ function safeFilename(subject: string | undefined): string {

 export async function shareEmailEml(blobId: string, subject?: string): Promise<void> {
  const dest = new File(Paths.cache, safeFilename(subject));
-  if (dest.exists) dest.delete();
  const url = getDownloadUrl(blobId, dest.name, RFC822);
  const downloaded = await File.downloadFileAsync(url, dest, {
    headers: { Authorization: authHeader() },
+    idempotent: true,
  });
  if (!(await Sharing.isAvailableAsync())) {
    throw new Error('Sharing is not available on this device');
  }
-  await Sharing.shareAsync(downloaded.uri, {
+  await Sharing.shareAsync(shareableUri(downloaded), {
    mimeType: RFC822,
    dialogTitle: 'Share email',
    UTI: 'public.email-message',
@@ -144,7 +144,11 @@ async function pollVerificationCode(
  relayBaseUrl: string,
  subscriptionId: string,
 ): Promise<string> {
-  const timeoutAt = Date.now() + 20_000;
+  // Stalwart per-account rate-limits PushVerification posts (default 60s).
+  // If there are leftover unverified subscriptions on the account, our new
+  // one queues up behind them - so we wait long enough to clear at least one
+  // verify window even in the unlucky case.
+  const timeoutAt = Date.now() + 75_000;
  let delay = 400;
  while (Date.now() < timeoutAt) {
    const res = await fetch(
@@ -203,10 +207,10 @@ export async function setupPushNotifications(

  // Reuse the previous JMAP subscription when the server still has it, but
  // push the expiry forward so it doesn't time out before the next app start.
+  const existingSubs = await listPushSubscriptions().catch(() => []);
  const storedServerId = await AsyncStorage.getItem(SUBSCRIPTION_ID_KEY);
  if (storedServerId) {
-    const existing = await listPushSubscriptions().catch(() => []);
-    const match = existing.find((s) => s.id === storedServerId);
+    const match = existingSubs.find((s) => s.id === storedServerId);
    if (match) {
      const refreshed = await refreshSubscriptionExpires(match);
      if (refreshed) {
@@ -219,6 +223,18 @@ export async function setupPushNotifications(
    await AsyncStorage.removeItem(SUBSCRIPTION_ID_KEY);
  }

+  // Reap any leftover Stalwart subscriptions still bound to this device.
+  // These pile up when a previous enable attempt failed mid-flow (verify
+  // race, network blip, app killed). Stalwart per-account rate-limits
+  // PushVerification posts, so leaving stragglers around blocks the new
+  // one's verification - the symptom is a confusing "code does not match".
+  const stragglers = existingSubs.filter(
+    (s) => s.deviceClientId === deviceClientId && s.id !== storedServerId,
+  );
+  for (const s of stragglers) {
+    await destroyPushSubscription(s.id).catch(() => undefined);
+  }
+
  const serverAssignedId = await createPushSubscription({
    deviceClientId,
    url: buildRelayUrl(relayBaseUrl, `/api/push/jmap/${encodeURIComponent(deviceClientId)}`),
@@ -13,6 +13,7 @@ import {
 } from 'lucide-react-native';
 import * as ImagePicker from 'expo-image-picker';
 import * as FileSystem from 'expo-file-system/legacy';
+import { File as FsFile } from 'expo-file-system';
 import { spacing, radius, typography, componentSizes, type ThemePalette } from '../theme/tokens';
 import { useColors } from '../theme/colors';
 import { Button } from '../components';
@@ -486,7 +487,7 @@ export default function ComposeScreen({ route, navigation }: Props) {
    }
  };

-  const pickAttachment = async () => {
+  const pickPhotoAttachments = async () => {
    const perm = await ImagePicker.requestMediaLibraryPermissionsAsync();
    if (!perm.granted) {
      Alert.alert(
@@ -516,6 +517,53 @@ export default function ComposeScreen({ route, navigation }: Props) {
    }
  };

+  const pickFileAttachment = async () => {
+    // pickFileAsync's return type is the lower-level FileSystemFile, not the
+    // public `File` wrapper. Both expose the fields we need (uri/name/size/type).
+    type PickedFile = { uri: string; name?: string; size?: number; type?: string };
+    let picked: PickedFile | undefined;
+    try {
+      const result = await FsFile.pickFileAsync();
+      picked = (Array.isArray(result) ? result[0] : result) as PickedFile;
+    } catch (e) {
+      // The picker rejects with PickerCancelledException when the user backs
+      // out — treat that as a no-op rather than surfacing an error.
+      const message = e instanceof Error ? e.message : String(e);
+      if (/cancel/i.test(message)) return;
+      Alert.alert(t('email_composer.attach', 'Attach'), message);
+      return;
+    }
+    if (!picked) return;
+    const type = picked.type || 'application/octet-stream';
+    const name = picked.name || `attachment-${Date.now()}`;
+    const entry = addUploadEntry({
+      name,
+      type,
+      size: picked.size ?? 0,
+      uri: picked.uri,
+      inline: false,
+    });
+    void startUpload(entry);
+  };
+
+  const pickAttachment = () => {
+    Alert.alert(
+      t('email_composer.attach', 'Attach'),
+      undefined,
+      [
+        {
+          text: t('email_composer.attach_photos', 'Photos & Videos'),
+          onPress: () => { void pickPhotoAttachments(); },
+        },
+        {
+          text: t('email_composer.attach_files', 'Files'),
+          onPress: () => { void pickFileAttachment(); },
+        },
+        { text: t('email_composer.cancel', 'Cancel'), style: 'cancel' },
+      ],
+    );
+  };
+
  const insertInlineImage = async () => {
    const perm = await ImagePicker.requestMediaLibraryPermissionsAsync();
    if (!perm.granted) {
@@ -11,6 +11,8 @@ import { useColors } from '../theme/colors';
 import SidebarDrawer from '../components/SidebarDrawer';
 import SenderAvatar from '../components/SenderAvatar';
 import { SwipeableRow } from '../components/SwipeableRow';
+import { MoveSheet } from '../components/MoveSheet';
+import { UndoSnackbar } from '../components/UndoSnackbar';
 import { OfflineBanner } from '../components/OfflineBanner';
 import { useNetworkStore } from '../stores/network-store';
 import { useEmailStore, type EmailFilters } from '../stores/email-store';
@@ -33,6 +35,10 @@ function isStarred(email: Email): boolean {
  return !!email.keywords?.$flagged;
 }

+function isPinned(email: Email): boolean {
+  return !!email.keywords?.$important;
+}
+
 function formatRelativeTime(date: Date): string {
  const now = Date.now();
  const diffMs = now - date.getTime();
@@ -164,8 +170,10 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
  const markRead = useEmailStore((s) => s.markRead);
  const markUnread = useEmailStore((s) => s.markUnread);
  const toggleStar = useEmailStore((s) => s.toggleStar);
+  const togglePin = useEmailStore((s) => s.togglePin);
  const deleteEmailAction = useEmailStore((s) => s.deleteEmail);
  const moveToMailboxAction = useEmailStore((s) => s.moveToMailbox);
+  const archiveEmailAction = useEmailStore((s) => s.archiveEmail);

  const swipeLeftAction = useSettingsStore((s) => s.swipeLeftAction);
  const swipeRightAction = useSettingsStore((s) => s.swipeRightAction);
@@ -184,6 +192,9 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
    [mailboxes],
  );

+  // Move-to-folder picker triggered by the swipe action.
+  const [pendingMoveId, setPendingMoveId] = React.useState<string | null>(null);
+
  // Selection state
  const [selectedIds, setSelectedIds] = React.useState<Set<string>>(new Set());
  const selectionMode = selectedIds.size > 0;
@@ -225,7 +236,7 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
    switch (action) {
      case 'archive':
        if (archiveMailboxId && currentMailboxId !== archiveMailboxId) {
-          void moveToMailboxAction(id, currentMailboxId, archiveMailboxId);
+          void archiveEmailAction(id);
        }
        break;
      case 'delete':
@@ -245,10 +256,17 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
      case 'star':
        void toggleStar(id, !isStarred(email));
        break;
+      case 'pin':
+        void togglePin(id, !isPinned(email));
+        break;
+      case 'move':
+        setPendingMoveId(id);
+        break;
    }
  }, [
    currentMailboxId, archiveMailboxId, trashMailboxId, junkMailboxId,
-    moveToMailboxAction, deleteEmailAction, markRead, markUnread, toggleStar,
+    moveToMailboxAction, archiveEmailAction, deleteEmailAction,
+    markRead, markUnread, toggleStar, togglePin,
  ]);

  const renderEmailRow = React.useCallback(
@@ -256,7 +274,7 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
      <SwipeableRow
        leftAction={selectionMode ? 'none' : swipeLeftAction}
        rightAction={selectionMode ? 'none' : swipeRightAction}
-        context={{ unread: isUnread(item), starred: isStarred(item) }}
+        context={{ unread: isUnread(item), starred: isStarred(item), pinned: isPinned(item) }}
        onAction={(action) => handleSwipeAction(item.id, action)}
      >
        <EmailRow
@@ -809,6 +827,22 @@ export default function EmailListScreen({ onEmailPress, onComposePress }: EmailL
          />
        );
      })()}
+
+      <MoveSheet
+        visible={pendingMoveId !== null}
+        onClose={() => setPendingMoveId(null)}
+        mailboxes={mailboxes}
+        currentMailboxId={currentMailboxId}
+        onPick={(toId) => {
+          const id = pendingMoveId;
+          setPendingMoveId(null);
+          if (id && currentMailboxId && toId !== currentMailboxId) {
+            void moveToMailboxAction(id, currentMailboxId, toId);
+          }
+        }}
+      />
+
+      <UndoSnackbar />
    </SafeAreaView>
  );
 }
@@ -9,33 +9,21 @@ import {
  ArrowLeft, Star, Trash2, MoreVertical, Reply, ReplyAll, Forward,
  ChevronLeft, ChevronRight, Paperclip, Archive, Mail, MailOpen,
  FolderInput, ShieldAlert, ShieldCheck, X, Check,
-  Inbox, Send, File as FileIcon, Ban, Folder, Code, Download, Tag,
+  Code, Download, Tag,
 } from 'lucide-react-native';
-import type { LucideIcon } from 'lucide-react-native';
 import { spacing, radius, typography, componentSizes, type ThemePalette } from '../theme/tokens';
 import { useColors } from '../theme/colors';
 import EmailBodyView from '../components/EmailBodyView';
 import SenderAvatar from '../components/SenderAvatar';
+import { MoveSheet } from '../components/MoveSheet';
 import { useEmailStore } from '../stores/email-store';
 import { setEmailKeywords } from '../api/email';
 import { shareEmailEml, shareAttachment } from '../lib/email-export';
 import { useKeywordsStore, keywordToken, type KeywordDef } from '../stores/keywords-store';
-import { buildMailboxTree, flattenVisible, type MailboxNode } from '../lib/mailbox-tree';
 import { useSheetDrag } from '../lib/use-sheet-drag';
 import type { Email, Mailbox } from '../api/types';
 import type { RootStackParamList } from '../navigation/types';

-function moveTargetIcon(role: string | null | undefined, name: string): LucideIcon {
-  const lower = name.toLowerCase();
-  if (role === 'inbox' || lower.includes('inbox')) return Inbox;
-  if (role === 'sent' || lower.includes('sent')) return Send;
-  if (role === 'drafts' || lower.includes('draft')) return FileIcon;
-  if (role === 'trash' || lower.includes('trash') || lower.includes('deleted')) return Trash2;
-  if (role === 'junk' || role === 'spam' || lower.includes('junk') || lower.includes('spam')) return Ban;
-  if (role === 'archive' || lower.includes('archive')) return Archive;
-  return Folder;
-}
-
 type Props = NativeStackScreenProps<RootStackParamList, 'EmailThread'>;

 function formatHeaderDate(iso: string): string {
@@ -71,6 +59,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
  const markRead = useEmailStore((s) => s.markRead);
  const deleteEmail = useEmailStore((s) => s.deleteEmail);
  const moveToMailbox = useEmailStore((s) => s.moveToMailbox);
+  const archiveEmailAction = useEmailStore((s) => s.archiveEmail);
  const mailboxes = useEmailStore((s) => s.mailboxes);
  const currentMailboxId = useEmailStore((s) => s.currentMailboxId);
  const emails = useEmailStore((s) => s.emails);
@@ -200,7 +189,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
  const onArchive = () => {
    if (!email || !currentMailboxId || !archiveMailbox) return;
    if (currentMailboxId === archiveMailbox.id) return;
-    void moveToMailbox(email.id, currentMailboxId, archiveMailbox.id);
+    void archiveEmailAction(email.id);
    navigation.goBack();
  };

@@ -492,7 +481,7 @@ export default function EmailThreadScreen({ route, navigation }: Props) {
        }}
      />

-      <MoveMenuSheet
+      <MoveSheet
        visible={moveMenuOpen}
        onClose={() => setMoveMenuOpen(false)}
        mailboxes={mailboxes}
@@ -725,107 +714,6 @@ function TagMenuSheet({ visible, onClose, keywords, activeKeywords, onToggle }:
  );
 }

-interface MoveMenuSheetProps {
-  visible: boolean;
-  onClose: () => void;
-  mailboxes: Mailbox[];
-  currentMailboxId: string | null;
-  onPick: (id: string) => void;
-}
-
-function MoveMenuSheet({ visible, onClose, mailboxes, currentMailboxId, onPick }: MoveMenuSheetProps) {
-  const c = useColors();
-  const styles = React.useMemo(() => makeStyles(c), [c]);
-  const insets = useSafeAreaInsets();
-  const slideY = React.useRef(new Animated.Value(500)).current;
-  const overlayOpacity = React.useRef(new Animated.Value(0)).current;
-  const dragHandlers = useSheetDrag({ slideY, closedY: 500, onClose });
-
-  React.useEffect(() => {
-    if (visible) {
-      Animated.parallel([
-        Animated.timing(slideY, { toValue: 0, duration: 220, easing: Easing.out(Easing.cubic), useNativeDriver: true }),
-        Animated.timing(overlayOpacity, { toValue: 1, duration: 220, useNativeDriver: true }),
-      ]).start();
-    } else {
-      Animated.parallel([
-        Animated.timing(slideY, { toValue: 500, duration: 180, easing: Easing.in(Easing.cubic), useNativeDriver: true }),
-        Animated.timing(overlayOpacity, { toValue: 0, duration: 180, useNativeDriver: true }),
-      ]).start();
-    }
-  }, [visible, slideY, overlayOpacity]);
-
-  const visibleNodes = React.useMemo(() => {
-    const tree = buildMailboxTree(mailboxes);
-    const expanded = new Set<string>();
-    const collect = (nodes: MailboxNode[]) => {
-      for (const n of nodes) {
-        if (n.children.length > 0) {
-          expanded.add(n.id);
-          collect(n.children);
-        }
-      }
-    };
-    collect(tree);
-    return flattenVisible(tree, expanded);
-  }, [mailboxes]);
-
-  return (
-    <Modal visible={visible} transparent animationType="none" onRequestClose={onClose} statusBarTranslucent>
-      <Animated.View style={[styles.sheetOverlay, { opacity: overlayOpacity }]}>
-        <Pressable style={styles.sheetOverlayPress} onPress={onClose} />
-      </Animated.View>
-      <Animated.View
-        style={[
-          styles.sheet,
-          styles.sheetTall,
-          { paddingBottom: Math.max(insets.bottom, spacing.md), transform: [{ translateY: slideY }] },
-        ]}
-      >
-        <View {...dragHandlers}>
-          <View style={styles.sheetHandleHit}>
-            <View style={styles.sheetHandle} />
-          </View>
-          <View style={styles.sheetHeader}>
-            <Text style={styles.sheetTitle}>Move to folder</Text>
-            <Pressable onPress={onClose} hitSlop={8} style={styles.sheetClose}>
-              <X size={18} color={c.textSecondary} />
-            </Pressable>
-          </View>
-        </View>
-        <ScrollView>
-          {visibleNodes.map((node) => {
-            const Icon = moveTargetIcon(node.role, node.name);
-            const isCurrent = node.id === currentMailboxId;
-            const canTarget = node.myRights?.mayAddItems !== false && !isCurrent;
-            return (
-              <Pressable
-                key={node.id}
-                onPress={canTarget ? () => onPick(node.id) : undefined}
-                disabled={!canTarget}
-                style={({ pressed }) => [
-                  styles.moveRow,
-                  pressed && canTarget && styles.moveRowPressed,
-                  { paddingLeft: spacing.lg + node.depth * 16 },
-                ]}
-              >
-                <Icon size={16} color={canTarget ? c.textSecondary : c.textMuted} />
-                <Text
-                  style={[styles.moveRowLabel, !canTarget && styles.moveRowLabelDisabled]}
-                  numberOfLines={1}
-                >
-                  {node.name}
-                </Text>
-                {isCurrent && <Check size={14} color={c.textMuted} />}
-              </Pressable>
-            );
-          })}
-        </ScrollView>
-      </Animated.View>
-    </Modal>
-  );
-}
-
 function MoreMenuItem({
  icon, label, onPress, trailing,
 }: { icon: React.ReactNode; label: string; onPress?: () => void; trailing?: React.ReactNode }) {
@@ -1106,9 +994,6 @@ function makeStyles(c: ThemePalette) {
    borderColor: c.border,
    paddingTop: spacing.sm,
  },
-  sheetTall: {
-    maxHeight: '75%',
-  },
  sheetHandleHit: {
    alignItems: 'center',
    paddingTop: spacing.xs,
@@ -1162,23 +1047,5 @@ function makeStyles(c: ThemePalette) {
    flex: 1,
  },

-  // Move folder row
-  moveRow: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    gap: spacing.sm,
-    paddingRight: spacing.lg,
-    paddingVertical: spacing.sm + 2,
-    minHeight: 44,
-  },
-  moveRowPressed: { backgroundColor: c.surfaceHover },
-  moveRowLabel: {
-    ...typography.body,
-    color: c.text,
-    flex: 1,
-  },
-  moveRowLabelDisabled: {
-    color: c.textMuted,
-  },
  });
 }
@@ -7,10 +7,19 @@ vi.mock('../../api/email', () => ({
  getFullEmail: vi.fn(),
  setEmailKeywords: vi.fn(),
  moveEmail: vi.fn(),
+  archiveEmails: vi.fn(),
+  restoreEmailMailboxes: vi.fn(),
  deleteEmail: vi.fn(),
  searchEmails: vi.fn(),
 }));

+// settings-store transitively pulls in jmap-client / expo-secure-store, which
+// trip on react-native's Flow-typed entrypoint under vitest. The store only
+// reads archiveMode in archiveEmail, so a minimal stub is enough.
+vi.mock('../settings-store', () => ({
+  useSettingsStore: { getState: () => ({ archiveMode: 'single' }) },
+}));
+
 import * as emailApi from '../../api/email';
 import { useEmailStore } from '../email-store';

@@ -9,10 +9,13 @@ import {
  getFullEmail,
  setEmailKeywords,
  moveEmail,
+  archiveEmails as apiArchiveEmails,
  deleteEmail as apiDeleteEmail,
+  restoreEmailMailboxes,
  searchEmails as apiSearchEmails,
 } from '../api/email';
 import { toWildcardQuery } from '../lib/search-utils';
+import { useSettingsStore } from './settings-store';

 export interface EmailFilters {
  from?: string;
@@ -25,6 +28,19 @@ export interface EmailFilters {
  isUnread?: boolean;
 }

+// Snapshot of an action that can still be reversed via the undo snackbar.
+// We store the full email object so undo can re-insert it into the visible list
+// optimistically without waiting for a refetch.
+export interface UndoEntry {
+  kind: 'archive' | 'delete' | 'move' | 'spam';
+  /** Human-readable label shown in the snackbar (e.g. "Email archived"). */
+  label: string;
+  /** Time the entry was created - the snackbar uses this to drive its timer. */
+  createdAt: number;
+  /** Each item is one email's pre-action mailboxIds, used to restore it. */
+  items: Array<{ email: Email; originalMailboxIds: Record<string, boolean> }>;
+}
+
 export interface EmailState {
  mailboxes: Mailbox[];
  currentMailboxId: string | null;
@@ -34,6 +50,7 @@ export interface EmailState {
  error: string | null;
  searchQuery: string;
  filters: EmailFilters;
+  pendingUndo: UndoEntry | null;

  fetchMailboxes: () => Promise<void>;
  selectMailbox: (mailboxId: string) => Promise<void>;
@@ -43,8 +60,12 @@ export interface EmailState {
  markRead: (emailId: string) => Promise<void>;
  markUnread: (emailId: string) => Promise<void>;
  toggleStar: (emailId: string, starred: boolean) => Promise<void>;
+  togglePin: (emailId: string, pinned: boolean) => Promise<void>;
  moveToMailbox: (emailId: string, fromMailboxId: string, toMailboxId: string) => Promise<void>;
+  archiveEmail: (emailId: string) => Promise<void>;
  deleteEmail: (emailId: string, trashMailboxId: string, currentMailboxId: string) => Promise<void>;
+  undoLast: () => Promise<void>;
+  clearUndo: () => void;
  searchEmails: (query: string) => Promise<Email[]>;
  setSearchQuery: (query: string) => void;
  setFilters: (filters: EmailFilters) => void;
@@ -102,6 +123,7 @@ export const useEmailStore = create<EmailState>()(
  error: null,
  searchQuery: '',
  filters: {},
+  pendingUndo: null,

  fetchMailboxes: async () => {
    try {
@@ -115,6 +137,8 @@ export const useEmailStore = create<EmailState>()(

  selectMailbox: async (mailboxId) => {
    // Reset search/filters when switching mailbox - matches webmail behavior.
+    // Switching mailboxes invalidates any pending undo: the snackbar would be
+    // stale and the restored email would re-appear in a different view.
    set({
      currentMailboxId: mailboxId,
      loading: true,
@@ -123,6 +147,7 @@ export const useEmailStore = create<EmailState>()(
      totalEmails: 0,
      searchQuery: '',
      filters: {},
+      pendingUndo: null,
    });
    try {
      const filter = buildJmapFilter(mailboxId, '', {});
@@ -232,16 +257,136 @@ export const useEmailStore = create<EmailState>()(
    });
  },

+  togglePin: async (emailId, pinned) => {
+    const email = get().emails.find((e) => e.id === emailId);
+    if (!email) return;
+    const keywords = { ...email.keywords };
+    if (pinned) {
+      keywords.$important = true;
+    } else {
+      delete keywords.$important;
+    }
+    await setEmailKeywords(emailId, keywords);
+    set({
+      emails: get().emails.map((e) =>
+        e.id === emailId ? { ...e, keywords } : e,
+      ),
+    });
+  },
+
  moveToMailbox: async (emailId, fromMailboxId, toMailboxId) => {
+    const email = get().emails.find((e) => e.id === emailId);
+    const original = email ? { ...email.mailboxIds } : null;
+
    await moveEmail(emailId, fromMailboxId, toMailboxId);
    set({ emails: get().emails.filter((e) => e.id !== emailId) });
+
+    if (email && original) {
+      const targetName = get().mailboxes.find((m) => m.id === toMailboxId)?.name;
+      set({
+        pendingUndo: {
+          kind: 'move',
+          label: targetName ? `Email moved to ${targetName}` : 'Email moved',
+          createdAt: Date.now(),
+          items: [{ email, originalMailboxIds: original }],
+        },
+      });
+    }
+  },
+
+  archiveEmail: async (emailId) => {
+    const { emails, mailboxes } = get();
+    const email = emails.find((e) => e.id === emailId);
+    if (!email) return;
+
+    const archiveMailbox = mailboxes.find(
+      (m) => m.role === 'archive' || m.name.toLowerCase() === 'archive',
+    );
+    if (!archiveMailbox) return;
+    if (email.mailboxIds?.[archiveMailbox.id]) return;
+
+    const mode = useSettingsStore.getState().archiveMode;
+    const original = { ...email.mailboxIds };
+
+    await apiArchiveEmails(
+      [{ id: email.id, receivedAt: email.receivedAt }],
+      archiveMailbox.id,
+      mode,
+      mailboxes,
+    );
+
+    set({
+      emails: get().emails.filter((e) => e.id !== emailId),
+      pendingUndo: {
+        kind: 'archive',
+        label: 'Email archived',
+        createdAt: Date.now(),
+        items: [{ email, originalMailboxIds: original }],
+      },
+    });
+
+    // Auto-sort modes may have created new year/month folders - refresh the
+    // mailbox list so the sidebar picks them up on the next render.
+    if (mode !== 'single') {
+      void get().fetchMailboxes();
+    }
  },

  deleteEmail: async (emailId, trashMailboxId, currentMailboxId) => {
+    const email = get().emails.find((e) => e.id === emailId);
+    const original = email ? { ...email.mailboxIds } : null;
+    const isPermanent = currentMailboxId === trashMailboxId;
+
    await apiDeleteEmail(emailId, trashMailboxId, currentMailboxId);
    set({ emails: get().emails.filter((e) => e.id !== emailId) });
+
+    // Permanent destroy can't be undone - skip the snackbar so we don't
+    // promise an undo we can't deliver.
+    if (email && original && !isPermanent) {
+      set({
+        pendingUndo: {
+          kind: 'delete',
+          label: 'Email moved to Trash',
+          createdAt: Date.now(),
+          items: [{ email, originalMailboxIds: original }],
+        },
+      });
+    }
  },

+  undoLast: async () => {
+    const entry = get().pendingUndo;
+    if (!entry) return;
+    set({ pendingUndo: null });
+
+    try {
+      await restoreEmailMailboxes(
+        entry.items.map((it) => ({ id: it.email.id, mailboxIds: it.originalMailboxIds })),
+      );
+    } catch (err) {
+      set({ error: err instanceof Error ? err.message : 'Undo failed' });
+      return;
+    }
+
+    // Re-insert each restored email into the visible list if its original
+    // mailboxIds include the current view. Server is the source of truth for
+    // ordering, but local re-insertion gives the user instant feedback.
+    const { currentMailboxId, emails } = get();
+    if (currentMailboxId) {
+      const restored = entry.items
+        .filter((it) => it.originalMailboxIds[currentMailboxId])
+        .map((it) => ({ ...it.email, mailboxIds: it.originalMailboxIds }));
+      if (restored.length > 0) {
+        const merged = [...restored, ...emails].sort(
+          (a, b) => new Date(b.receivedAt).getTime() - new Date(a.receivedAt).getTime(),
+        );
+        set({ emails: merged });
+      }
+    }
+  },
+
+  clearUndo: () => set({ pendingUndo: null }),
+
  searchEmails: async (query) => {
    const ids = await apiSearchEmails(query);
    if (ids.length === 0) return [];
@@ -10,7 +10,16 @@ export type Density = 'extra-compact' | 'compact' | 'regular' | 'comfortable';

 const STORAGE_KEY = 'webmail:settings:v1';

-export type SwipeAction = 'none' | 'archive' | 'delete' | 'spam' | 'read' | 'star';
+export type SwipeAction =
+  | 'none'
+  | 'archive'
+  | 'delete'
+  | 'spam'
+  | 'read'
+  | 'star'
+  | 'pin'
+  | 'move';
+export type ArchiveMode = 'single' | 'year' | 'month';

 interface PersistedSettings {
  externalContentPolicy: ExternalContentPolicy;
@@ -31,6 +40,8 @@ interface PersistedSettings {
  // Layout / list interactions
  swipeLeftAction: SwipeAction;
  swipeRightAction: SwipeAction;
+  // Archive
+  archiveMode: ArchiveMode;
 }

 const DEFAULT_PERSISTED: PersistedSettings = {
@@ -49,6 +60,7 @@ const DEFAULT_PERSISTED: PersistedSettings = {
  attachmentReminderKeywords: ['attached', 'attachment', 'attaching', 'enclosed'],
  swipeLeftAction: 'archive',
  swipeRightAction: 'read',
+  archiveMode: 'single',
 };

 export interface SettingsState extends PersistedSettings {
@@ -73,6 +85,7 @@ export interface SettingsState extends PersistedSettings {
  setAttachmentReminderKeywords: (keywords: string[]) => void;
  setSwipeLeftAction: (action: SwipeAction) => void;
  setSwipeRightAction: (action: SwipeAction) => void;
+  setArchiveMode: (mode: ArchiveMode) => void;
  addTrustedSender: (email: string) => void;
  removeTrustedSender: (email: string) => void;
  isSenderTrusted: (email: string) => boolean;
@@ -96,6 +109,7 @@ function snapshot(state: SettingsState): PersistedSettings {
    attachmentReminderKeywords: state.attachmentReminderKeywords,
    swipeLeftAction: state.swipeLeftAction,
    swipeRightAction: state.swipeRightAction,
+    archiveMode: state.archiveMode,
  };
 }

@@ -144,6 +158,7 @@ export const useSettingsStore = create<SettingsState>((set, get) => ({
          attachmentReminderKeywords: Array.isArray(parsed.attachmentReminderKeywords) ? parsed.attachmentReminderKeywords : DEFAULT_PERSISTED.attachmentReminderKeywords,
          swipeLeftAction: parsed.swipeLeftAction ?? DEFAULT_PERSISTED.swipeLeftAction,
          swipeRightAction: parsed.swipeRightAction ?? DEFAULT_PERSISTED.swipeRightAction,
+          archiveMode: parsed.archiveMode ?? DEFAULT_PERSISTED.archiveMode,
          hydrated: true,
        });
        return;
@@ -168,6 +183,7 @@ export const useSettingsStore = create<SettingsState>((set, get) => ({
  setAttachmentReminderKeywords: (keywords) => { set({ attachmentReminderKeywords: keywords }); persist(snapshot(get())); },
  setSwipeLeftAction: (action) => { set({ swipeLeftAction: action }); persist(snapshot(get())); },
  setSwipeRightAction: (action) => { set({ swipeRightAction: action }); persist(snapshot(get())); },
+  setArchiveMode: (mode) => { set({ archiveMode: mode }); persist(snapshot(get())); },

  addTrustedSender: (email) => {
    const normalized = email.toLowerCase().trim();
Author	SHA1	Message	Date
Linus Rath	a8bb83ffe0	chore: update version number to 0.1.13	2026-05-02 14:44:00 +02:00
Linus Rath	c37256c54e	feat: enhance attachment handling in ComposeScreen with file picker and updated UI options	2026-05-02 14:43:45 +02:00
Linus Rath	e1d318ebc1	feat: add restoreEmailMailboxes mock to email store tests	2026-05-02 14:32:15 +02:00
Linus Rath	2090480bf4	feat: implement undo functionality for email actions with snackbar notification	2026-05-02 14:31:50 +02:00
Linus Rath	329c8a2f0b	feat: add swipe actions for pinning and moving emails; enhance archive functionality	2026-05-02 14:27:15 +02:00
@@ -1 +1 @@
 .1.12
 .1.13