@rapidmx/web-client 0.4.0 → 0.6.0

package/dist/apps/shared/components/mail/writableMailboxes.js

@@ -0,0 +1,87 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/**
+ * Which of the caller's accessible mailboxes they can actually create things in (send from, create
+ * events/contacts/to-dos in). `listMailboxes()` returns view-only shares too, and `Mailbox` itself carries
+ * no per-caller access role, so a "viewer" delegate used to be offered mailboxes every create would 403 in.
+ *
+ * The signal: an owned mailbox (or any mailbox, for a trusted caller) is always writable; for any other,
+ * `getMyMailboxAccess()`'s `canCreate` - the server's own ACL evaluation of the exact action a create needs.
+ * One request per mailbox per page load: results are cached in a module-level map, with concurrent callers
+ * sharing one in-flight request. A failure (network, an older server without that route) is "unknown" and
+ * isn't cached: the server still enforces access on the create itself, and hiding a usable mailbox over a
+ * transient error would be worse than offering one that later errors.
+ *
+ * Nothing waits on these checks: pickers list every mailbox straight away and drop view-only ones as each
+ * answer arrives.
+ */
+import { useEffect, useMemo, useState } from "react";
+import { getMyMailboxAccess } from "@rapidmx/react-shared/mail/mailboxAccessApi.js";
+const inFlight = new Map();
+const settled = new Map();
+/** Forgets every cached answer - for tests, and anything that changes the caller's access mid-session. */
+export function clearMailboxWritabilityCache() {
+    inFlight.clear();
+    settled.clear();
+}
+function isImplicitlyWritable(mailbox, userUid, trusted) {
+    return !!trusted || (!!userUid && mailbox.ownerUserUid === userUid);
+}
+/** The already-known answer for `mailbox`, without making a request. */
+export function peekMailboxWritability(mailbox, userUid, trusted) {
+    return isImplicitlyWritable(mailbox, userUid, trusted) ? true : settled.get(mailbox.uid);
+}
+/** Whether the caller can create items in `mailbox`. Never rejects. */
+export function getMailboxWritability(mailbox, userUid, trusted) {
+    const known = peekMailboxWritability(mailbox, userUid, trusted);
+    if (known !== undefined) {
+        return Promise.resolve(known);
+    }
+    let request = inFlight.get(mailbox.uid);
+    if (!request) {
+        request = getMyMailboxAccess(mailbox.uid).then((access) => {
+            settled.set(mailbox.uid, access.canCreate);
+            inFlight.delete(mailbox.uid);
+            return access.canCreate;
+        }, () => {
+            // Not cached - a later check may succeed.
+            inFlight.delete(mailbox.uid);
+            return undefined;
+        });
+        inFlight.set(mailbox.uid, request);
+    }
+    return request;
+}
+/** Per-mailbox writability answers for `mailboxes`, filled in as each one arrives (already-known answers are
+ * present from the first render). */
+export function useMailboxWritability(mailboxes, userUid, trusted) {
+    const [answers, setAnswers] = useState({});
+    useEffect(() => {
+        let cancelled = false;
+        for (const mailbox of mailboxes) {
+            void getMailboxWritability(mailbox, userUid, trusted).then((writable) => {
+                if (!cancelled) {
+                    setAnswers((prev) => ({ ...prev, [mailbox.uid]: writable }));
+                }
+            });
+        }
+        return () => {
+            cancelled = true;
+        };
+    }, [mailboxes, userUid, trusted]);
+    return useMemo(() => {
+        const merged = {};
+        for (const mailbox of mailboxes) {
+            merged[mailbox.uid] = answers[mailbox.uid] ?? peekMailboxWritability(mailbox, userUid, trusted);
+        }
+        return merged;
+    }, [answers, mailboxes, userUid, trusted]);
+}
+/** `mailboxes` minus any known to be view-only, always keeping `keepUid` (the picker's current/default value,
+ * so the control never shows a value missing from its own options). Lists everything until told otherwise. */
+export function useWritableMailboxes(mailboxes, userUid, keepUid, trusted) {
+    const writability = useMailboxWritability(mailboxes, userUid, trusted);
+    return useMemo(() => mailboxes.filter((mb) => mb.uid === keepUid || writability[mb.uid] !== false), [mailboxes, writability, keepUid]);
+}

package/dist/apps/shared/components/rules/RuleBuilder.d.ts

@@ -0,0 +1,70 @@
+import React, { ReactNode } from "react";
+/** One condition field this scope's `Conditions` shape supports — `"list"` renders an add/remove chip
+ * editor for a `string[]` field, `"boolean"` a plain checkbox, `"select"` a fixed-choice dropdown for a
+ * field with a small closed set of string values (e.g. `MailFilterConditions.importance`). */
+export interface ConditionFieldDef {
+    key: string;
+    label: string;
+    kind: "list" | "boolean" | "select";
+    placeholder?: string;
+    /** Required when `kind` is `"select"` — the fixed set of values this field may hold, plus an
+     * implicit "Any" option that clears the field entirely. */
+    options?: {
+        value: string;
+        label: string;
+    }[];
+}
+/** One action type this scope's `Action` union supports — the per-scope registry the shared condition
+ * editor/chrome below is deliberately kept out of (transport-rule and mail-filter actions are
+ * different enough vocabularies that one component special-casing both would be worse than this). */
+export interface ActionTypeDef<A> {
+    value: string;
+    label: string;
+    /** Builds a fresh default action of this type when picked from "Add action". */
+    createDefault: () => A;
+    /** Renders this action's own type-specific fields (e.g. header name/value). `null` for an action
+     * type with nothing further to configure. */
+    render: (action: A, onChange: (next: A) => void) => ReactNode;
+}
+export interface RuleBuilderValue<C extends object, A extends {
+    type: string;
+}> {
+    enabled: boolean;
+    sequence: number;
+    stopProcessingRules: boolean;
+    conditions: C;
+    actions: A[];
+}
+export interface RuleBuilderProps<C extends object, A extends {
+    type: string;
+}> {
+    value: RuleBuilderValue<C, A>;
+    onChange: (next: RuleBuilderValue<C, A>) => void;
+    conditionFields: ConditionFieldDef[];
+    actionTypes: ActionTypeDef<A>[];
+    /** Set by the page once the user has tried to save a rule `hasConditions()` rejects - turns the
+     * "add at least one condition" hint into an error. */
+    showValidation?: boolean;
+}
+/**
+ * Whether `conditions` holds at least one real condition: a list with a non-blank entry, a ticked
+ * boolean, or a chosen select value. A rule with none would match *every* message, so the pages that save
+ * a `RuleBuilder` value (mail filters, transport rules) must refuse to save unless this returns `true`.
+ */
+export declare function hasConditions(conditions: object): boolean;
+/**
+ * Shared condition-row editor and enabled/sequence/stop-processing chrome for a rule that matches
+ * conditions and runs actions in order — `TransportRule` (admin, org-wide) and `MailFilterRule`
+ * (mailbox-scoped) both have this same `{enabled, sequence, stopProcessingRules, conditions, actions}`
+ * shape. Conditions are driven by a declarative `conditionFields` list so both scopes share this one
+ * editor despite their `Conditions` types not being identical — `MailFilterConditions.importance`
+ * (`MailFilterRule`'s one condition field `TransportRuleConditions` has no equivalent of) is what forced
+ * this list beyond `"list"`/`"boolean"` to add a third `"select"` kind for a small fixed-choice field,
+ * confirming the shared editor still generalizes rather than needing a fork; actions are driven by a
+ * small per-scope `actionTypes` registry instead, since the two action vocabularies (reject/quarantine/
+ * add-header/add-recipient vs. move/copy/delete/mark-read/forward) are different enough that one
+ * component special-casing both would be worse than this split.
+ */
+export default function RuleBuilder<C extends object, A extends {
+    type: string;
+}>({ value, onChange, conditionFields, actionTypes, showValidation, }: RuleBuilderProps<C, A>): React.JSX.Element;

package/dist/apps/shared/components/rules/RuleBuilder.js

@@ -6,6 +6,20 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState } from "react";
 import Button from "@rapidmx/react-shared/components/buttons/Button.js";
 const INPUT_CLASS = "flex-1 text-sm py-2 px-3 border border-border rounded-sm bg-surface text-text focus:outline-none focus:border-primary";
+/**
+ * Whether `conditions` holds at least one real condition: a list with a non-blank entry, a ticked
+ * boolean, or a chosen select value. A rule with none would match *every* message, so the pages that save
+ * a `RuleBuilder` value (mail filters, transport rules) must refuse to save unless this returns `true`.
+ */
+export function hasConditions(conditions) {
+    return Object.values(conditions).some((v) => {
+        if (Array.isArray(v))
+            return v.some((entry) => typeof entry !== "string" || entry.trim() !== "");
+        if (typeof v === "string")
+            return v.trim() !== "";
+        return v !== undefined && v !== null && v !== false;
+    });
+}
 /**
  * Shared condition-row editor and enabled/sequence/stop-processing chrome for a rule that matches
  * conditions and runs actions in order — `TransportRule` (admin, org-wide) and `MailFilterRule`
@@ -19,7 +33,7 @@ const INPUT_CLASS = "flex-1 text-sm py-2 px-3 border border-border rounded-sm bg
  * add-header/add-recipient vs. move/copy/delete/mark-read/forward) are different enough that one
  * component special-casing both would be worse than this split.
  */
-export default function RuleBuilder({ value, onChange, conditionFields, actionTypes, }) {
+export default function RuleBuilder({ value, onChange, conditionFields, actionTypes, showValidation = false, }) {
     const [draftText, setDraftText] = useState({});
     const [newActionType, setNewActionType] = useState(actionTypes[0]?.value ?? "");
     const conditions = value.conditions;
@@ -36,12 +50,22 @@ export default function RuleBuilder({ value, onChange, conditionFields, actionTy
         patch({ conditions: { ...conditions, [key]: [...existing, text] } });
         setDraftText({ ...draftText, [key]: "" });
     }
+    // Only invoked from a chip's own "Remove" button, which only renders while `conditions[key]` holds
+    // that entry. Removing the last entry deletes the key rather than leaving an empty list behind.
     function removeListEntry(key, entry) {
-        const existing = conditions[key] ?? [];
-        patch({ conditions: { ...conditions, [key]: existing.filter((e) => e !== entry) } });
+        const remaining = conditions[key].filter((e) => e !== entry);
+        const next = { ...conditions };
+        if (remaining.length > 0) {
+            next[key] = remaining;
+        }
+        else {
+            delete next[key];
+        }
+        patch({ conditions: next });
     }
     function toggleBoolean(key) {
-        patch({ conditions: { ...conditions, [key]: !conditions[key] } });
+        // Unticking stores `undefined` (no condition), not `false`.
+        patch({ conditions: { ...conditions, [key]: conditions[key] ? undefined : true } });
     }
     function setSelect(key, value) {
         patch({ conditions: { ...conditions, [key]: value || undefined } });
@@ -58,14 +82,18 @@ export default function RuleBuilder({ value, onChange, conditionFields, actionTy
     function removeAction(index) {
         patch({ actions: value.actions.filter((_, i) => i !== index) });
     }
-    return (_jsxs("div", { className: "flex flex-col gap-5", children: [_jsxs("div", { className: "bg-surface border border-border rounded-md p-6", children: [_jsx("h2", { className: "text-base font-bold uppercase tracking-wide mb-4", children: "Conditions" }), _jsx("div", { className: "flex flex-col gap-4", children: conditionFields.map((field) => {
+    return (_jsxs("div", { className: "flex flex-col gap-5", children: [_jsxs("div", { className: "bg-surface border border-border rounded-md p-6", children: [_jsx("h2", { className: "text-base font-bold uppercase tracking-wide mb-4", children: "Conditions" }), !hasConditions(value.conditions) && (_jsx("p", { role: showValidation ? "alert" : undefined, className: `text-sm mb-4 ${showValidation ? "text-danger" : "text-text-muted"}`, children: "Add at least one condition. A rule without conditions would apply to every message." })), _jsx("div", { className: "flex flex-col gap-4", children: conditionFields.map((field) => {
                             if (field.kind === "boolean") {
                                 return (_jsxs("label", { className: "flex items-center gap-2 text-sm", children: [_jsx("input", { type: "checkbox", checked: !!conditions[field.key], onChange: () => toggleBoolean(field.key) }), field.label] }, field.key));
                             }
                             if (field.kind === "select") {
                                 return (_jsxs("div", { children: [_jsx("label", { className: "text-sm font-semibold mb-1.5 block", htmlFor: `condition-${field.key}`, children: field.label }), _jsxs("select", { id: `condition-${field.key}`, className: INPUT_CLASS, value: conditions[field.key] ?? "", onChange: (e) => setSelect(field.key, e.target.value), children: [_jsx("option", { value: "", children: "Any" }), (field.options ?? []).map((opt) => (_jsx("option", { value: opt.value, children: opt.label }, opt.value)))] })] }, field.key));
                             }
-                            return (_jsxs("div", { children: [_jsx("div", { className: "text-sm font-semibold mb-1.5", children: field.label }), _jsx("div", { className: "flex flex-wrap gap-2 mb-2", children: (conditions[field.key] ?? []).map((entry) => (_jsxs("span", { className: "inline-flex items-center gap-1.5 text-xs py-1 px-2.5 rounded-pill bg-surface-alt", children: [entry, _jsx("button", { type: "button", "aria-label": `Remove ${entry}`, onClick: () => removeListEntry(field.key, entry), className: "text-text-muted hover:text-danger", children: "\u00D7" })] }, entry))) }), _jsxs("div", { className: "flex gap-2", children: [_jsx("input", { type: "text", "aria-label": field.label, className: INPUT_CLASS, placeholder: field.placeholder ?? "Add a value", value: draftText[field.key] ?? "", onChange: (e) => setDraftText({ ...draftText, [field.key]: e.target.value }), onKeyDown: (e) => {
+                            return (_jsxs("div", { children: [_jsx("div", { className: "text-sm font-semibold mb-1.5", children: field.label }), _jsx("div", { className: "flex flex-wrap gap-2 mb-2", children: (conditions[field.key] ?? []).map((entry) => (_jsxs("span", { className: "inline-flex items-center gap-1.5 text-xs py-1 px-2.5 rounded-pill bg-surface-alt", children: [entry, _jsx("button", { type: "button", "aria-label": `Remove ${entry}`, onClick: () => removeListEntry(field.key, entry), className: "text-text-muted hover:text-danger", children: "\u00D7" })] }, entry))) }), _jsxs("div", { className: "flex gap-2", children: [_jsx("input", { type: "text", "aria-label": field.label, className: INPUT_CLASS, placeholder: field.placeholder ?? "Add a value", value: draftText[field.key] ?? "", onChange: (e) => setDraftText({ ...draftText, [field.key]: e.target.value }), 
+                                                // Text typed but never added (no Add/Enter) is committed when the field
+                                                // loses focus - e.g. to the page's Save button - so it's never silently
+                                                // dropped from the saved rule.
+                                                onBlur: () => addListEntry(field.key), onKeyDown: (e) => {
                                                     if (e.key === "Enter") {
                                                         e.preventDefault();
                                                         addListEntry(field.key);

package/dist/apps/shared/components/settings/layout/SettingsShell.d.ts

@@ -0,0 +1,41 @@
+import React, { PropsWithChildren } from "react";
+import { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { AppShellProps } from "../../layout/AppShell.js";
+import { PluginNav } from "../../../plugins/pluginNav.js";
+export interface SettingsSectionDef {
+    id: string;
+    href: string;
+    label: string;
+}
+/** Every settings section with its own sidebar entry. */
+export declare const SETTINGS_SECTIONS: SettingsSectionDef[];
+/** A `SETTINGS_SECTIONS` id, or a plugin's `settingsSections` item id (see `PluginNav`). */
+export type SettingsSectionId = string;
+/** `SETTINGS_SECTIONS` followed by the plugins' `settingsSections` items, core ids winning - see
+ * `mergePluginNavItems`. */
+export declare function settingsSections(pluginNav?: PluginNav): SettingsSectionDef[];
+export interface SettingsShellProps extends Omit<AppShellProps, "active"> {
+    /** Which entry in `SETTINGS_SECTIONS` (or plugin `settingsSections` item) is highlighted in this shell's own sidebar — distinct from
+     * `AppShell`'s own `active` (always hardcoded to `"settings"` below), since Settings isn't a rail
+     * icon (see `AppShell.tsx`'s `AppShellApp` doc comment) but still needs its own section
+     * highlighting. Each settings page passes its own section id explicitly, the same "gotcha" this
+     * plan already calls out for every shell's `active` prop. */
+    active: SettingsSectionId;
+}
+export interface SettingsShellContextValue {
+    /** The mailbox currently selected (`?mailboxUid=`, or the caller's first accessible mailbox) —
+     * every settings section so far (Automatic Replies) edits mailbox-scoped fields. */
+    mailboxUid?: string;
+    mailboxes: Mailbox[];
+}
+/** Reads the mailbox Settings is currently scoped to, as resolved by the enclosing `SettingsShell`. */
+export declare function useSettingsShell(): SettingsShellContextValue;
+/**
+ * The Settings area's shell — reached via a `UserMenu` entry rather than a 5th `AppShell` icon (per
+ * this plan's own confirmed decision), so it always passes `active="settings"` to `AppShell` regardless
+ * of which section is showing. Unlike `ContactsShell`/`TasksShell` (whose sidebar is just a mailbox
+ * switcher, since each has exactly one well-known folder), this shell's sidebar is a real list of
+ * settings sections (`SETTINGS_SECTIONS`) — full-page navigation between them, same as the top-level
+ * app rail, since this framework has no client-side router.
+ */
+export default function SettingsShell({ active, userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }: PropsWithChildren<SettingsShellProps>): React.JSX.Element;

package/dist/apps/shared/components/settings/layout/SettingsShell.js

@@ -12,6 +12,7 @@ import Alert from "@rapidmx/react-shared/components/feedback/Alert.js";
 import Skeleton, { SkeletonList } from "@rapidmx/react-shared/components/feedback/Skeleton.js";
 import AppShell from "../../layout/AppShell.js";
 import MailboxProvisioning from "../../layout/MailboxProvisioning.js";
+import { mergePluginNavItems } from "../../../plugins/pluginNav.js";
 /** Every settings section with its own sidebar entry. */
 export const SETTINGS_SECTIONS = [
     { id: "auto-reply", href: "/settings/auto-reply", label: "Automatic Replies" },
@@ -20,11 +21,19 @@ export const SETTINGS_SECTIONS = [
     { id: "labels", href: "/settings/labels", label: "Labels" },
     { id: "focused-inbox", href: "/settings/focused-inbox", label: "Focused Inbox" },
     { id: "read-receipts", href: "/settings/read-receipts", label: "Read Receipts" },
-    { id: "booking-types", href: "/settings/booking-types", label: "Booking Links" },
     { id: "encryption", href: "/settings/encryption", label: "Encryption" },
     { id: "sharing", href: "/settings/sharing", label: "Sharing" },
     { id: "privacy", href: "/settings/privacy", label: "Privacy & Data" },
 ];
+/** `SETTINGS_SECTIONS` followed by the plugins' `settingsSections` items, core ids winning - see
+ * `mergePluginNavItems`. */
+export function settingsSections(pluginNav) {
+    return mergePluginNavItems(SETTINGS_SECTIONS, pluginNav?.settingsSections, ({ id, href, label }) => ({
+        id,
+        href,
+        label,
+    }));
+}
 const SettingsShellContext = createContext({ mailboxes: [] });
 /** Reads the mailbox Settings is currently scoped to, as resolved by the enclosing `SettingsShell`. */
 export function useSettingsShell() {
@@ -38,7 +47,7 @@ export function useSettingsShell() {
  * settings sections (`SETTINGS_SECTIONS`) — full-page navigation between them, same as the top-level
  * app rail, since this framework has no client-side router.
  */
-export default function SettingsShell({ active, userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, children, }) {
+export default function SettingsShell({ active, userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }) {
     const [status, setStatus] = useState("checking");
     const [error, setError] = useState(null);
     const [mailboxes, setMailboxes] = useState([]);
@@ -77,16 +86,17 @@ export default function SettingsShell({ active, userUid, authServerUrl, imperson
         inner = (_jsx("div", { className: "flex-1 flex items-center justify-center p-8", children: _jsx("div", { className: "w-full max-w-md", children: _jsx(Alert, { children: error }) }) }));
     }
     else if (userUid && status === "ready") {
+        const sections = settingsSections(pluginNav);
         // A function, not a plain JSX constant — same reasoning as ContactsShell's identical comment:
         // rendered twice (desktop `<aside>` + mobile `Drawer`), possibly simultaneously mounted, so the
         // `<select>`'s `id`/its `<label>`'s `htmlFor` need a distinct value per instance.
         const sidebarContent = (idPrefix) => (_jsxs(_Fragment, { children: [mailboxes.length > 1 && (_jsxs("div", { children: [_jsx("label", { className: "block text-xs font-bold uppercase tracking-wide text-text-muted mb-1", htmlFor: `${idPrefix}-settings-mailbox-switcher`, children: "Mailbox" }), _jsx("select", { id: `${idPrefix}-settings-mailbox-switcher`, className: "w-full text-sm border border-border rounded-sm py-1.5 px-2 bg-surface", value: mailboxUid, onChange: (e) => {
-                                // `active` always names a real entry in `SETTINGS_SECTIONS` — every settings
-                                // page passes its own section id explicitly (see `SettingsShellProps.active`'s
-                                // own doc comment), so this lookup can't miss.
-                                const section = SETTINGS_SECTIONS.find((s) => s.id === active);
-                                window.location.href = `${section.href}?mailboxUid=${encodeURIComponent(e.target.value)}`;
-                            }, children: mailboxes.map((mb) => (_jsxs("option", { value: mb.uid, children: [mb.displayName, mb.ownerUserUid ? "" : " (shared)"] }, mb.uid))) })] })), _jsx("nav", { "aria-label": "Settings sections", className: "flex flex-col gap-0.5", children: SETTINGS_SECTIONS.map((section) => (_jsx("a", { 
+                                // Every core settings page passes its own section id (see
+                                // `SettingsShellProps.active`), but a plugin page's section is missing when the
+                                // server didn't send its nav item, so that falls back to the current path.
+                                const href = sections.find((s) => s.id === active)?.href ?? window.location.pathname;
+                                window.location.href = `${href}?mailboxUid=${encodeURIComponent(e.target.value)}`;
+                            }, children: mailboxes.map((mb) => (_jsxs("option", { value: mb.uid, children: [mb.displayName, mb.ownerUserUid ? "" : " (shared)"] }, mb.uid))) })] })), _jsx("nav", { "aria-label": "Settings sections", className: "flex flex-col gap-0.5", children: sections.map((section) => (_jsx("a", { 
                         // `inner` (this whole branch) is only ever computed once `status === "ready"`
                         // and `mailboxUid` has already resolved truthy — a falsy `mailboxUid` returns
                         // `<MailboxProvisioning />` above instead (and TypeScript's own narrowing of
@@ -100,5 +110,5 @@ export default function SettingsShell({ active, userUid, authServerUrl, imperson
                         ].join(" "), children: section.label }, section.id))) })] }));
         inner = (_jsxs(_Fragment, { children: [_jsx("aside", { className: "hidden md:flex w-56 shrink-0 bg-surface border-r border-border flex-col p-3 gap-3", children: sidebarContent("desktop") }), _jsx(Drawer, { open: drawerOpen, onClose: () => setDrawerOpen(false), title: "Settings", children: _jsx("div", { className: "flex flex-col gap-3", children: sidebarContent("mobile") }) }), _jsxs("main", { className: "flex-1 min-w-0 flex flex-col", children: [_jsx("button", { type: "button", className: "md:hidden m-3 self-start w-9 h-9 flex items-center justify-center rounded-sm text-text-muted hover:bg-surface-alt hover:text-text", "aria-label": "Open settings menu", onClick: () => setDrawerOpen(true), children: _jsx(HiOutlineBars3, { size: 20, "aria-hidden": "true" }) }), _jsx(SettingsShellContext.Provider, { value: contextValue, children: children })] })] }));
     }
-    return (_jsx(AppShell, { active: "settings", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, children: inner }));
+    return (_jsx(AppShell, { active: "settings", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, pluginNav: pluginNav, children: inner }));
 }

package/dist/apps/shared/components/tasks/TasksSidebar.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+import { Task } from "@rapidmx/react-shared/tasks/tasksApi.js";
+export type TasksView = {
+    type: "myDay";
+} | {
+    type: "important";
+} | {
+    type: "planned";
+} | {
+    type: "assignedToMe";
+} | {
+    type: "flagged";
+} | {
+    type: "all";
+} | {
+    type: "list";
+    uid: string;
+    name: string;
+};
+export declare function tasksViewKey(view: TasksView): string;
+export interface TasksSidebarProps {
+    mailboxUid?: string;
+    /** The caller's own (incomplete) tasks — used to compute every smart-filter's count. Deliberately not
+     * fetched again here; the parent already has this loaded for the main list. */
+    tasks: Task[];
+    userUid?: string;
+    active: TasksView;
+    onSelect: (view: TasksView) => void;
+    /** Bumped by the parent to force a contact-list-style re-fetch of task lists (mirrors
+     * `ContactsSidebar`'s identical prop) — not currently used by any caller, kept for parity/future use. */
+    refreshToken?: number;
+}
+/**
+ * Tasks' Outlook To-Do-style left sidebar. "My Day"/"Assigned to me" are real persisted fields
+ * (`Task.myDay`/`assignedTo`, from Phase 0); "Important"/"Planned" are pure smart-filters derived from
+ * already-loaded fields (`priority === "high"`/`dueDate != null`) with no backend concept of their own;
+ * "Flagged email" is a `Message` smart-filter (see `flaggedMessages.ts`), not a `Task` one at all — the
+ * page renders it as a distinct list, not the task table. "Tasks" is the flat, unfiltered default. Custom
+ * lists are real `TaskList` records, fetched here (same pattern as `ContactsSidebar`'s contact lists).
+ */
+export default function TasksSidebar({ mailboxUid, tasks, userUid, active, onSelect, refreshToken }: TasksSidebarProps): React.JSX.Element;

package/dist/apps/shared/components/tasks/TasksToolbar.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export type TasksViewMode = "list" | "grid";
+export interface TasksToolbarProps {
+    viewMode: TasksViewMode;
+    onViewModeChange: (mode: TasksViewMode) => void;
+    selectedCount: number;
+    onComplete: () => void;
+    onDelete: () => void;
+    onAddToMyDay: () => void;
+}
+/** Tasks' toolbar: a Grid/List view-mode toggle (local, not persisted) plus bulk actions for whatever
+ * rows are checked (Complete, Add to My Day, Delete) — deliberately presentational, matching
+ * `ContactsToolbar`'s convention, since the page owns the actual task data/selection. */
+export default function TasksToolbar({ viewMode, onViewModeChange, selectedCount, onComplete, onDelete, onAddToMyDay }: TasksToolbarProps): React.JSX.Element;

package/dist/apps/shared/components/tasks/layout/TasksShell.d.ts

@@ -0,0 +1,24 @@
+import React, { PropsWithChildren } from "react";
+import { Mailbox } from "@rapidmx/react-shared/mail/mailApi.js";
+import { AppShellProps } from "../../layout/AppShell.js";
+export type TasksShellProps = Omit<AppShellProps, "active">;
+export interface TasksShellContextValue {
+    /** The mailbox currently selected (`?mailboxUid=`, or the caller's first accessible mailbox). */
+    mailboxUid?: string;
+    /** The selected mailbox's single `tasks`-type folder. */
+    folderUid?: string;
+    mailboxes: Mailbox[];
+    /** The caller's own uid — exposed here (rather than only as `AppShell`'s prop) so the page content
+     * can compute "assigned to me" without needing it threaded through separately. */
+    userUid?: string;
+}
+/** Reads the mailbox/folder Tasks is currently showing, as resolved by the enclosing `TasksShell`. */
+export declare function useTasksShell(): TasksShellContextValue;
+/**
+ * The Tasks app's shell — structurally identical to `ContactsShell` (a mailbox has exactly one
+ * well-known `tasks` folder, guaranteed to exist by `BaseMailboxRoute.create()`'s eager provisioning
+ * in `@rapidmx/restapi`), just bound to a different folder type. Kept as its own small component
+ * (rather than a single generic "SingleFolderShell" parameterized by type) so each app's sidebar can
+ * grow its own app-specific controls later without threading extra props through a shared one.
+ */
+export default function TasksShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }: PropsWithChildren<TasksShellProps>): React.JSX.Element;

package/dist/apps/shared/components/tasks/layout/TasksShell.js

@@ -24,7 +24,7 @@ export function useTasksShell() {
  * (rather than a single generic "SingleFolderShell" parameterized by type) so each app's sidebar can
  * grow its own app-specific controls later without threading extra props through a shared one.
  */
-export default function TasksShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, children, }) {
+export default function TasksShell({ userUid, authServerUrl, impersonating, impersonationBaseUrl, trusted, pluginNav, children, }) {
     const [status, setStatus] = useState("checking");
     const [error, setError] = useState(null);
     const [mailboxes, setMailboxes] = useState([]);
@@ -88,5 +88,5 @@ export default function TasksShell({ userUid, authServerUrl, impersonating, impe
                             }, children: mailboxes.map((mb) => (_jsxs("option", { value: mb.uid, children: [mb.displayName, mb.ownerUserUid ? "" : " (shared)"] }, mb.uid))) })] })), folderError && _jsx(Alert, { children: folderError })] }));
         inner = (_jsxs(_Fragment, { children: [_jsx("aside", { className: "hidden md:flex w-56 shrink-0 bg-surface border-r border-border flex-col p-3 gap-3", children: sidebarContent("desktop") }), _jsx(Drawer, { open: drawerOpen, onClose: () => setDrawerOpen(false), title: "Mailbox", children: _jsx("div", { className: "flex flex-col gap-3", children: sidebarContent("mobile") }) }), _jsxs("main", { className: "flex-1 min-w-0 flex flex-col", children: [(mailboxes.length > 1 || folderError) && (_jsx("button", { type: "button", className: "md:hidden m-3 w-9 h-9 flex items-center justify-center rounded-sm text-text-muted hover:bg-surface-alt hover:text-text", "aria-label": "Open mailbox switcher", onClick: () => setDrawerOpen(true), children: _jsx(HiOutlineBars3, { size: 20, "aria-hidden": "true" }) })), _jsx(TasksShellContext.Provider, { value: contextValue, children: children })] })] }));
     }
-    return (_jsx(AppShell, { active: "tasks", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, children: inner }));
+    return (_jsx(AppShell, { active: "tasks", userUid: userUid, authServerUrl: authServerUrl, impersonating: impersonating, impersonationBaseUrl: impersonationBaseUrl, trusted: trusted, pluginNav: pluginNav, children: inner }));
 }

package/dist/apps/shared/mail/findWellKnownFolderUid.d.ts

@@ -0,0 +1,5 @@
+import { FolderType } from "@rapidmx/react-shared/mail/mailApi.js";
+/** The uid of a mailbox's well-known folder of `type` (e.g. its Contacts or Tasks folder), for creating an
+ * item in a mailbox other than the one an app currently has loaded. Resolves `undefined` if the mailbox has
+ * no such folder; rejects if the folder list can't be fetched. */
+export declare function findWellKnownFolderUid(mailboxUid: string, type: FolderType): Promise<string | undefined>;

package/dist/apps/shared/mail/listAllPages.d.ts

@@ -0,0 +1,17 @@
+/** Page size the list pages (Contacts, Tasks) request per call - restapi caps `limit` at 500. */
+export declare const LIST_PAGE_SIZE = 500;
+/** Safety cap on pages fetched - stops a server that ignores `page` (and keeps returning a full first
+ * page) from looping forever. 40 pages x 500 = 20,000 items. */
+export declare const MAX_LIST_PAGES = 40;
+export interface ListAllPagesResult<T> {
+    items: T[];
+    /** `true` when fetching stopped at `maxPages` with the last page still full - there may be more items
+     * the caller isn't showing, so it should say so rather than presenting `items` as the whole list. */
+    truncated: boolean;
+}
+/**
+ * Fetches every page of a zero-based `limit`/`page` list endpoint, stopping at the first short page
+ * (fewer than `pageSize` items) - so a folder with more items than one page holds is shown in full
+ * rather than silently cut off at the first page. Stops at `maxPages` regardless, reporting `truncated`.
+ */
+export declare function listAllPages<T>(fetchPage: (page: number) => Promise<T[]>, pageSize?: number, maxPages?: number): Promise<ListAllPagesResult<T>>;

package/dist/apps/shared/mail/listAllPages.js

@@ -0,0 +1,25 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/** Page size the list pages (Contacts, Tasks) request per call - restapi caps `limit` at 500. */
+export const LIST_PAGE_SIZE = 500;
+/** Safety cap on pages fetched - stops a server that ignores `page` (and keeps returning a full first
+ * page) from looping forever. 40 pages x 500 = 20,000 items. */
+export const MAX_LIST_PAGES = 40;
+/**
+ * Fetches every page of a zero-based `limit`/`page` list endpoint, stopping at the first short page
+ * (fewer than `pageSize` items) - so a folder with more items than one page holds is shown in full
+ * rather than silently cut off at the first page. Stops at `maxPages` regardless, reporting `truncated`.
+ */
+export async function listAllPages(fetchPage, pageSize = LIST_PAGE_SIZE, maxPages = MAX_LIST_PAGES) {
+    const items = [];
+    for (let page = 0; page < maxPages; page++) {
+        const batch = await fetchPage(page);
+        items.push(...batch);
+        if (batch.length < pageSize) {
+            return { items, truncated: false };
+        }
+    }
+    return { items, truncated: true };
+}

package/dist/apps/shared/plugins/pluginNav.d.ts

@@ -0,0 +1,39 @@
+/**
+ * One navigation entry a plugin contributes through its manifest's `ui` field. Structurally identical to
+ * `@rapidmx/restapi`'s `PluginUiNavItem`, defined locally so this package doesn't depend on restapi.
+ */
+export interface PluginUiNavItem {
+    /** Unique within its list. A plugin page passes this as its shell's `active` to highlight the entry. */
+    id: string;
+    label: string;
+    /** A same-origin path under the host's prefix (`/settings/...`, `/admin/...`, `/...`). */
+    href: string;
+}
+/**
+ * The navigation every enabled plugin with a successfully built UI contributes, supplied by the server's
+ * `WwwRoute`/`AdminConsoleRoute` `fetchProps` as the `pluginNav` page prop.
+ */
+export interface PluginNav {
+    /** Appended to `SettingsShell`'s section list. */
+    settingsSections?: PluginUiNavItem[];
+    /** Appended to `AdminShell`'s icon rail and mobile tab bar. */
+    adminNav?: PluginUiNavItem[];
+    /** Appended to `AppShell`'s app rail and mobile tab bar. */
+    appRail?: PluginUiNavItem[];
+}
+/** The page prop every www and admin page receives - extended by `AppShellProps` and `AdminShellProps`, so
+ * a page that spreads its props onto its shell passes `pluginNav` through with no code of its own. */
+export interface PluginNavProps {
+    pluginNav?: PluginNav;
+}
+/** A same-origin absolute path: starts with `/`, but not `//` or `/\` (both of which browsers treat as
+ * protocol-relative URLs to another host). */
+export declare function isSafePluginHref(href: string): boolean;
+/**
+ * Appends a plugin's nav items after the core ones. Skips any item that isn't well-formed, whose `href`
+ * isn't a same-origin path (see `isSafePluginHref`), or whose id is already taken - by a core item or
+ * `reservedIds` (core ids always win) or by an earlier plugin item.
+ */
+export declare function mergePluginNavItems<T extends {
+    id: string;
+}>(coreItems: T[], pluginItems: PluginUiNavItem[] | undefined, toItem: (item: PluginUiNavItem) => T, reservedIds?: string[]): T[];

package/dist/apps/shared/plugins/pluginNav.js

@@ -0,0 +1,33 @@
+///////////////////////////////////////////////////////////////////////////////
+// Copyright (C) 2026 Jean-Philippe Steinmetz
+// SPDX-License-Identifier: MPL-2.0
+///////////////////////////////////////////////////////////////////////////////
+/** A same-origin absolute path: starts with `/`, but not `//` or `/\` (both of which browsers treat as
+ * protocol-relative URLs to another host). */
+export function isSafePluginHref(href) {
+    return /^\/(?![/\\])/.test(href);
+}
+/**
+ * Appends a plugin's nav items after the core ones. Skips any item that isn't well-formed, whose `href`
+ * isn't a same-origin path (see `isSafePluginHref`), or whose id is already taken - by a core item or
+ * `reservedIds` (core ids always win) or by an earlier plugin item.
+ */
+export function mergePluginNavItems(coreItems, pluginItems, toItem, reservedIds = []) {
+    if (!pluginItems?.length) {
+        return coreItems;
+    }
+    const taken = new Set([...coreItems.map((item) => item.id), ...reservedIds]);
+    const merged = [...coreItems];
+    for (const item of pluginItems) {
+        if (typeof item?.id !== "string" ||
+            typeof item.label !== "string" ||
+            typeof item.href !== "string" ||
+            !isSafePluginHref(item.href) ||
+            taken.has(item.id)) {
+            continue;
+        }
+        taken.add(item.id);
+        merged.push(toItem(item));
+    }
+    return merged;
+}

package/dist/apps/shared/search/LocalIndexLifecycle.d.ts

@@ -0,0 +1,13 @@
+import type { PublicKey } from "@rapidmx/react-shared/crypto/keyvaultApi.js";
+import type { Folder } from "@rapidmx/react-shared/mail/mailApi.js";
+export declare const POLL_INTERVAL_MS = 5000;
+export interface LocalIndexLifecycleProps {
+    mailboxUid?: string;
+    mailboxKeys?: PublicKey[];
+    folders: Folder[];
+    /** Every mailbox the signed-in user can currently access. Once known, indexes on this device for any
+     * other mailbox (e.g. left behind by a different user who never signed out) are removed. */
+    accessibleMailboxUids?: string[];
+}
+/** Renders nothing - pure side-effect component, mounted by `MailShell.tsx`. */
+export default function LocalIndexLifecycle({ mailboxUid, folders, accessibleMailboxUids }: LocalIndexLifecycleProps): null;