@bobfrankston/mailx 1.0.378 → 1.0.382

package/client/lib/mailxapi.js

@@ -109,6 +109,19 @@
         getThreadMessages: function(accountId, threadId) {
             return callNode("getThreadMessages", { accountId: accountId, threadId: threadId });
         },
+        // Calendar / Tasks two-way cache. Reads return local DB immediately;
+        // writes commit locally and queue a push-to-Google action.
+        getCalendarEvents: function(fromMs, toMs) {
+            return callNode("getCalendarEvents", { fromMs: fromMs, toMs: toMs });
+        },
+        createCalendarEvent: function(ev) { return callNode("createCalendarEvent", ev); },
+        updateCalendarEvent: function(uuid, patch) { return callNode("updateCalendarEvent", { uuid: uuid, patch: patch }); },
+        deleteCalendarEvent: function(uuid) { return callNode("deleteCalendarEvent", { uuid: uuid }); },
+        getTasks: function(includeCompleted) { return callNode("getTasks", { includeCompleted: !!includeCompleted }); },
+        createTask: function(t) { return callNode("createTask", t); },
+        updateTask: function(uuid, patch) { return callNode("updateTask", { uuid: uuid, patch: patch }); },
+        deleteTask: function(uuid) { return callNode("deleteTask", { uuid: uuid }); },
+        drainStoreSync: function() { return callNode("drainStoreSync"); },
         readJsoncFile: function(name) {
             return callNode("readJsoncFile", { name: name });
         },

package/client/styles/components.css

@@ -205,6 +205,15 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
 
 .ft-folder-name { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
 
+/* Case-duplicate warning — another folder exists with the same name in a
+   different case on the server. Hover for the full explanation via title. */
+.ft-folder-duplicate .ft-folder-name::after {
+    content: " ⚠";
+    color: oklch(0.65 0.2 65);
+    font-weight: 600;
+    margin-left: 4px;
+}
+
 .ft-badge {
     font-size: 0.7rem;
     padding: 0.1rem 0.4rem;
@@ -332,6 +341,18 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     user-select: none;
 
     .ml-col { cursor: pointer; &:hover { color: var(--color-text); } }
+    .ml-col-sortable { position: relative; padding-right: 14px; }
+    .ml-col-sort-asc::after,
+    .ml-col-sort-desc::after {
+        position: absolute;
+        right: 2px;
+        top: 50%;
+        transform: translateY(-50%);
+        font-size: 10px;
+        color: var(--color-accent);
+    }
+    .ml-col-sort-asc::after  { content: "▲"; }
+    .ml-col-sort-desc::after { content: "▼"; }
 }
 
 /* Narrow-mode folder title above the list — hidden on wide where the window
@@ -603,6 +624,64 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     white-space: pre;
     tab-size: 2;
 }
+
+/* JSONC editor with line-number gutter. Gutter + textarea share the same
+   line-height so numbers stay aligned; textarea owns the scroll and the
+   gutter syncs via JS. Error line is highlighted red in the gutter so the
+   "Line N, col M" error points at a visible marker. */
+.jsonc-editor-wrap {
+    flex: 1;
+    display: flex;
+    min-height: 200px;
+    border: 1px solid var(--color-border);
+    border-radius: var(--radius-sm);
+    overflow: hidden;
+    background: var(--color-bg-surface);
+}
+.jsonc-gutter {
+    flex: 0 0 auto;
+    min-width: 3em;
+    padding: 6px 6px 6px 10px;
+    background: oklch(0.94 0.005 250);
+    border-right: 1px solid var(--color-border);
+    color: var(--color-text-muted);
+    font-family: var(--font-mono);
+    font-size: 13px;
+    line-height: 1.5;
+    text-align: right;
+    user-select: none;
+    overflow: hidden;
+    white-space: pre;
+    tab-size: 2;
+}
+.jsonc-gutter-line {
+    line-height: 1.5;
+    font-variant-numeric: tabular-nums;
+}
+.jsonc-gutter-error {
+    background: oklch(0.65 0.2 25);
+    color: #fff;
+    font-weight: 600;
+    border-radius: 2px;
+    padding: 0 4px;
+    margin: 0 -4px;
+}
+.jsonc-editor-wrap .jsonc-textarea {
+    flex: 1;
+    border: 0;
+    border-radius: 0;
+    line-height: 1.5;
+    resize: none;
+    /* The outer wrap draws the focus ring so gutter + area move together */
+}
+.jsonc-editor-wrap:focus-within {
+    outline: 2px solid var(--color-accent);
+    outline-offset: -1px;
+}
+.jsonc-editor-wrap:has(.mailx-modal-input-error) {
+    outline: 2px solid oklch(0.65 0.2 25);
+    outline-offset: -1px;
+}
 .mailx-modal-input:focus {
     outline: 2px solid var(--color-accent);
     outline-offset: -1px;
@@ -816,6 +895,21 @@ button.tb-menu-item { background: none; border: none; color: inherit; width: 100
     opacity: 0.9;
 }
 
+/* Filter: only this conversation — rows not in the current thread hide.
+   The selected row stays visible regardless so toggling doesn't leave the
+   list empty when the selection is a singleton thread. */
+.ml-row.thread-filter-hidden { display: none; }
+
+/* Offline indicator — sits in the status bar; amber tone so it's visible
+   but doesn't scream (being offline is normal local-first behavior, not
+   an error). */
+.status-offline {
+    color: oklch(0.65 0.18 65);
+    font-weight: 600;
+    font-size: var(--font-size-sm);
+    padding: 0 6px;
+}
+
 /* S51 — calendar sidebar (Thunderbird Lightning Events & Tasks pane).
    Right-docked, fixed width. Visible by default; user hides via View menu.
    Hides automatically on narrow screens (< 1100px) — Android uses the
@@ -926,11 +1020,41 @@ body.calendar-sidebar-on .calendar-sidebar { display: flex; }
     align-items: center;
     gap: 6px;
     padding: 2px 0;
+
+    .cal-side-task-delete {
+        margin-left: auto;
+        opacity: 0;
+        background: transparent;
+        border: 0;
+        cursor: pointer;
+        color: var(--color-text-muted);
+        padding: 0 4px;
+        font-size: 14px;
+        line-height: 1;
+        transition: opacity 0.15s, color 0.15s;
+    }
+    &:hover .cal-side-task-delete { opacity: 1; }
+    .cal-side-task-delete:hover { color: oklch(0.55 0.22 25); }
+}
+.cal-side-task-title {
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
 }
 .cal-side-task-title.done {
     text-decoration: line-through;
     color: var(--color-text-muted);
 }
+.cal-side-task-header-row {
+    display: flex;
+    align-items: center;
+    gap: var(--gap-xs);
+    padding: 2px 0;
+
+    label { flex: 1; }
+    .cal-side-new { width: auto; padding: 2px 8px; font-size: 0.85em; }
+}
 
 .ml-empty {
     grid-column: 1 / -1;

package/client/styles/layout.css

@@ -44,15 +44,17 @@ body.calendar-sidebar-on {
 .main-area { grid-area: main; }
 .status-bar { grid-area: status; }
 
-/* Vertical icon rail (Dovecot/Thunderbird-style). Always visible on
-   wide+medium tiers; collapses on narrow (icons move into the hamburger
-   menu — TBD; for now hidden on narrow). */
+/* Vertical icon rail — Thunderbird Supernova style: dark background with
+   light icons so the rail reads as "chrome" and contrasts visibly against
+   the content area (whether the app's in light or dark theme). Always
+   visible on wide+medium tiers; hidden on narrow (icons fold into
+   hamburger — TBD). */
 .icon-rail {
     display: flex;
     flex-direction: column;
     justify-content: space-between;
-    background: var(--color-bg-alt, #f4f4f5);
-    border-right: 1px solid var(--color-border);
+    background: oklch(0.25 0.01 250);
+    border-right: 1px solid oklch(0.18 0.01 250);
     padding: 6px 0;
     overflow: hidden;
 }
@@ -71,16 +73,38 @@ body.calendar-sidebar-on {
     background: transparent;
     cursor: pointer;
     font-size: 16px;
-    color: var(--color-text);
+    color: oklch(0.88 0.01 250);
     border-left: 3px solid transparent;
-    transition: background 0.12s, border-color 0.12s;
+    transition: background 0.12s, border-color 0.12s, color 0.12s;
 }
 .rail-btn:hover:not([disabled]) {
-    background: var(--color-hover, rgba(0,0,0,0.06));
+    background: oklch(0.32 0.02 250);
+    color: oklch(0.96 0.01 250);
 }
 .rail-btn[data-active="true"] {
-    background: var(--color-hover, rgba(0,0,0,0.06));
-    border-left-color: var(--color-accent, #1a6dd4);
+    background: oklch(0.35 0.03 250);
+    color: oklch(0.98 0.01 250);
+    border-left-color: var(--color-accent, #4a9cff);
+}
+.rail-btn[disabled] {
+    color: oklch(0.55 0.01 250);
+}
+.rail-btn { position: relative; }
+.rail-badge {
+    position: absolute;
+    top: 3px;
+    right: 6px;
+    min-width: 18px;
+    padding: 1px 4px;
+    border-radius: 9px;
+    background: oklch(0.65 0.22 25);
+    color: #fff;
+    font-size: 10px;
+    font-weight: 600;
+    line-height: 1.4;
+    text-align: center;
+    font-variant-numeric: tabular-nums;
+    pointer-events: none;
 }
 .rail-btn[disabled] {
     opacity: 0.35;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.378",
+  "version": "1.0.382",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -24,7 +24,7 @@
     "@bobfrankston/iflow-node": "^0.1.7",
     "@bobfrankston/miscinfo": "^1.0.9",
     "@bobfrankston/oauthsupport": "^1.0.24",
-    "@bobfrankston/msger": "^0.1.345",
+    "@bobfrankston/msger": "^0.1.347",
     "@bobfrankston/mailx-host": "^0.1.4",
     "@capacitor/android": "^8.3.0",
     "@capacitor/cli": "^8.3.0",
@@ -88,7 +88,7 @@
       "@bobfrankston/iflow-node": "^0.1.7",
       "@bobfrankston/miscinfo": "^1.0.9",
       "@bobfrankston/oauthsupport": "^1.0.24",
-      "@bobfrankston/msger": "^0.1.345",
+      "@bobfrankston/msger": "^0.1.347",
       "@bobfrankston/mailx-host": "^0.1.4",
       "@capacitor/android": "^8.3.0",
       "@capacitor/cli": "^8.3.0",

package/packages/mailx-imap/index.js

@@ -564,7 +564,11 @@ export class ImapManager extends EventEmitter {
                 const hasToken = fs.existsSync(path.join(tokenDir, "oauth-token.json"));
                 const TOKEN_FETCH_TIMEOUT_MS = hasToken ? 30_000 : 120_000;
                 const authPromise = authenticateOAuth(credPath, {
-                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts.readonly https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/drive",
+                    // Scope set covers two-way sync of all mailx-managed local
+                    // stores: mail (mail.google.com), contacts (full, not
+                    // readonly — we write edits back), calendar (full), tasks
+                    // (full), drive (for shared accounts.jsonc).
+                    scope: "https://mail.google.com/ https://www.googleapis.com/auth/contacts https://www.googleapis.com/auth/calendar https://www.googleapis.com/auth/tasks https://www.googleapis.com/auth/drive",
                     tokenDirectory: tokenDir,
                     credentialsKey: "installed",
                     loginHint: account.imap.user,
@@ -2295,8 +2299,33 @@ export class ImapManager extends EventEmitter {
                             await api.setFlags(folder.path, action.uid, action.flags || []);
                             console.log(`  [api] ${accountId}: flags synced UID ${action.uid}`);
                         }
+                        else if ((action.action === "delete" || action.action === "trash") && api.trashMessage) {
+                            await api.trashMessage(folder.path, action.uid);
+                            console.log(`  [api] ${accountId}: trashed UID ${action.uid} from ${folder.path}`);
+                        }
+                        else if (action.action === "move" && api.moveMessage) {
+                            const target = folders.find(f => f.id === action.targetFolderId);
+                            if (!target) {
+                                // Unreachable target — drop the action rather than loop.
+                                console.error(`  [api] ${accountId}: move target folder ${action.targetFolderId} missing — dropping UID ${action.uid}`);
+                                this.db.completeSyncAction(action.id);
+                                continue;
+                            }
+                            await api.moveMessage(folder.path, action.uid, target.path);
+                            console.log(`  [api] ${accountId}: moved UID ${action.uid} ${folder.path} → ${target.path}`);
+                        }
                         else {
-                            // move/delete/append via API not implemented yet — leave queued
+                            // Unsupported action on Gmail. After 5 retries, drop it
+                            // so stale rows don't mark messages pending-reconcile
+                            // forever. Previously "continue" here caused the pink
+                            // rows that shouldn't have been pink.
+                            if (action.attempts >= 5) {
+                                console.warn(`  [api] ${accountId}: dropping stale action "${action.action}" UID ${action.uid} after ${action.attempts} attempts (unsupported on Gmail API path)`);
+                                this.db.completeSyncAction(action.id);
+                            }
+                            else {
+                                this.db.failSyncAction(action.id, `unsupported Gmail action: ${action.action}`);
+                            }
                             continue;
                         }
                         this.db.completeSyncAction(action.id);

package/packages/mailx-service/google-sync.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Google Calendar / Tasks / People (Contacts) two-way sync helpers.
+ *
+ * Used by MailxService to push local edits to Google and pull server
+ * changes into the local cache. All functions take a `getToken` function
+ * and a fetch implementation so they stay platform-agnostic (Node uses
+ * global `fetch` on Node 18+; browsers use window.fetch).
+ *
+ * Error handling: throws on network / HTTP errors. Caller catches and
+ * either retries via the store_sync drainer or surfaces to the UI.
+ */
+type TokenProvider = () => Promise<string>;
+export interface GCalEvent {
+    id: string;
+    summary: string;
+    start: {
+        dateTime?: string;
+        date?: string;
+    };
+    end: {
+        dateTime?: string;
+        date?: string;
+    };
+    location?: string;
+    description?: string;
+    etag?: string;
+}
+export declare function listCalendarEvents(tokenProvider: TokenProvider, fromMs: number, toMs: number, calendarId?: string): Promise<GCalEvent[]>;
+export declare function createCalendarEvent(tokenProvider: TokenProvider, event: any, calendarId?: string): Promise<GCalEvent>;
+export declare function updateCalendarEvent(tokenProvider: TokenProvider, eventId: string, event: any, calendarId?: string): Promise<GCalEvent>;
+export declare function deleteCalendarEvent(tokenProvider: TokenProvider, eventId: string, calendarId?: string): Promise<void>;
+export interface GTask {
+    id: string;
+    title: string;
+    notes?: string;
+    due?: string;
+    completed?: string;
+    status?: "needsAction" | "completed";
+    etag?: string;
+}
+export declare function listTasks(tokenProvider: TokenProvider, listId?: string, showCompleted?: boolean): Promise<GTask[]>;
+export declare function createTask(tokenProvider: TokenProvider, task: any, listId?: string): Promise<GTask>;
+export declare function updateTask(tokenProvider: TokenProvider, taskId: string, task: any, listId?: string): Promise<GTask>;
+export declare function deleteTask(tokenProvider: TokenProvider, taskId: string, listId?: string): Promise<void>;
+export declare function createContact(tokenProvider: TokenProvider, person: any): Promise<any>;
+export declare function updateContact(tokenProvider: TokenProvider, resourceName: string, updatePersonFields: string, person: any): Promise<any>;
+export declare function deleteContact(tokenProvider: TokenProvider, resourceName: string): Promise<void>;
+export declare function calendarEventToLocal(ev: GCalEvent, accountId: string): {
+    providerId: string;
+    accountId: string;
+    title: string;
+    startMs: number;
+    endMs: number;
+    allDay: boolean;
+    location: string;
+    notes: string;
+    etag: string;
+};
+export declare function localToCalendarEvent(local: {
+    title: string;
+    startMs: number;
+    endMs: number;
+    allDay?: boolean;
+    location?: string;
+    notes?: string;
+}): any;
+export declare function taskToLocal(t: GTask, accountId: string): {
+    providerId: string;
+    accountId: string;
+    title: string;
+    notes: string;
+    dueMs: number | undefined;
+    completedMs: number | undefined;
+    etag: string;
+};
+export declare function localToTask(local: {
+    title: string;
+    notes?: string;
+    dueMs?: number;
+    completedMs?: number;
+}): any;
+export {};
+//# sourceMappingURL=google-sync.d.ts.map

package/packages/mailx-service/google-sync.js

@@ -0,0 +1,140 @@
+/**
+ * Google Calendar / Tasks / People (Contacts) two-way sync helpers.
+ *
+ * Used by MailxService to push local edits to Google and pull server
+ * changes into the local cache. All functions take a `getToken` function
+ * and a fetch implementation so they stay platform-agnostic (Node uses
+ * global `fetch` on Node 18+; browsers use window.fetch).
+ *
+ * Error handling: throws on network / HTTP errors. Caller catches and
+ * either retries via the store_sync drainer or surfaces to the UI.
+ */
+async function googleFetch(tokenProvider, url, init = {}) {
+    const token = await tokenProvider();
+    const headers = new Headers(init.headers || {});
+    headers.set("Authorization", `Bearer ${token}`);
+    if (init.body && !headers.has("Content-Type"))
+        headers.set("Content-Type", "application/json");
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) {
+        const body = await res.text().catch(() => "");
+        throw new Error(`Google API ${res.status} ${res.statusText}: ${body.slice(0, 300)}`);
+    }
+    return res;
+}
+export async function listCalendarEvents(tokenProvider, fromMs, toMs, calendarId = "primary") {
+    const from = new Date(fromMs).toISOString();
+    const to = new Date(toMs).toISOString();
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`
+        + `?timeMin=${encodeURIComponent(from)}&timeMax=${encodeURIComponent(to)}`
+        + `&singleEvents=true&orderBy=startTime&maxResults=250`;
+    const all = [];
+    let pageToken;
+    do {
+        const pagedUrl = pageToken ? `${url}&pageToken=${encodeURIComponent(pageToken)}` : url;
+        const res = await googleFetch(tokenProvider, pagedUrl);
+        const data = await res.json();
+        for (const ev of (data.items || []))
+            all.push(ev);
+        pageToken = data.nextPageToken;
+    } while (pageToken);
+    return all;
+}
+export async function createCalendarEvent(tokenProvider, event, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(event) });
+    return res.json();
+}
+export async function updateCalendarEvent(tokenProvider, eventId, event, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(event) });
+    return res.json();
+}
+export async function deleteCalendarEvent(tokenProvider, eventId, calendarId = "primary") {
+    const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+export async function listTasks(tokenProvider, listId = "@default", showCompleted = false) {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks`
+        + `?showCompleted=${showCompleted}&maxResults=100`;
+    const res = await googleFetch(tokenProvider, url);
+    const data = await res.json();
+    return data.items || [];
+}
+export async function createTask(tokenProvider, task, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(task) });
+    return res.json();
+}
+export async function updateTask(tokenProvider, taskId, task, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks/${encodeURIComponent(taskId)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(task) });
+    return res.json();
+}
+export async function deleteTask(tokenProvider, taskId, listId = "@default") {
+    const url = `https://tasks.googleapis.com/tasks/v1/lists/${encodeURIComponent(listId)}/tasks/${encodeURIComponent(taskId)}`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+// ── Contacts (People API) ──
+export async function createContact(tokenProvider, person) {
+    const url = `https://people.googleapis.com/v1/people:createContact`;
+    const res = await googleFetch(tokenProvider, url, { method: "POST", body: JSON.stringify(person) });
+    return res.json();
+}
+export async function updateContact(tokenProvider, resourceName, updatePersonFields, person) {
+    const url = `https://people.googleapis.com/v1/${resourceName}:updateContact`
+        + `?updatePersonFields=${encodeURIComponent(updatePersonFields)}`;
+    const res = await googleFetch(tokenProvider, url, { method: "PATCH", body: JSON.stringify(person) });
+    return res.json();
+}
+export async function deleteContact(tokenProvider, resourceName) {
+    const url = `https://people.googleapis.com/v1/${resourceName}:deleteContact`;
+    await googleFetch(tokenProvider, url, { method: "DELETE" });
+}
+// ── Conversion helpers ──
+export function calendarEventToLocal(ev, accountId) {
+    const allDay = !!ev.start.date && !ev.start.dateTime;
+    const startMs = allDay
+        ? Date.parse(ev.start.date)
+        : Date.parse(ev.start.dateTime);
+    const endMs = allDay
+        ? Date.parse(ev.end.date)
+        : Date.parse(ev.end.dateTime);
+    return {
+        providerId: ev.id, accountId,
+        title: ev.summary || "(no title)",
+        startMs, endMs, allDay,
+        location: ev.location || "", notes: ev.description || "",
+        etag: ev.etag || "",
+    };
+}
+export function localToCalendarEvent(local) {
+    const toIso = (ms) => new Date(ms).toISOString();
+    const toDate = (ms) => new Date(ms).toISOString().slice(0, 10);
+    return {
+        summary: local.title,
+        start: local.allDay ? { date: toDate(local.startMs) } : { dateTime: toIso(local.startMs) },
+        end: local.allDay ? { date: toDate(local.endMs) } : { dateTime: toIso(local.endMs) },
+        location: local.location || undefined,
+        description: local.notes || undefined,
+    };
+}
+export function taskToLocal(t, accountId) {
+    return {
+        providerId: t.id, accountId, title: t.title || "",
+        notes: t.notes || "",
+        dueMs: t.due ? Date.parse(t.due) : undefined,
+        completedMs: t.completed ? Date.parse(t.completed) : undefined,
+        etag: t.etag || "",
+    };
+}
+export function localToTask(local) {
+    return {
+        title: local.title,
+        notes: local.notes || undefined,
+        due: local.dueMs ? new Date(local.dueMs).toISOString() : undefined,
+        completed: local.completedMs ? new Date(local.completedMs).toISOString() : undefined,
+        status: local.completedMs ? "completed" : "needsAction",
+    };
+}
+//# sourceMappingURL=google-sync.js.map

package/packages/mailx-service/index.d.ts

@@ -47,6 +47,46 @@ export declare class MailxService {
      *  Called without `feature` it returns the catch-all primary — same
      *  semantics as the original single-flag version for back-compat. */
     getPrimaryAccount(feature?: string): any;
+    private primaryTokenProvider;
+    /** Return cal events visible in [fromMs..toMs), refreshing from Google
+     *  in the background if enough time has passed. Caller displays local
+     *  results immediately; events updated from Google emit an event. */
+    getCalendarEvents(fromMs: number, toMs: number): Promise<any[]>;
+    private refreshCalendarEvents;
+    createCalendarEventLocal(ev: {
+        title: string;
+        startMs: number;
+        endMs: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+    }): Promise<string>;
+    updateCalendarEventLocal(uuid: string, patch: {
+        title?: string;
+        startMs?: number;
+        endMs?: number;
+        allDay?: boolean;
+        location?: string;
+        notes?: string;
+    }): Promise<void>;
+    deleteCalendarEventLocal(uuid: string): Promise<void>;
+    getTasks(includeCompleted?: boolean): Promise<any[]>;
+    private refreshTasks;
+    createTaskLocal(t: {
+        title: string;
+        notes?: string;
+        dueMs?: number;
+    }): Promise<string>;
+    updateTaskLocal(uuid: string, patch: {
+        title?: string;
+        notes?: string;
+        dueMs?: number;
+        completedMs?: number;
+    }): Promise<void>;
+    deleteTaskLocal(uuid: string): Promise<void>;
+    /** Drain the store_sync queue — calendar / tasks / contacts push-to-server.
+     *  Called on every local edit, and on a periodic tick from the outbox worker. */
+    drainStoreSync(): Promise<void>;
     /** List queued outgoing messages with parsed envelope headers so the UI
      *  can render a pink-row "pending" view before IMAP APPEND succeeds. */
     listQueuedOutgoing(): any[];
@@ -95,11 +135,13 @@ export declare class MailxService {
     addContact(name: string, email: string): boolean;
     /** Address-book listing — paginated, filterable. */
     listContacts(query: string, page?: number, pageSize?: number): any;
-    /** Upsert a contact from the address book UI (edit name). */
+    /** Upsert a contact from the address book UI (edit name). Two-way cache:
+     *  commits locally, queues a Google People push. */
     upsertContact(name: string, email: string): {
         ok: true;
     };
-    /** Delete a contact from the address book. */
+    /** Delete a contact from the address book. Also pushes the deletion to
+     *  Google People if the contact had a resourceName (i.e. was synced). */
     deleteContact(email: string): {
         ok: true;
     };