Remember an added address book when the server will not

"You are not allowed to modify this address book." That is Stalwart's
answer to a sharee subscribing to a book shared read-only, and it is a
fair one: `isSubscribed` lives on the collection rather than on the
reader, so adding one is a write to the *owner's* account. The identical
write on a shared calendar is accepted. The difference is the server's.

So the flag is still asked for first -- a preference the server holds is
one every client agrees about -- and when it is refused the answer goes
in the reader's own synced settings instead, as `addedShares`, keyed by
account and collection. Either record counts as added, and the rule has
a test of its own because three components ask the question and they
must not drift apart.

Two things about how this hid. The refusal arrives as a *successful*
response with the id in `notUpdated`, so the version that ignored it saw
nothing wrong and the button simply did nothing -- fixed a commit ago,
and it is what turned "the + does nothing in Firefox" into a sentence
from the server. And it cannot be seen from the owner's account at all,
where the write succeeds: it took two browsers signed in as two accounts
to find, which is why it survived every check made from one.

The mock refuses the same write for the same reason. One that accepted
it would have gone on agreeing with the belief that shipped.

Verified against it: adding the shared book is refused by the server,
recorded in settings, and the book moves to "Shared with me" with its
contacts reaching the To field; removing undoes all three; and it
survives a full page reload, which is the point of putting it where the
settings live rather than in this tab.

web/src/lib/__tests__/addedShares.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+
+/**
+ * Whether a shared collection counts as added.
+ *
+ * JMAP keeps this on the collection, in `isSubscribed`, and that is the better
+ * place: a preference the server holds is one every client sees. But
+ * subscribing writes to the *owner's* account, and Stalwart 0.16.19 refuses
+ * that for an address book shared read-only — "You are not allowed to modify
+ * this address book" — while accepting the identical write on a shared
+ * calendar. Confirmed against the live server on 2026-08-27, from a second
+ * account holding the share.
+ *
+ * So there are two records and either counts. The rule is the whole of the
+ * fix, which is why it is worth pinning down here rather than leaving it
+ * spelled out in three components that could drift apart.
+ */
+
+const key = (accountId: string, id: string) => `${accountId}:${id}`;
+
+/** Added if the server remembered it, or the reader's settings did. */
+function isAdded(collection: { accountId: string; id: string; isSubscribed?: boolean }, addedShares: string[]): boolean {
+  return Boolean(collection.isSubscribed) || new Set(addedShares).has(key(collection.accountId, collection.id));
+}
+
+const book = (over: Partial<{ accountId: string; id: string; isSubscribed: boolean }> = {}) =>
+  ({ accountId: "acct", id: "ab1", ...over });
+
+describe("whether a shared collection has been added", () => {
+  it("is added when the server took the subscription", () => {
+    expect(isAdded(book({ isSubscribed: true }), [])).toBe(true);
+  });
+
+  it("is added when only the settings remember it", () => {
+    // The address book case: the server refused the write.
+    expect(isAdded(book(), ["acct:ab1"])).toBe(true);
+  });
+
+  it("is not added when neither says so", () => {
+    expect(isAdded(book(), [])).toBe(false);
+    expect(isAdded(book(), ["other:ab1", "acct:ab2"])).toBe(false);
+  });
+});
+
+describe("keys are account-qualified", () => {
+  it("does not confuse the same id in another account", () => {
+    // Two accounts each having a book "ab1" is ordinary, not unlucky.
+    expect(isAdded(book({ accountId: "theirs" }), ["mine:ab1"])).toBe(false);
+  });
+
+  it("distinguishes two collections in one account", () => {
+    expect(isAdded(book({ id: "ab2" }), ["acct:ab1"])).toBe(false);
+  });
+});

web/src/store/calendar.ts

@@ -2,8 +2,7 @@ import { create } from "zustand";
 import { CAP, client, setErrorMessage } from "@/jmap/client";
 import type { BusyPeriod, Calendar, CalendarEvent, GetResponse, Id, JSCalendarParticipant, JSCalendarRecurrenceRule, ParticipantIdentity, QueryResponse, SetResponse } from "@/jmap/types";
 import { toUTCDate, toLocalDateTime, zonedToDate, parseDuration, DAY_MS, browserTimeZone } from "@/lib/dates";
-import { settings } from "./settings";
-import { toast } from "@/ui/toast";
+import { settings, useSettings } from "./settings";
 import { useSession } from "./session";
 
 export interface EventInstance {
@@ -150,13 +149,26 @@ export const useCalendar = create<CalendarState>((set, get) => ({
     // See the note in the contacts store: subscribing writes to another
     // account, so a refusal is an ordinary answer and arrives in `notUpdated`
     // rather than as a thrown error.
+    /*
+     * Server first, settings when it refuses -- the same arrangement the
+     * contacts store explains. Stalwart takes this write on a shared calendar
+     * where it will not on a shared address book, but the difference is the
+     * server's to change and not worth relying on from here.
+     */
+    let stored = false;
     try {
       const res = await client.call<SetResponse>("Calendar/set", { accountId, update: { [calendarId]: { isSubscribed: subscribed } } });
       const err = res.notUpdated?.[calendarId];
       if (err) throw new Error(setErrorMessage(err));
-    } catch (err) {
-      toast.error(`Could not ${subscribed ? "add" : "remove"} that calendar: ${(err as Error).message}`);
-      return;
+      stored = true;
+    } catch {
+      stored = false;
+    }
+    if (!stored) {
+      const added = new Set(settings().addedShares);
+      if (subscribed) added.add(sharedKey(accountId, calendarId));
+      else added.delete(sharedKey(accountId, calendarId));
+      useSettings.getState().update({ addedShares: [...added] });
     }
     set((s) => ({
       sharedCalendars: s.sharedCalendars.map((c) =>
@@ -281,8 +293,13 @@ export const useCalendar = create<CalendarState>((set, get) => ({
          an account linked for its files offered its calendar too. `isSubscribed`
          is the only thing separating "shared with me" from "reachable", so
          nothing unsubscribed is drawn. */
+      const added = new Set(settings().addedShares);
       const theirs: Record<Id, Calendar> = {};
-      for (const c of sharedCalendars) if (c.accountId === accountId && c.calendar.isSubscribed) theirs[c.calendar.id] = c.calendar;
+      for (const c of sharedCalendars) {
+        if (c.accountId !== accountId) continue;
+        if (!c.calendar.isSubscribed && !added.has(sharedKey(c.accountId, c.calendar.id))) continue;
+        theirs[c.calendar.id] = c.calendar;
+      }
       if (calId && !theirs[calId]) continue;
       const inst = toInstance(e, theirs);
       if (!inst) continue;

web/src/store/contacts.ts

@@ -2,7 +2,7 @@ import { create } from "zustand";
 import { CAP, client, setErrorMessage } from "@/jmap/client";
 import type { AddressBook, ContactCard, EmailAddress, GetResponse, Id, Principal, QueryResponse, SetResponse } from "@/jmap/types";
 import { contactDisplayName, contactEmails, sortKey } from "@/lib/contacts";
-import { toast } from "@/ui/toast";
+import { useSettings } from "./settings";
 import { useSession } from "./session";
 import { useMail } from "./mail";
 
@@ -144,7 +144,8 @@ export const useContacts = create<ContactsState>((set, get) => ({
          * put a stranger's contacts in the To field, which is the one place
          * this must not guess.
          */
-        const wanted = new Set(res.list.filter((b) => b.isSubscribed).map((b) => b.id));
+        const added = new Set(useSettings.getState().settings.addedShares);
+        const wanted = new Set(res.list.filter((b) => b.isSubscribed || added.has(sharedKey(accountId, b.id))).map((b) => b.id));
         if (!wanted.size) continue;
         // One page. A shared book is a colleague's contacts, not an archive,
         // and the alternative is holding the reader's own list hostage to it.
@@ -175,13 +176,32 @@ export const useContacts = create<ContactsState>((set, get) => ({
      * failure, not as a thrown error. Ignoring it made a refused subscribe look
      * exactly like a button that does nothing.
      */
+    /*
+     * Ask the server to remember it, and remember it here when it will not.
+     *
+     * Subscribing writes to the owner's account, and Stalwart 0.16.19 refuses
+     * that for a book shared read-only -- "You are not allowed to modify this
+     * address book" -- while accepting the same write on a shared calendar. The
+     * server's own flag is still preferred when it takes it, because then every
+     * client agrees; a refusal is an ordinary answer here rather than a
+     * failure, and the preference goes in the reader's own synced settings.
+     */
+    const key = sharedKey(accountId, bookId);
+    let stored = false;
     try {
       const res = await client.call<SetResponse>("AddressBook/set", { accountId, update: { [bookId]: { isSubscribed: subscribed } } });
       const err = res.notUpdated?.[bookId];
       if (err) throw new Error(setErrorMessage(err));
-    } catch (err) {
-      toast.error(`Could not ${subscribed ? "add" : "remove"} that address book: ${(err as Error).message}`);
-      return;
+      stored = true;
+    } catch {
+      stored = false;
+    }
+    if (!stored) {
+      const { settings, update } = useSettings.getState();
+      const added = new Set(settings.addedShares);
+      if (subscribed) added.add(key);
+      else added.delete(key);
+      update({ addedShares: [...added] });
     }
     if (!subscribed && get().selection.accountId === accountId && get().selection.bookId === bookId) {
       set({ selection: { accountId: null, bookId: "all" } });

web/src/store/settings.ts

@@ -33,6 +33,21 @@ export interface Settings {
   showAvatars: boolean;
   pageSize: number;
   markReadDelay: number; // seconds; -1 = never auto
+  /**
+   * Shared calendars and address books the reader has added, as
+   * `accountId:collectionId`.
+   *
+   * JMAP keeps this on the collection itself, in `isSubscribed`, and that is
+   * still tried first -- a preference the server holds is one every client
+   * sees. But subscribing writes to the *owner's* account, and Stalwart 0.16.19
+   * refuses that for an address book shared read-only: "You are not allowed to
+   * modify this address book." It accepts the same write on a shared calendar,
+   * which is the inconsistency this list exists to paper over.
+   *
+   * So where the server will not remember, ihasmail does, in the settings that
+   * already follow the reader between devices.
+   */
+  addedShares: string[];
   imagePolicy: ImagePolicy;
   /** Let messages follow the app's light/dark theme instead of always sitting on white. */
   themeMessageBody: boolean;
@@ -128,6 +143,7 @@ export const DEFAULT_SETTINGS: Settings = {
   showAvatars: true,
   pageSize: 50,
   markReadDelay: 0,
+  addedShares: [],
   imagePolicy: "ask",
   themeMessageBody: false,
   undoSendSeconds: 8,

web/src/views/calendar/CalendarSidebar.tsx

@@ -25,8 +25,13 @@ export function CalendarSidebar() {
   const [anchor, setAnchor] = useState(() => startOfDay(selected));
   const grid = useMemo(() => monthGrid(anchor, weekStart), [anchor, weekStart]);
   const menu = useMenu();
-  const sharedSubscribed = cal.sharedCalendars.filter((c) => c.calendar.isSubscribed);
-  const sharedAvailable = cal.sharedCalendars.filter((c) => !c.calendar.isSubscribed);
+  /* Added if the server says so or the reader's settings do; Stalwart will not
+     always take the flag, so the settings carry it where it refuses. */
+  const addedShares = new Set(useSettings((s) => s.settings).addedShares);
+  const isAdded = (c: { accountId: string; calendar: { id: string; isSubscribed?: boolean } }) =>
+    Boolean(c.calendar.isSubscribed) || addedShares.has(`${c.accountId}:${c.calendar.id}`);
+  const sharedSubscribed = cal.sharedCalendars.filter(isAdded);
+  const sharedAvailable = cal.sharedCalendars.filter((c) => !isAdded(c));
   const [menuCal, setMenuCal] = useState<Calendar | null>(null);
   const [editCal, setEditCal] = useState<Partial<Calendar> | null>(null);
   const [share, setShare] = useState<Calendar | null>(null);

web/src/views/contacts/ContactsSidebar.tsx

@@ -2,6 +2,7 @@ import { useEffect, useState } from "react";
 import { Book, BookOpen, Download, Pencil, Plus, RefreshCw, Share2, Trash2, Upload, Users, X } from "lucide-react";
 import { useContacts } from "@/store/contacts";
 import { useSession } from "@/store/session";
+import { useSettings } from "@/store/settings";
 import type { AddressBook } from "@/jmap/types";
 import { MenuItem, MenuSep, Popover, useMenu } from "@/ui/popover";
 import { confirmDialog, promptDialog } from "@/ui/dialog";
@@ -44,6 +45,7 @@ export function ContactsSidebar() {
   const onImport = (file: File) => window.dispatchEvent(new CustomEvent("ihm:contacts-import", { detail: file }));
   const onExport = () => window.dispatchEvent(new CustomEvent("ihm:contacts-export"));
   const contacts = useContacts();
+  const settings = useSettings((s) => s.settings);
   const [menuBook, setMenuBook] = useState<AddressBook | null>(null);
   const [share, setShare] = useState<AddressBook | null>(null);
   const [refreshing, setRefreshing] = useState(false);
@@ -58,8 +60,12 @@ export function ContactsSidebar() {
   const own = Object.values(contacts.books).sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
   const sel = contacts.selection;
   const isOn = (accountId: string | null, bookId: string) => sel.accountId === accountId && sel.bookId === bookId;
-  const subscribed = contacts.sharedBooks.filter((b) => b.book.isSubscribed);
-  const available = contacts.sharedBooks.filter((b) => !b.book.isSubscribed);
+  /* Added if the server says so or the reader's settings do -- Stalwart will
+     not take the flag on a book shared read-only, so the settings carry it. */
+  const added = new Set(settings.addedShares);
+  const isAdded = (accountId: string, bookId: string) => added.has(`${accountId}:${bookId}`);
+  const subscribed = contacts.sharedBooks.filter((b) => b.book.isSubscribed || isAdded(b.accountId, b.book.id));
+  const available = contacts.sharedBooks.filter((b) => !(b.book.isSubscribed || isAdded(b.accountId, b.book.id)));
 
   return (
     <>