feat: support outlook for calendar plus minor fixes

.env.example

@@ -3,3 +3,6 @@
 # See docs/GOOGLE_CALENDAR_ACCOUNTS_CALLBACK.md
 
 # GOOGLE_OAUTH_CLIENT_ID=your-id.apps.googleusercontent.com
+
+# Outlook / Microsoft Graph (see docs/OUTLOOK_CALENDAR_ACCOUNTS_CALLBACK.md)
+# OUTLOOK_OAUTH_CLIENT_ID=your-azure-application-client-id

src/background.ts

@@ -14,6 +14,7 @@ import {
 } from "./background/cloudSettingsAutoSync";
 import { isAllowedFetchUrl } from "@/seqta/utils/allowedFetchUrl";
 import { registerGoogleCalendarMessageHandlers, initGoogleCalendarBackground } from "./background/googleCalendar";
+import { registerOutlookCalendarMessageHandlers } from "./background/outlookCalendar";
 
 /**
  * Session-only dev-mode override of the content API base.
@@ -559,6 +560,7 @@ const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
 };
 
 registerGoogleCalendarMessageHandlers(MESSAGE_HANDLERS, isTrustedSender);
+registerOutlookCalendarMessageHandlers(MESSAGE_HANDLERS, isTrustedSender);
 initGoogleCalendarBackground();
 
 browser.runtime.onMessage.addListener(

src/background/calendarWeekly.ts

@@ -1,11 +1,12 @@
 import browser from "webextension-polyfill";
 import { verboseLog } from "@/utils/verboseLog";
 import {
+  CALENDAR_WEEKLY_ALARM,
   getAutoSyncWeekly,
-  GOOGLE_CALENDAR_WEEKLY_ALARM,
   markWeeklySyncPending,
-} from "@/seqta/utils/googleCalendar/syncSettings";
+} from "@/seqta/utils/calendarSync/settings";
 import { readGoogleCalendarState } from "@/seqta/utils/googleCalendar/storage";
+import { readOutlookCalendarState } from "@/seqta/utils/outlookCalendar/storage";
 
 const WEEKLY_PERIOD_MINUTES = 7 * 24 * 60;
 
@@ -14,29 +15,37 @@ function isSeqtaTab(tab: browser.Tabs.Tab): boolean {
   return title.includes("SEQTA Learn") || title.includes("SEQTA Engage");
 }
 
-async function isCalendarConnected(): Promise<boolean> {
+async function isAnyCalendarConnected(): Promise<boolean> {
-  const state = await readGoogleCalendarState();
+  const [google, outlook] = await Promise.all([
-  return !!(state.refreshToken || state.accessToken);
+    readGoogleCalendarState(),
+    readOutlookCalendarState(),
+  ]);
+  return !!(
+    google.refreshToken ||
+    google.accessToken ||
+    outlook.refreshToken ||
+    outlook.accessToken
+  );
 }
 
 export async function ensureWeeklySyncAlarm(): Promise<void> {
-  const connected = await isCalendarConnected();
+  const connected = await isAnyCalendarConnected();
   const enabled = await getAutoSyncWeekly();
   if (!connected || !enabled) {
-    await browser.alarms.clear(GOOGLE_CALENDAR_WEEKLY_ALARM);
+    await browser.alarms.clear(CALENDAR_WEEKLY_ALARM);
     return;
   }
 
-  const existing = await browser.alarms.get(GOOGLE_CALENDAR_WEEKLY_ALARM);
+  const existing = await browser.alarms.get(CALENDAR_WEEKLY_ALARM);
   if (!existing) {
-    await browser.alarms.create(GOOGLE_CALENDAR_WEEKLY_ALARM, {
+    await browser.alarms.create(CALENDAR_WEEKLY_ALARM, {
       periodInMinutes: WEEKLY_PERIOD_MINUTES,
     });
   }
 }
 
 export async function clearWeeklySyncAlarm(): Promise<void> {
-  await browser.alarms.clear(GOOGLE_CALENDAR_WEEKLY_ALARM);
+  await browser.alarms.clear(CALENDAR_WEEKLY_ALARM);
 }
 
 export async function triggerWeeklySyncOnSeqtaTabs(): Promise<boolean> {
@@ -48,7 +57,7 @@ export async function triggerWeeklySyncOnSeqtaTabs(): Promise<boolean> {
   for (const tab of seqtaTabs) {
     if (tab.id == null) continue;
     try {
-      await browser.tabs.sendMessage(tab.id, { type: "googleCalendarRunWeeklySync" });
+      await browser.tabs.sendMessage(tab.id, { type: "calendarRunWeeklySync" });
       delivered = true;
     } catch (err) {
       verboseLog("[BetterSEQTA+] Weekly calendar sync message failed for tab:", tab.id, err);
@@ -58,7 +67,7 @@ export async function triggerWeeklySyncOnSeqtaTabs(): Promise<boolean> {
 }
 
 export async function handleWeeklySyncAlarm(): Promise<void> {
-  if (!(await isCalendarConnected()) || !(await getAutoSyncWeekly())) return;
+  if (!(await isAnyCalendarConnected()) || !(await getAutoSyncWeekly())) return;
 
   const delivered = await triggerWeeklySyncOnSeqtaTabs();
   if (!delivered) {
@@ -68,7 +77,12 @@ export async function handleWeeklySyncAlarm(): Promise<void> {
 
 export function registerWeeklySyncAlarmListener(): void {
   browser.alarms.onAlarm.addListener((alarm) => {
-    if (alarm.name !== GOOGLE_CALENDAR_WEEKLY_ALARM) return;
+    if (alarm.name !== CALENDAR_WEEKLY_ALARM) return;
     void handleWeeklySyncAlarm();
   });
 }
+
+export function initCalendarBackground(): void {
+  registerWeeklySyncAlarmListener();
+  void ensureWeeklySyncAlarm();
+}

src/background/googleCalendar.ts

@@ -20,16 +20,16 @@ import {
   clampSyncWeeks,
   getAutoSyncWeekly,
   getSyncWeeksAhead,
-} from "@/seqta/utils/googleCalendar/syncSettings";
+} from "@/seqta/utils/calendarSync/settings";
+import {
+  readSharedCalendarSyncSettings,
+  writeSharedCalendarSyncSettings,
+} from "@/seqta/utils/calendarSync/sharedSettings";
 import type {
   GoogleCalendarStatus,
   GoogleCalendarSyncResult,
 } from "@/seqta/utils/googleCalendar/types";
-import {
+import { ensureWeeklySyncAlarm, initCalendarBackground } from "./calendarWeekly";
-  clearWeeklySyncAlarm,
-  ensureWeeklySyncAlarm,
-  registerWeeklySyncAlarmListener,
-} from "./googleCalendarWeekly";
 
 function base64UrlEncode(buffer: ArrayBuffer): string {
   const bytes = new Uint8Array(buffer);
@@ -221,13 +221,14 @@ async function connectGoogleCalendar(): Promise<GoogleCalendarSyncResult> {
 
 async function getGoogleCalendarStatus(): Promise<GoogleCalendarStatus> {
   const state = await readGoogleCalendarState();
+  const shared = await readSharedCalendarSyncSettings();
   const syncWeeksAhead = await getSyncWeeksAhead();
   const autoSyncWeekly = await getAutoSyncWeekly();
   return {
     configured: isGoogleCalendarConfigured(),
     connected: !!(state.refreshToken || state.accessToken),
     lastSyncAt: state.lastSyncAt,
-    lastWeeklySyncAt: state.lastWeeklySyncAt,
+    lastWeeklySyncAt: shared.lastWeeklySyncAt,
     lastSyncOrigin: state.lastSyncOrigin,
     syncWeeksAhead,
     autoSyncWeekly,
@@ -239,8 +240,8 @@ export async function handleGoogleCalendarConnect(): Promise<GoogleCalendarSyncR
 }
 
 export async function handleGoogleCalendarDisconnect(): Promise<{ success: boolean }> {
-  await clearWeeklySyncAlarm();
   await clearGoogleCalendarState();
+  await ensureWeeklySyncAlarm();
   return { success: true };
 }
 
@@ -345,7 +346,7 @@ export function registerGoogleCalendarMessageHandlers(
         patch.autoSyncWeekly = !!body.autoSyncWeekly;
       }
       if (Object.keys(patch).length > 0) {
-        await writeGoogleCalendarState(patch);
+        await writeSharedCalendarSyncSettings(patch);
       }
       await ensureWeeklySyncAlarm();
       sendResponse({ success: true, ...(await getGoogleCalendarStatus()) });
@@ -359,7 +360,4 @@ export function registerGoogleCalendarMessageHandlers(
   };
 }
 
-export function initGoogleCalendarBackground(): void {
+export { initCalendarBackground as initGoogleCalendarBackground } from "./calendarWeekly";
-  registerWeeklySyncAlarmListener();
-  void ensureWeeklySyncAlarm();
-}

src/background/outlookCalendar.ts

@@ -0,0 +1,302 @@
+import browser from "webextension-polyfill";
+import {
+  OUTLOOK_AUTH_URL,
+  OUTLOOK_CALENDAR_OAUTH_CALLBACK,
+  OUTLOOK_CALENDAR_SCOPE,
+  OUTLOOK_OAUTH_CLIENT_ID,
+  isOutlookCalendarConfigured,
+  outlookOAuthRedirectUriHint,
+} from "@/config/outlookCalendar";
+import {
+  exchangeOutlookCodeViaAccounts,
+  refreshOutlookTokenViaAccounts,
+} from "@/seqta/utils/outlookCalendar/accountsToken";
+import {
+  clearOutlookCalendarState,
+  readOutlookCalendarState,
+  writeOutlookCalendarState,
+} from "@/seqta/utils/outlookCalendar/storage";
+import type { OutlookCalendarStatus } from "@/seqta/utils/outlookCalendar/types";
+import type { GoogleCalendarSyncResult } from "@/seqta/utils/googleCalendar/types";
+import { ensureWeeklySyncAlarm } from "./calendarWeekly";
+
+function base64UrlEncode(buffer: ArrayBuffer): string {
+  const bytes = new Uint8Array(buffer);
+  let binary = "";
+  for (const b of bytes) binary += String.fromCharCode(b);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+
+async function sha256(input: string): Promise<ArrayBuffer> {
+  const data = new TextEncoder().encode(input);
+  return crypto.subtle.digest("SHA-256", data);
+}
+
+function randomVerifier(): string {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return base64UrlEncode(bytes.buffer);
+}
+
+async function pkceChallenge(verifier: string): Promise<string> {
+  return base64UrlEncode(await sha256(verifier));
+}
+
+function parseRedirectCode(responseUrl: string): string {
+  const url = new URL(responseUrl);
+  const err = url.searchParams.get("error");
+  if (err) throw new Error(url.searchParams.get("error_description") ?? err);
+  const code = url.searchParams.get("code");
+  if (!code) throw new Error("Microsoft sign-in did not return an authorization code.");
+  return code;
+}
+
+const OAUTH_CALLBACK_PREFIX = OUTLOOK_CALENDAR_OAUTH_CALLBACK;
+const OAUTH_TIMEOUT_MS = 10 * 60 * 1000;
+
+function isOAuthCallbackUrl(url: string): boolean {
+  if (!url.startsWith(OAUTH_CALLBACK_PREFIX)) return false;
+  const parsed = new URL(url);
+  return parsed.searchParams.has("code") || parsed.searchParams.has("error");
+}
+
+function waitForOAuthCallback(authTabId: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      cleanup();
+      reject(new Error("Microsoft sign-in timed out. Close the tab and try again."));
+    }, OAUTH_TIMEOUT_MS);
+
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      browser.tabs.onUpdated.removeListener(onUpdated);
+      browser.tabs.onRemoved.removeListener(onRemoved);
+    };
+
+    const finishFromUrl = (url: string, tabId: number) => {
+      if (!isOAuthCallbackUrl(url)) return false;
+      cleanup();
+      void browser.tabs.remove(tabId).catch(() => {});
+      resolve(url);
+      return true;
+    };
+
+    const onRemoved = (tabId: number) => {
+      if (tabId !== authTabId) return;
+      cleanup();
+      reject(new Error("Microsoft sign-in was cancelled."));
+    };
+
+    const onUpdated = (
+      tabId: number,
+      changeInfo: browser.Tabs.OnUpdatedChangeInfoType,
+      tab: browser.Tabs.Tab,
+    ) => {
+      if (tabId !== authTabId) return;
+      const url =
+        changeInfo.url ?? (changeInfo.status === "complete" ? tab.url : undefined);
+      if (url) finishFromUrl(url, tabId);
+    };
+
+    browser.tabs.onUpdated.addListener(onUpdated);
+    browser.tabs.onRemoved.addListener(onRemoved);
+
+    void browser.tabs
+      .get(authTabId)
+      .then((tab) => {
+        if (tab.url) finishFromUrl(tab.url, authTabId);
+      })
+      .catch(() => {});
+  });
+}
+
+async function openOAuthTab(authUrl: string): Promise<string> {
+  const tab = await browser.tabs.create({ url: authUrl, active: true });
+  if (tab.id === undefined) {
+    throw new Error("Could not open Microsoft sign-in tab.");
+  }
+  return waitForOAuthCallback(tab.id);
+}
+
+async function getValidAccessToken(): Promise<string> {
+  const state = await readOutlookCalendarState();
+  const now = Date.now();
+  if (state.accessToken && state.expiresAt && state.expiresAt > now + 60_000) {
+    return state.accessToken;
+  }
+  if (!state.refreshToken) {
+    throw new Error("Not connected to Outlook Calendar.");
+  }
+  const refreshed = await refreshOutlookTokenViaAccounts(state.refreshToken);
+  const expiresAt = refreshed.expires_in
+    ? Date.now() + refreshed.expires_in * 1000
+    : Date.now() + 3_600_000;
+  await writeOutlookCalendarState({
+    accessToken: refreshed.access_token,
+    refreshToken: refreshed.refresh_token ?? state.refreshToken,
+    expiresAt,
+  });
+  return refreshed.access_token;
+}
+
+async function connectOutlookCalendar(): Promise<GoogleCalendarSyncResult> {
+  if (!isOutlookCalendarConfigured()) {
+    return {
+      success: false,
+      configured: false,
+      error: "Outlook Calendar is not configured in this extension build.",
+    };
+  }
+
+  const redirectUri = OUTLOOK_CALENDAR_OAUTH_CALLBACK;
+  const verifier = randomVerifier();
+  const challenge = await pkceChallenge(verifier);
+  const authUrl = new URL(OUTLOOK_AUTH_URL);
+  authUrl.searchParams.set("client_id", OUTLOOK_OAUTH_CLIENT_ID);
+  authUrl.searchParams.set("response_type", "code");
+  authUrl.searchParams.set("redirect_uri", redirectUri);
+  authUrl.searchParams.set("scope", OUTLOOK_CALENDAR_SCOPE);
+  authUrl.searchParams.set("response_mode", "query");
+  authUrl.searchParams.set("prompt", "consent");
+  authUrl.searchParams.set("code_challenge", challenge);
+  authUrl.searchParams.set("code_challenge_method", "S256");
+
+  let responseUrl: string;
+  try {
+    responseUrl = await openOAuthTab(authUrl.toString());
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Microsoft sign-in failed";
+    const mismatch =
+      /redirect_uri|invalid_request|AADSTS50011/i.test(message) ||
+      /redirect_uri|invalid_request|AADSTS50011/i.test(String(err));
+    return {
+      success: false,
+      configured: true,
+      error: mismatch
+        ? `Microsoft redirect URI mismatch. ${outlookOAuthRedirectUriHint()}`
+        : message.includes("cancel")
+          ? "Microsoft sign-in was cancelled."
+          : message,
+    };
+  }
+
+  try {
+    const code = parseRedirectCode(responseUrl);
+    const tokens = await exchangeOutlookCodeViaAccounts(code, redirectUri, verifier);
+    const expiresAt = tokens.expires_in
+      ? Date.now() + tokens.expires_in * 1000
+      : Date.now() + 3_600_000;
+
+    const existing = await readOutlookCalendarState();
+    await writeOutlookCalendarState({
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token ?? existing.refreshToken,
+      expiresAt,
+      connectedAt: Date.now(),
+    });
+
+    await ensureWeeklySyncAlarm();
+
+    return { success: true, configured: true, connected: true };
+  } catch (err) {
+    return {
+      success: false,
+      configured: true,
+      error: err instanceof Error ? err.message : "Microsoft sign-in failed",
+    };
+  }
+}
+
+async function getOutlookCalendarStatus(): Promise<OutlookCalendarStatus> {
+  const state = await readOutlookCalendarState();
+  return {
+    configured: isOutlookCalendarConfigured(),
+    connected: !!(state.refreshToken || state.accessToken),
+    lastSyncAt: state.lastSyncAt,
+    lastSyncOrigin: state.lastSyncOrigin,
+  };
+}
+
+export async function handleOutlookCalendarConnect(): Promise<GoogleCalendarSyncResult> {
+  return connectOutlookCalendar();
+}
+
+export async function handleOutlookCalendarDisconnect(): Promise<{ success: boolean }> {
+  await clearOutlookCalendarState();
+  await ensureWeeklySyncAlarm();
+  return { success: true };
+}
+
+export async function handleOutlookCalendarStatus(): Promise<OutlookCalendarStatus> {
+  return getOutlookCalendarStatus();
+}
+
+export function registerOutlookCalendarMessageHandlers(
+  handlers: Record<
+    string,
+    (
+      request: unknown,
+      sendResponse: (response?: unknown) => void,
+      sender?: browser.Runtime.MessageSender,
+    ) => boolean | void
+  >,
+  isTrustedSender: (sender?: browser.Runtime.MessageSender) => boolean,
+): void {
+  const rejectUntrusted = (
+    sendResponse: (response?: unknown) => void,
+    sender?: browser.Runtime.MessageSender,
+  ): boolean => {
+    if (isTrustedSender(sender)) return false;
+    sendResponse({ success: false, error: "Unauthorized sender" });
+    return true;
+  };
+
+  handlers.outlookCalendarConnect = (_req, sendResponse, sender) => {
+    if (rejectUntrusted(sendResponse, sender)) return false;
+    void handleOutlookCalendarConnect()
+      .then(sendResponse)
+      .catch((err) => {
+        sendResponse({
+          success: false,
+          error: err instanceof Error ? err.message : "Microsoft sign-in failed",
+        });
+      });
+    return true;
+  };
+
+  handlers.outlookCalendarDisconnect = (_req, sendResponse, sender) => {
+    if (rejectUntrusted(sendResponse, sender)) return false;
+    void handleOutlookCalendarDisconnect()
+      .then(sendResponse)
+      .catch((err) => {
+        sendResponse({
+          success: false,
+          error: err instanceof Error ? err.message : "Disconnect failed",
+        });
+      });
+    return true;
+  };
+
+  handlers.outlookCalendarStatus = (_req, sendResponse, sender) => {
+    if (rejectUntrusted(sendResponse, sender)) return false;
+    void handleOutlookCalendarStatus()
+      .then(sendResponse)
+      .catch(() => {
+        sendResponse({ configured: isOutlookCalendarConfigured(), connected: false });
+      });
+    return true;
+  };
+
+  handlers.outlookCalendarGetAccessToken = (_req, sendResponse, sender) => {
+    if (rejectUntrusted(sendResponse, sender)) return false;
+    void getValidAccessToken()
+      .then((accessToken) => sendResponse({ success: true, accessToken }))
+      .catch((err) => {
+        sendResponse({
+          success: false,
+          error: err instanceof Error ? err.message : "Token refresh failed",
+        });
+      });
+    return true;
+  };
+}

src/config/outlookCalendar.ts

@@ -0,0 +1,43 @@
+/**
+ * Outlook Calendar OAuth — public client config (extension).
+ * Client secret and token exchange live on accounts.betterseqta.org.
+ * See docs/OUTLOOK_CALENDAR_ACCOUNTS_CALLBACK.md
+ */
+
+import { ACCOUNTS_BASE } from "@/config/googleCalendar";
+
+const HARDCODED_OUTLOOK_OAUTH_CLIENT_ID =
+  "0b55168c-916c-4323-8f67-b3dd30af3c9e";
+
+const envClientId =
+  typeof __OUTLOOK_OAUTH_CLIENT_ID__ !== "undefined" ? __OUTLOOK_OAUTH_CLIENT_ID__ : "";
+
+export const OUTLOOK_OAUTH_CLIENT_ID: string =
+  envClientId.trim() || HARDCODED_OUTLOOK_OAUTH_CLIENT_ID.trim();
+
+/** Must match Azure app registration + accounts callback route exactly. */
+export const OUTLOOK_CALENDAR_OAUTH_CALLBACK = `${ACCOUNTS_BASE}/auth/microsoft/calendar/callback`;
+
+export const OUTLOOK_CALENDAR_TOKEN_URL = `${ACCOUNTS_BASE}/api/bsplus/microsoft/calendar/token`;
+export const OUTLOOK_CALENDAR_REFRESH_URL = `${ACCOUNTS_BASE}/api/bsplus/microsoft/calendar/refresh`;
+
+/** Delegated Graph scopes for create/update/delete calendar events. */
+export const OUTLOOK_CALENDAR_SCOPE = "offline_access Calendars.ReadWrite User.Read";
+
+export const OUTLOOK_AUTH_URL =
+  "https://login.microsoftonline.com/common/oauth2/v2.0/authorize";
+
+export const OUTLOOK_GRAPH_API = "https://graph.microsoft.com/v1.0";
+
+export const BSPLUS_OUTLOOK_CALENDAR_EVENT_CATEGORY = "BetterSEQTA+";
+
+export function isOutlookCalendarConfigured(): boolean {
+  return OUTLOOK_OAUTH_CLIENT_ID.length > 0;
+}
+
+export const OUTLOOK_CALENDAR_ACCOUNTS_NOT_READY_HINT =
+  "Outlook Calendar connect requires accounts.betterseqta.org — see docs/OUTLOOK_CALENDAR_ACCOUNTS_CALLBACK.md";
+
+export function outlookOAuthRedirectUriHint(): string {
+  return `Authorized redirect URI in Azure must be: ${OUTLOOK_CALENDAR_OAUTH_CALLBACK}`;
+}

src/env.d.ts

@@ -3,3 +3,4 @@ declare const __GH_RELEASE_REPO__: string;
 declare const __UPDATE_CHANNEL__: "stable" | "nightly";
 declare const __BUILD_LABEL__: string;
 declare const __GOOGLE_OAUTH_CLIENT_ID__: string;
+declare const __OUTLOOK_OAUTH_CLIENT_ID__: string;

src/manifests/manifest.json

@@ -22,13 +22,15 @@
     "https://accounts.betterseqta.org/",
     "https://www.googleapis.com/",
     "https://oauth2.googleapis.com/",
+    "https://graph.microsoft.com/",
+    "https://login.microsoftonline.com/",
     "*://*/*"
   ],
   "background": {
     "service_worker": "background.ts"
   },
   "content_security_policy": {
-    "extension_pages": "script-src 'self'; object-src 'self'; connect-src 'self' http: https: https://betterseqta.org https://accounts.betterseqta.org https://raw.githubusercontent.com https://newsapi.org https://www.googleapis.com https://oauth2.googleapis.com"
+    "extension_pages": "script-src 'self'; object-src 'self'; connect-src 'self' http: https: https://betterseqta.org https://accounts.betterseqta.org https://raw.githubusercontent.com https://newsapi.org https://www.googleapis.com https://oauth2.googleapis.com https://graph.microsoft.com https://login.microsoftonline.com"
   },
   "content_scripts": [
     {

src/plugins/built-in/timetable/CalendarDeleteEventsModal.svelte

@@ -4,11 +4,13 @@
   let {
     open = false,
     busy = false,
+    providerLabel = "Google",
     onConfirm,
     onCancel,
   } = $props<{
     open?: boolean;
     busy?: boolean;
+    providerLabel?: string;
     onConfirm: () => void | Promise<void>;
     onCancel: () => void;
   }>();
@@ -37,7 +39,7 @@
         Remove synced events?
       </h2>
       <p class="bsplus-cal-modal-body">
-        This removes all BetterSEQTA+ timetable events from your Google Calendar for this school.
+        This removes all BetterSEQTA+ timetable events from your {providerLabel} Calendar for this school.
         Your connection stays active — you can sync again later.
       </p>
       <div class="bsplus-cal-modal-actions">

src/plugins/built-in/timetable/CalendarDisconnectModal.svelte

@@ -4,11 +4,13 @@
   let {
     open = false,
     busy = false,
+    providerLabel = "Google",
     onConfirm,
     onCancel,
   } = $props<{
     open?: boolean;
     busy?: boolean;
+    providerLabel?: string;
     onConfirm: () => void | Promise<void>;
     onCancel: () => void;
   }>();
@@ -34,10 +36,10 @@
       transition:fade={{ duration: 180 }}
     >
       <h2 id="bsplus-cal-disconnect-title" class="bsplus-cal-modal-title">
-        Disconnect Google Calendar?
+        Disconnect {providerLabel} Calendar?
       </h2>
       <p class="bsplus-cal-modal-body">
-        Your synced timetable events will stay in Google Calendar, but BetterSEQTA+ will stop
+        Your synced timetable events will stay in {providerLabel} Calendar, but BetterSEQTA+ will stop
         updating them until you connect again.
       </p>
       <div class="bsplus-cal-modal-actions">

src/plugins/built-in/timetable/CalendarSyncControl.svelte

@@ -8,6 +8,10 @@
   } from "@/config/googleCalendar";
   import { maybeRunDueWeeklySync } from "@/seqta/utils/googleCalendar/calendarSyncListener";
   import { deleteSyncedEventsFromGoogleCalendar } from "@/seqta/utils/googleCalendar/syncEngine";
+  import {
+    formatOutlookSyncResultMessage,
+    runOutlookCalendarSync,
+  } from "@/seqta/utils/outlookCalendar/syncRunner";
   import {
     formatSyncResultMessage,
     runGoogleCalendarSync,
@@ -17,17 +21,24 @@
     GoogleCalendarSyncProgress,
     GoogleCalendarSyncResult,
   } from "@/seqta/utils/googleCalendar/types";
+  import type { OutlookCalendarStatus } from "@/seqta/utils/outlookCalendar/types";
+  import { deleteSyncedEventsFromOutlookCalendar } from "@/seqta/utils/outlookCalendar/syncEngine";
   import CalendarDeleteEventsModal from "./CalendarDeleteEventsModal.svelte";
   import CalendarDisconnectModal from "./CalendarDisconnectModal.svelte";
   import CalendarSyncProgress from "./CalendarSyncProgress.svelte";
+  import OutlookCalendarIcon from "./OutlookCalendarIcon.svelte";
   import { settingsState } from "@/seqta/utils/listeners/SettingsState";
   import { syncCalendarSyncTheme } from "./calendarSyncTheme";
 
+  type CalendarProvider = "google" | "outlook";
   type BusyPhase = "connect" | "sync" | "delete" | "disconnect" | null;
+  type BusyState = { provider: CalendarProvider; phase: BusyPhase } | null;
 
-  let status = $state<GoogleCalendarStatus>({ configured: true, connected: false });
+  let googleStatus = $state<GoogleCalendarStatus>({ configured: true, connected: false });
-  let busy = $state<BusyPhase>(null);
+  let outlookStatus = $state<OutlookCalendarStatus>({ configured: true, connected: false });
+  let busy = $state<BusyState>(null);
   let menuOpen = $state(false);
+  let modalProvider = $state<CalendarProvider | null>(null);
   let showDisconnect = $state(false);
   let showDeleteEvents = $state(false);
   let toast = $state<{ message: string; error: boolean } | null>(null);
@@ -42,8 +53,17 @@
   let toastTimer: ReturnType<typeof setTimeout> | null = null;
 
   const isBusy = $derived(busy !== null);
+  const anyConnected = $derived(googleStatus.connected || outlookStatus.connected);
   const accent = "var(--bsplus-cal-accent, var(--better-main, #3b82f6))";
 
+  function isProviderBusy(provider: CalendarProvider): boolean {
+    return busy?.provider === provider;
+  }
+
+  function providerPhase(provider: CalendarProvider): BusyPhase {
+    return busy?.provider === provider ? busy.phase : null;
+  }
+
   function showToastMessage(message: string, isError = false) {
     toast = { message, error: isError };
     if (toastTimer) clearTimeout(toastTimer);
@@ -53,19 +73,26 @@
   }
 
   async function refreshStatus() {
-    status = (await browser.runtime.sendMessage({
+    const [google, outlook] = await Promise.all([
-      type: "googleCalendarStatus",
+      browser.runtime.sendMessage({ type: "googleCalendarStatus" }) as Promise<GoogleCalendarStatus>,
-    })) as GoogleCalendarStatus;
+      browser.runtime.sendMessage({ type: "outlookCalendarStatus" }) as Promise<OutlookCalendarStatus>,
-    syncWeeksAhead = status.syncWeeksAhead ?? 12;
+    ]);
-    autoSyncWeekly = status.autoSyncWeekly !== false;
+    googleStatus = google;
+    outlookStatus = outlook;
+    syncWeeksAhead = google.syncWeeksAhead ?? 12;
+    autoSyncWeekly = google.autoSyncWeekly !== false;
   }
 
-  async function getAccessTokenFromBackground(): Promise<string> {
+  async function getAccessToken(provider: CalendarProvider): Promise<string> {
-    const res = (await browser.runtime.sendMessage({
+    const messageType =
-      type: "googleCalendarGetAccessToken",
+      provider === "google" ? "googleCalendarGetAccessToken" : "outlookCalendarGetAccessToken";
-    })) as { success?: boolean; accessToken?: string; error?: string };
+    const res = (await browser.runtime.sendMessage({ type: messageType })) as {
+      success?: boolean;
+      accessToken?: string;
+      error?: string;
+    };
     if (!res?.success || !res.accessToken) {
-      throw new Error(res?.error ?? "Could not get Google Calendar access token.");
+      throw new Error(res?.error ?? "Could not get calendar access token.");
     }
     return res.accessToken;
   }
@@ -84,15 +111,17 @@
     })) as GoogleCalendarStatus & { success?: boolean };
     if (result.syncWeeksAhead != null) syncWeeksAhead = result.syncWeeksAhead;
     if (result.autoSyncWeekly != null) autoSyncWeekly = result.autoSyncWeekly;
-    status = { ...status, ...result };
+    googleStatus = { ...googleStatus, ...result };
   }
 
-  async function performSync(mode: "full" | "incremental" = "full"): Promise<boolean> {
+  async function performSync(
-    const result = await runGoogleCalendarSync({
+    provider: CalendarProvider,
-      mode,
+    mode: "full" | "incremental" = "full",
-      onProgress: handleSyncProgress,
+  ): Promise<boolean> {
-    });
+    const run = provider === "google" ? runGoogleCalendarSync : runOutlookCalendarSync;
+    const format = provider === "google" ? formatSyncResultMessage : formatOutlookSyncResultMessage;
 
+    const result = await run({ mode, onProgress: handleSyncProgress });
     syncProgress = null;
 
     if (!result.success) {
@@ -100,30 +129,47 @@
       return false;
     }
 
-    status = {
+    if (provider === "google") {
-      ...status,
+      googleStatus = {
+        ...googleStatus,
         connected: true,
-      lastSyncAt: result.lastSyncAt ?? status.lastSyncAt,
+        lastSyncAt: result.lastSyncAt ?? googleStatus.lastSyncAt,
       };
-    showToastMessage(formatSyncResultMessage(result));
+    } else {
+      outlookStatus = {
+        ...outlookStatus,
+        connected: true,
+        lastSyncAt: result.lastSyncAt ?? outlookStatus.lastSyncAt,
+      };
+    }
+
+    showToastMessage(format(result));
     return true;
   }
 
-  async function connectGoogle() {
+  async function connectProvider(provider: CalendarProvider) {
+    const status = provider === "google" ? googleStatus : outlookStatus;
     if (!status.configured || isBusy) return;
     menuOpen = true;
-    busy = "connect";
+    busy = { provider, phase: "connect" };
+    const connectType =
+      provider === "google" ? "googleCalendarConnect" : "outlookCalendarConnect";
     try {
       const result = (await browser.runtime.sendMessage({
-        type: "googleCalendarConnect",
+        type: connectType,
       })) as GoogleCalendarSyncResult;
       if (!result.success) {
-        showToastMessage(result.error ?? "Could not connect to Google Calendar.", true);
+        const label = provider === "google" ? "Google" : "Outlook";
+        showToastMessage(result.error ?? `Could not connect to ${label} Calendar.`, true);
         return;
       }
-      status = { ...status, connected: true };
+      if (provider === "google") {
-      busy = "sync";
+        googleStatus = { ...googleStatus, connected: true };
-      await performSync();
+      } else {
+        outlookStatus = { ...outlookStatus, connected: true };
+      }
+      busy = { provider, phase: "sync" };
+      await performSync(provider);
     } catch (err) {
       showToastMessage(err instanceof Error ? err.message : "Could not connect.", true);
     } finally {
@@ -132,16 +178,17 @@
     }
   }
 
-  async function syncTimetable() {
+  async function syncProvider(provider: CalendarProvider) {
+    const status = provider === "google" ? googleStatus : outlookStatus;
     if (!status.configured || isBusy) return;
     if (!status.connected) {
-      await connectGoogle();
+      await connectProvider(provider);
       return;
     }
 
-    busy = "sync";
+    busy = { provider, phase: "sync" };
     try {
-      await performSync();
+      await performSync(provider);
     } catch (err) {
       showToastMessage(err instanceof Error ? err.message : "Calendar sync failed.", true);
     } finally {
@@ -151,8 +198,9 @@
   }
 
   async function confirmDeleteEvents() {
-    if (isBusy) return;
+    if (isBusy || !modalProvider) return;
-    busy = "delete";
+    const provider = modalProvider;
+    busy = { provider, phase: "delete" };
     syncProgress = {
       phase: "preparing",
       current: 0,
@@ -160,11 +208,13 @@
       message: "Preparing removal…",
     };
     try {
-      const result = await deleteSyncedEventsFromGoogleCalendar(
+      const deleteFn =
-        location.origin,
+        provider === "google"
-        getAccessTokenFromBackground,
+          ? deleteSyncedEventsFromGoogleCalendar
-        { onProgress: handleSyncProgress },
+          : deleteSyncedEventsFromOutlookCalendar;
-      );
+      const result = await deleteFn(location.origin, () => getAccessToken(provider), {
+        onProgress: handleSyncProgress,
+      });
 
       if (!result.success) {
         showToastMessage(result.error ?? "Could not remove calendar events.", true);
@@ -174,6 +224,7 @@
       const removed = result.deleted ?? 0;
       showDeleteEvents = false;
       menuOpen = false;
+      modalProvider = null;
       if (removed === 0) {
         showToastMessage("No synced events to remove.");
       } else {
@@ -200,20 +251,29 @@
   }
 
   async function confirmDisconnect() {
-    if (isBusy) return;
+    if (isBusy || !modalProvider) return;
-    busy = "disconnect";
+    const provider = modalProvider;
+    busy = { provider, phase: "disconnect" };
+    const disconnectType =
+      provider === "google" ? "googleCalendarDisconnect" : "outlookCalendarDisconnect";
+    const label = provider === "google" ? "Google" : "Outlook";
     try {
       const result = (await browser.runtime.sendMessage({
-        type: "googleCalendarDisconnect",
+        type: disconnectType,
       })) as { success?: boolean };
       if (!result?.success) {
-        showToastMessage("Could not disconnect Google Calendar.", true);
+        showToastMessage(`Could not disconnect ${label} Calendar.`, true);
         return;
       }
-      status = { ...status, connected: false, lastSyncAt: undefined };
+      if (provider === "google") {
+        googleStatus = { ...googleStatus, connected: false, lastSyncAt: undefined };
+      } else {
+        outlookStatus = { ...outlookStatus, connected: false, lastSyncAt: undefined };
+      }
       showDisconnect = false;
       menuOpen = false;
-      showToastMessage("Disconnected from Google Calendar.");
+      modalProvider = null;
+      showToastMessage(`Disconnected from ${label} Calendar.`);
     } catch (err) {
       showToastMessage(err instanceof Error ? err.message : "Disconnect failed.", true);
     } finally {
@@ -294,6 +354,7 @@
 
     const themeKeys = [
       "selectedColor",
+      "selectedFont",
       "DarkMode",
       "adaptiveThemeColour",
       "adaptiveThemeGradient",
@@ -333,22 +394,22 @@
 <div class="bsplus-cal-sync" bind:this={rootEl}>
   <button
     type="button"
-    class="uiButton bsplus-cal-trigger iconFamily"
+    class="uiButton bsplus-cal-trigger"
     bind:this={triggerEl}
     class:bsplus-cal-trigger--open={menuOpen}
-    class:bsplus-cal-trigger--connected={status.connected}
+    class:bsplus-cal-trigger--connected={anyConnected}
     class:bsplus-cal-trigger--busy={isBusy}
     aria-haspopup="menu"
     aria-expanded={menuOpen}
     aria-busy={isBusy}
-    aria-label={status.connected ? "Google Calendar sync options" : "Sync with Calendar"}
+    aria-label={anyConnected ? "Calendar sync options" : "Sync with Calendar"}
     onclick={() => {
       if (!isBusy) toggleMenu();
     }}
   >
-    <span class="bsplus-cal-trigger-icon" aria-hidden="true">&#xe9cd;</span>
+    <span class="bsplus-cal-trigger-icon iconFamily" aria-hidden="true">&#xe9cd;</span>
     <span class="bsplus-cal-trigger-text">Sync with Calendar</span>
-    {#if status.connected}
+    {#if anyConnected}
       <span class="bsplus-cal-status-dot" aria-hidden="true"></span>
     {/if}
   </button>
@@ -397,10 +458,10 @@
               <span> Calendar</span>
             </span>
             <span class="bsplus-cal-provider-status">
-              {#if !status.configured}
+              {#if !googleStatus.configured}
                 Not available in this build
-              {:else if status.connected}
+              {:else if googleStatus.connected}
-                Connected{formatLastSync(status.lastSyncAt) ? ` · ${formatLastSync(status.lastSyncAt)}` : ""}
+                Connected{formatLastSync(googleStatus.lastSyncAt) ? ` · ${formatLastSync(googleStatus.lastSyncAt)}` : ""}
               {:else}
                 Not connected
               {/if}
@@ -408,7 +469,128 @@
           </div>
         </div>
 
-        {#if status.connected}
+        <div class="bsplus-cal-provider-actions">
+          {#if !googleStatus.connected}
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--primary"
+              style:--bsplus-cal-accent={accent}
+              role="menuitem"
+              disabled={!googleStatus.configured || isBusy}
+              onclick={() => void connectProvider("google")}
+            >
+              {providerPhase("google") === "connect" ? "Connecting…" : "Connect"}
+            </button>
+          {:else}
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--primary"
+              style:--bsplus-cal-accent={accent}
+              role="menuitem"
+              disabled={isBusy}
+              onclick={() => void syncProvider("google")}
+            >
+              {providerPhase("google") === "sync" ? "Syncing…" : "Sync now"}
+            </button>
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--ghost"
+              role="menuitem"
+              disabled={isBusy}
+              onclick={() => {
+                modalProvider = "google";
+                showDeleteEvents = true;
+              }}
+            >
+              {providerPhase("google") === "delete" ? "Removing…" : "Remove from calendar"}
+            </button>
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--ghost"
+              role="menuitem"
+              disabled={isBusy}
+              onclick={() => {
+                modalProvider = "google";
+                showDisconnect = true;
+              }}
+            >
+              Disconnect
+            </button>
+          {/if}
+        </div>
+      </div>
+
+      <div class="bsplus-cal-provider bsplus-cal-provider--outlook" role="none">
+        <div class="bsplus-cal-provider-row">
+          <span class="bsplus-cal-provider-icon" aria-hidden="true">
+            <OutlookCalendarIcon />
+          </span>
+          <div class="bsplus-cal-provider-copy">
+            <span class="bsplus-cal-provider-name">Outlook Calendar</span>
+            <span class="bsplus-cal-provider-status">
+              {#if !outlookStatus.configured}
+                Set OUTLOOK_OAUTH_CLIENT_ID to enable
+              {:else if outlookStatus.connected}
+                Connected{formatLastSync(outlookStatus.lastSyncAt) ? ` · ${formatLastSync(outlookStatus.lastSyncAt)}` : ""}
+              {:else}
+                Not connected
+              {/if}
+            </span>
+          </div>
+        </div>
+
+        <div class="bsplus-cal-provider-actions">
+          {#if !outlookStatus.connected}
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--primary"
+              style:--bsplus-cal-accent={accent}
+              role="menuitem"
+              disabled={!outlookStatus.configured || isBusy}
+              onclick={() => void connectProvider("outlook")}
+            >
+              {providerPhase("outlook") === "connect" ? "Connecting…" : "Connect"}
+            </button>
+          {:else}
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--primary"
+              style:--bsplus-cal-accent={accent}
+              role="menuitem"
+              disabled={isBusy}
+              onclick={() => void syncProvider("outlook")}
+            >
+              {providerPhase("outlook") === "sync" ? "Syncing…" : "Sync now"}
+            </button>
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--ghost"
+              role="menuitem"
+              disabled={isBusy}
+              onclick={() => {
+                modalProvider = "outlook";
+                showDeleteEvents = true;
+              }}
+            >
+              {providerPhase("outlook") === "delete" ? "Removing…" : "Remove from calendar"}
+            </button>
+            <button
+              type="button"
+              class="bsplus-cal-action bsplus-cal-action--ghost"
+              role="menuitem"
+              disabled={isBusy}
+              onclick={() => {
+                modalProvider = "outlook";
+                showDisconnect = true;
+              }}
+            >
+              Disconnect
+            </button>
+          {/if}
+        </div>
+      </div>
+
+      {#if anyConnected}
         <div class="bsplus-cal-settings" role="group" aria-label="Sync settings">
             <label class="bsplus-cal-setting">
               <span class="bsplus-cal-setting-label">Weeks ahead</span>
@@ -440,76 +622,29 @@
 
         <CalendarSyncProgress progress={syncProgress} />
 
-        <div class="bsplus-cal-provider-actions">
-          {#if !status.connected}
-            <button
-              type="button"
-              class="bsplus-cal-action bsplus-cal-action--primary"
-              style:--bsplus-cal-accent={accent}
-              role="menuitem"
-              disabled={!status.configured || isBusy}
-              onclick={() => void connectGoogle()}
-            >
-              {busy === "connect" ? "Connecting…" : "Connect"}
-            </button>
-          {:else}
-            <button
-              type="button"
-              class="bsplus-cal-action bsplus-cal-action--primary"
-              style:--bsplus-cal-accent={accent}
-              role="menuitem"
-              disabled={isBusy}
-              onclick={() => void syncTimetable()}
-            >
-              {busy === "sync" ? "Syncing…" : "Sync now"}
-            </button>
-            <button
-              type="button"
-              class="bsplus-cal-action bsplus-cal-action--ghost"
-              role="menuitem"
-              disabled={isBusy}
-              onclick={() => {
-                showDeleteEvents = true;
-              }}
-            >
-              {busy === "delete" ? "Removing…" : "Remove from calendar"}
-            </button>
-            <button
-              type="button"
-              class="bsplus-cal-action bsplus-cal-action--ghost"
-              role="menuitem"
-              disabled={isBusy}
-              onclick={() => {
-                showDisconnect = true;
-              }}
-            >
-              Disconnect
-            </button>
-          {/if}
-        </div>
-      </div>
-
       <div class="bsplus-cal-coming-soon" role="none">
         <span class="bsplus-cal-coming-soon-label">More providers</span>
-        <span class="bsplus-cal-coming-soon-hint">Outlook, Apple Calendar — coming soon</span>
+        <span class="bsplus-cal-coming-soon-hint">Apple Calendar — coming soon</span>
       </div>
     </div>
   {/if}
 
   <CalendarDeleteEventsModal
     open={showDeleteEvents}
-    busy={busy === "delete"}
+    busy={busy?.phase === "delete"}
+    providerLabel={modalProvider === "outlook" ? "Outlook" : "Google"}
     onCancel={() => {
-      if (busy !== "delete") showDeleteEvents = false;
+      if (busy?.phase !== "delete") showDeleteEvents = false;
     }}
     onConfirm={confirmDeleteEvents}
   />
 
   <CalendarDisconnectModal
     open={showDisconnect}
-    busy={busy === "disconnect"}
+    busy={busy?.phase === "disconnect"}
+    providerLabel={modalProvider === "outlook" ? "Outlook" : "Google"}
     onCancel={() => {
-      if (busy !== "disconnect") showDisconnect = false;
+      if (busy?.phase !== "disconnect") showDisconnect = false;
     }}
     onConfirm={confirmDisconnect}
   />
@@ -530,7 +665,7 @@
   .bsplus-cal-sync {
     position: relative;
     display: inline-flex;
-    font-family: Rubik, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    font-family: var(--bsplus-cal-font-family, var(--betterseqta-font-family, Rubik), sans-serif);
     color: var(--bsplus-cal-text, var(--text-primary, #111));
   }
 
@@ -545,16 +680,19 @@
     padding: 0 10px;
     margin-left: 4px;
     border-radius: 16px !important;
+    font-family: inherit;
     transition: all 0.2s ease;
   }
 
   .bsplus-cal-trigger-icon {
+    font-family: "IconFamily" !important;
     font-size: 16px;
     line-height: 1;
     opacity: 0.9;
   }
 
   .bsplus-cal-trigger-text {
+    font-family: inherit;
     font-size: 13px;
     font-weight: 600;
     line-height: 1;
@@ -680,7 +818,7 @@
     color: var(--bsplus-cal-text, #18181b);
     border: 1px solid var(--bsplus-cal-border, color-mix(in srgb, var(--bsplus-cal-text) 12%, transparent));
     box-shadow: 0 16px 40px rgba(0, 0, 0, 0.22);
-    font-family: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    font-family: var(--bsplus-cal-font-family, var(--betterseqta-font-family, Rubik), sans-serif);
   }
 
   .bsplus-cal-menu.dark {
@@ -710,6 +848,11 @@
     padding: 8px;
     border-radius: 10px;
     background: var(--bsplus-cal-surface-muted, color-mix(in srgb, var(--bsplus-cal-text) 4%, transparent));
+    margin-bottom: 8px;
+  }
+
+  .bsplus-cal-provider--outlook {
+    margin-bottom: 0;
   }
 
   .bsplus-cal-provider-row {

src/plugins/built-in/timetable/OutlookCalendarIcon.svelte

@@ -0,0 +1,231 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="60 90.4 570.02 539.67" aria-hidden="true">
+  <defs>
+    <linearGradient
+      id="bsplus-outlook-linear0"
+      gradientUnits="userSpaceOnUse"
+      x1="9.98908"
+      y1="22.364901"
+      x2="30.932199"
+      y2="9.37495"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0" style="stop-color:rgb(12.54902%,65.490196%,98.039216%);stop-opacity:1;" />
+      <stop offset="0.4" style="stop-color:rgb(23.137255%,83.529412%,100%);stop-opacity:1;" />
+      <stop offset="1" style="stop-color:rgb(76.862745%,69.019608%,100%);stop-opacity:1;" />
+    </linearGradient>
+    <linearGradient
+      id="bsplus-outlook-linear1"
+      gradientUnits="userSpaceOnUse"
+      x1="17.197201"
+      y1="26.7945"
+      x2="28.856199"
+      y2="8.12575"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0" style="stop-color:rgb(8.627451%,35.294118%,85.098039%);stop-opacity:1;" />
+      <stop offset="0.5008" style="stop-color:rgb(9.411765%,50.196078%,89.803922%);stop-opacity:1;" />
+      <stop offset="1" style="stop-color:rgb(52.156863%,52.941176%,100%);stop-opacity:1;" />
+    </linearGradient>
+    <linearGradient
+      id="bsplus-outlook-linear2"
+      gradientUnits="userSpaceOnUse"
+      x1="25.7005"
+      y1="27.048401"
+      x2="12.7563"
+      y2="16.501301"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0.236946" style="stop-color:rgb(26.666667%,54.117647%,100%);stop-opacity:0;" />
+      <stop offset="0.792113" style="stop-color:rgb(0%,19.607843%,69.411765%);stop-opacity:0.2;" />
+    </linearGradient>
+    <linearGradient
+      id="bsplus-outlook-linear3"
+      gradientUnits="userSpaceOnUse"
+      x1="24.0534"
+      y1="31.1099"
+      x2="44.509998"
+      y2="18.0177"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0" style="stop-color:rgb(10.196078%,26.27451%,65.098039%);stop-opacity:1;" />
+      <stop offset="0.492267" style="stop-color:rgb(12.54902%,32.156863%,79.607843%);stop-opacity:1;" />
+      <stop offset="1" style="stop-color:rgb(37.254902%,12.54902%,79.607843%);stop-opacity:1;" />
+    </linearGradient>
+    <linearGradient
+      id="bsplus-outlook-linear4"
+      gradientUnits="userSpaceOnUse"
+      x1="29.8281"
+      y1="30.327299"
+      x2="17.397499"
+      y2="19.570801"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0" style="stop-color:rgb(0%,27.058824%,72.54902%);stop-opacity:0;" />
+      <stop offset="0.669859" style="stop-color:rgb(5.098039%,12.156863%,41.176471%);stop-opacity:0.2;" />
+    </linearGradient>
+    <radialGradient
+      id="bsplus-outlook-radial0"
+      gradientUnits="userSpaceOnUse"
+      cx="0"
+      cy="0"
+      fx="0"
+      fy="0"
+      r="1"
+      gradientTransform="matrix(0.000000000000024802,-405.040512,438.393002,0.000000000000026844,360.027008,102.268202)"
+    >
+      <stop offset="0.568182" style="stop-color:rgb(15.294118%,37.254902%,94.117647%);stop-opacity:0;" />
+      <stop offset="0.992424" style="stop-color:rgb(0%,12.941176%,46.666667%);stop-opacity:1;" />
+    </radialGradient>
+    <linearGradient
+      id="bsplus-outlook-linear5"
+      gradientUnits="userSpaceOnUse"
+      x1="41.998001"
+      y1="29.9431"
+      x2="23.8517"
+      y2="29.9431"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0" style="stop-color:rgb(30.196078%,76.862745%,100%);stop-opacity:1;" />
+      <stop offset="0.196145" style="stop-color:rgb(5.882353%,68.627451%,100%);stop-opacity:1;" />
+    </linearGradient>
+    <radialGradient
+      id="bsplus-outlook-radial1"
+      gradientUnits="userSpaceOnUse"
+      cx="0"
+      cy="0"
+      fx="0"
+      fy="0"
+      r="1"
+      gradientTransform="matrix(122.73959,-122.73959,122.73959,122.73959,421.392002,568.675518)"
+    >
+      <stop offset="0.259477" style="stop-color:rgb(0%,37.647059%,81.960784%);stop-opacity:0.4;" />
+      <stop offset="0.908166" style="stop-color:rgb(1.176471%,51.372549%,94.509804%);stop-opacity:0;" />
+    </radialGradient>
+    <radialGradient
+      id="bsplus-outlook-radial2"
+      gradientUnits="userSpaceOnUse"
+      cx="0"
+      cy="0"
+      fx="0"
+      fy="0"
+      r="1"
+      gradientTransform="matrix(357.407022,-468.445926,423.594568,323.187085,159.471002,697.080002)"
+    >
+      <stop offset="0.732317" style="stop-color:rgb(95.686275%,65.490196%,96.862745%);stop-opacity:0;" />
+      <stop offset="1" style="stop-color:rgb(95.686275%,65.490196%,96.862745%);stop-opacity:0.501961;" />
+    </radialGradient>
+    <radialGradient
+      id="bsplus-outlook-radial3"
+      gradientUnits="userSpaceOnUse"
+      cx="0"
+      cy="0"
+      fx="0"
+      fy="0"
+      r="1"
+      gradientTransform="matrix(-170.860868,259.725406,-674.018133,-443.404152,278.562012,412.978506)"
+    >
+      <stop offset="0" style="stop-color:rgb(28.627451%,87.058824%,100%);stop-opacity:1;" />
+      <stop offset="0.724349" style="stop-color:rgb(16.078431%,76.470588%,100%);stop-opacity:1;" />
+    </radialGradient>
+    <linearGradient
+      id="bsplus-outlook-linear6"
+      gradientUnits="userSpaceOnUse"
+      x1="3.45756"
+      y1="37.872299"
+      x2="20.9291"
+      y2="37.859699"
+      gradientTransform="matrix(15,0,0,15,0,0)"
+    >
+      <stop offset="0.205882" style="stop-color:rgb(42.352941%,87.843137%,100%);stop-opacity:1;" />
+      <stop offset="0.535" style="stop-color:rgb(31.372549%,83.529412%,100%);stop-opacity:0;" />
+    </linearGradient>
+    <radialGradient
+      id="bsplus-outlook-radial4"
+      gradientUnits="userSpaceOnUse"
+      cx="0"
+      cy="0"
+      fx="0"
+      fy="0"
+      r="1"
+      gradientTransform="matrix(215.76719,230.769125,-230.769125,215.76719,59.143649,354.231005)"
+    >
+      <stop offset="0.038877" style="stop-color:rgb(0%,56.862745%,100%);stop-opacity:1;" />
+      <stop offset="0.919119" style="stop-color:rgb(9.411765%,23.921569%,67.843137%);stop-opacity:1;" />
+    </radialGradient>
+    <radialGradient
+      id="bsplus-outlook-radial5"
+      gradientUnits="userSpaceOnUse"
+      cx="0"
+      cy="0"
+      fx="0"
+      fy="0"
+      r="1"
+      gradientTransform="matrix(0.000000000000010287,167.999997,-193.782005,0.000000000000011866,180,491.158504)"
+    >
+      <stop offset="0.557796" style="stop-color:rgb(5.882353%,64.705882%,96.862745%);stop-opacity:0;" />
+      <stop offset="1" style="stop-color:rgb(45.490196%,77.647059%,100%);stop-opacity:0.501961;" />
+    </radialGradient>
+  </defs>
+  <g>
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear0);"
+      d="M 463.984375 140.144531 L 119.636719 358.414062 L 90.023438 311.695312 L 90.023438 271.4375 C 90.023438 256.78125 97.445312 243.121094 109.742188 235.144531 L 309.910156 105.257812 C 340.40625 85.46875 379.6875 85.464844 410.1875 105.25 Z M 463.984375 140.144531 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear1);"
+      d="M 407.101562 103.339844 C 408.136719 103.953125 409.164062 104.59375 410.183594 105.253906 L 566.398438 206.585938 L 179.0625 452.105469 L 119.625 358.335938 L 403.894531 177.800781 C 430.820312 160.699219 432 122.230469 407.101562 103.339844 Z M 407.101562 103.339844 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear2);"
+      d="M 407.101562 103.339844 C 408.136719 103.953125 409.164062 104.59375 410.183594 105.253906 L 566.398438 206.585938 L 179.0625 452.105469 L 119.625 358.335938 L 403.894531 177.800781 C 430.820312 160.699219 432 122.230469 407.101562 103.339844 Z M 407.101562 103.339844 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear3);"
+      d="M 333.601562 498.988281 L 179.066406 452.109375 L 507.628906 243.835938 C 535.300781 226.296875 535.230469 185.898438 507.496094 168.457031 L 506.015625 167.527344 L 510.277344 170.175781 L 610.273438 235.042969 C 622.574219 243.019531 629.996094 256.683594 629.996094 271.34375 L 629.996094 310.304688 Z M 333.601562 498.988281 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear4);"
+      d="M 333.601562 498.988281 L 179.066406 452.109375 L 507.628906 243.835938 C 535.300781 226.296875 535.230469 185.898438 507.496094 168.457031 L 506.015625 167.527344 L 510.277344 170.175781 L 610.273438 235.042969 C 622.574219 243.019531 629.996094 256.683594 629.996094 271.34375 L 629.996094 310.304688 Z M 333.601562 498.988281 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-radial0);"
+      d="M 410.1875 105.25 C 379.6875 85.464844 340.40625 85.46875 309.90625 105.257812 L 109.742188 235.144531 C 97.445312 243.121094 90.023438 256.78125 90.023438 271.4375 L 90.023438 273.40625 C 90.507812 288.121094 98.25 301.679688 110.757812 309.566406 L 359.644531 466.476562 L 609.160156 309.804688 C 622.121094 301.667969 629.984375 287.441406 629.984375 272.140625 L 629.984375 310.308594 L 629.992188 271.34375 C 629.992188 256.683594 622.566406 243.023438 610.269531 235.042969 Z M 410.1875 105.25 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear5);"
+      d="M 315.769531 630.050781 L 536.21875 630.050781 C 587.996094 630.050781 629.96875 588.078125 629.96875 536.300781 L 629.96875 272.140625 C 629.96875 287.441406 622.105469 301.667969 609.148438 309.804688 L 281.242188 515.695312 C 263.554688 526.804688 252.820312 546.222656 252.820312 567.109375 C 252.824219 601.871094 281.003906 630.050781 315.769531 630.050781 Z M 315.769531 630.050781 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-radial1);"
+      d="M 315.769531 630.050781 L 536.21875 630.050781 C 587.996094 630.050781 629.96875 588.078125 629.96875 536.300781 L 629.96875 272.140625 C 629.96875 287.441406 622.105469 301.667969 609.148438 309.804688 L 281.242188 515.695312 C 263.554688 526.804688 252.820312 546.222656 252.820312 567.109375 C 252.824219 601.871094 281.003906 630.050781 315.769531 630.050781 Z M 315.769531 630.050781 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-radial2);"
+      d="M 315.769531 630.050781 L 536.21875 630.050781 C 587.996094 630.050781 629.96875 588.078125 629.96875 536.300781 L 629.96875 272.140625 C 629.96875 287.441406 622.105469 301.667969 609.148438 309.804688 L 281.242188 515.695312 C 263.554688 526.804688 252.820312 546.222656 252.820312 567.109375 C 252.824219 601.871094 281.003906 630.050781 315.769531 630.050781 Z M 315.769531 630.050781 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-radial3);"
+      d="M 405.402344 630.035156 L 183.738281 630.035156 C 131.960938 630.035156 89.988281 588.0625 89.988281 536.285156 L 89.988281 271.945312 C 89.988281 287.21875 97.824219 301.421875 110.742188 309.566406 L 438.324219 516.085938 C 456.257812 527.390625 467.132812 547.113281 467.132812 568.3125 C 467.128906 602.402344 439.492188 630.035156 405.402344 630.035156 Z M 405.402344 630.035156 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-linear6);"
+      d="M 405.402344 630.035156 L 183.738281 630.035156 C 131.960938 630.035156 89.988281 588.0625 89.988281 536.285156 L 89.988281 271.945312 C 89.988281 287.21875 97.824219 301.421875 110.742188 309.566406 L 438.324219 516.085938 C 456.257812 527.390625 467.132812 547.113281 467.132812 568.3125 C 467.128906 602.402344 439.492188 630.035156 405.402344 630.035156 Z M 405.402344 630.035156 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-radial4);"
+      d="M 108.75 345 L 251.25 345 C 278.175781 345 300 366.824219 300 393.75 L 300 536.25 C 300 563.175781 278.175781 585 251.25 585 L 108.75 585 C 81.824219 585 60 563.175781 60 536.25 L 60 393.75 C 60 366.824219 81.824219 345 108.75 345 Z M 108.75 345 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:url(#bsplus-outlook-radial5);"
+      d="M 108.75 345 L 251.25 345 C 278.175781 345 300 366.824219 300 393.75 L 300 536.25 C 300 563.175781 278.175781 585 251.25 585 L 108.75 585 C 81.824219 585 60 563.175781 60 536.25 L 60 393.75 C 60 366.824219 81.824219 345 108.75 345 Z M 108.75 345 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;"
+      d="M 179.386719 534 C 159.539062 534 143.25 527.789062 130.511719 515.375 C 117.773438 502.960938 111.402344 486.757812 111.402344 466.769531 C 111.402344 445.660156 117.867188 428.589844 130.796875 415.550781 C 143.730469 402.515625 160.660156 396 181.59375 396 C 201.375 396 217.472656 402.238281 229.890625 414.714844 C 242.375 427.191406 248.617188 443.644531 248.617188 464.066406 C 248.617188 485.050781 242.148438 501.964844 229.21875 514.816406 C 216.351562 527.605469 199.742188 534 179.386719 534 Z M 179.960938 507.648438 C 190.777344 507.648438 199.484375 503.953125 206.078125 496.566406 C 212.671875 489.179688 215.96875 478.902344 215.96875 465.742188 C 215.96875 452.023438 212.765625 441.347656 206.367188 433.710938 C 199.964844 426.074219 191.417969 422.257812 180.730469 422.257812 C 169.71875 422.257812 160.851562 426.199219 154.132812 434.082031 C 147.410156 441.90625 144.050781 452.273438 144.050781 465.183594 C 144.050781 478.285156 147.410156 488.652344 154.132812 496.285156 C 160.851562 503.859375 169.460938 507.648438 179.960938 507.648438 Z M 179.960938 507.648438 "
+    />
+    <path
+      style="stroke:none;fill-rule:nonzero;fill:rgb(100%,100%,100%);fill-opacity:1;"
+      d="M 179.332031 535.847656 C 159.5625 535.847656 143.332031 529.472656 130.640625 516.71875 C 117.953125 503.964844 111.605469 487.320312 111.605469 466.789062 C 111.605469 445.105469 118.046875 427.570312 130.929688 414.179688 C 143.8125 400.785156 160.679688 394.089844 181.53125 394.089844 C 201.234375 394.089844 217.273438 400.5 229.644531 413.316406 C 242.082031 426.136719 248.296875 443.035156 248.296875 464.015625 C 248.296875 485.566406 241.855469 502.945312 228.976562 516.144531 C 216.15625 529.28125 199.609375 535.847656 179.332031 535.847656 Z M 179.902344 508.78125 C 190.679688 508.78125 199.355469 504.984375 205.921875 497.398438 C 212.492188 489.808594 215.773438 479.253906 215.773438 465.734375 C 215.773438 451.640625 212.585938 440.675781 206.210938 432.832031 C 199.832031 424.988281 191.320312 421.066406 180.671875 421.066406 C 169.699219 421.066406 160.867188 425.113281 154.171875 433.214844 C 147.476562 441.246094 144.128906 451.898438 144.128906 465.160156 C 144.128906 478.617188 147.476562 489.265625 154.171875 497.109375 C 160.867188 504.890625 169.445312 508.78125 179.902344 508.78125 Z M 179.902344 508.78125 "
+    />
+  </g>
+</svg>

src/plugins/built-in/timetable/calendarSyncHost.css

@@ -20,4 +20,5 @@
 
 .bsplus-calendar-sync-mount {
   display: inline-flex;
+  font-family: var(--bsplus-cal-font-family, var(--betterseqta-font-family, Rubik), sans-serif);
 }

src/plugins/built-in/timetable/calendarSyncTheme.ts

@@ -1,5 +1,7 @@
 import { settingsState } from "@/seqta/utils/listeners/SettingsState";
 import { extractSolidColor } from "@/seqta/ui/colors/parseCssColor";
+import { ensureFontLoaded } from "@/seqta/ui/fonts/Manager";
+import { getFontPreset } from "@/seqta/ui/fonts/presets";
 
 export const CALENDAR_THEME_CSS_VARS = [
   "--better-main",
@@ -42,6 +44,10 @@ function resolvePageAccentColor(): string {
 export function syncCalendarSyncTheme(target: HTMLElement): void {
   const computed = getComputedStyle(document.documentElement);
   const dark = isCalendarDarkMode();
+  const fontPreset = getFontPreset(settingsState.selectedFont);
+
+  ensureFontLoaded(fontPreset);
+  target.style.setProperty("--bsplus-cal-font-family", fontPreset.stack);
 
   for (const name of CALENDAR_THEME_CSS_VARS) {
     const value =

src/plugins/built-in/timetable/calendarSyncUi.ts

@@ -1,7 +1,7 @@
 import { mount, unmount } from "svelte";
 import CalendarSyncControl from "./CalendarSyncControl.svelte";
 import { syncCalendarSyncTheme } from "./calendarSyncTheme";
-import { registerGoogleCalendarContentHandlers } from "@/seqta/utils/googleCalendar/calendarSyncListener";
+import { registerCalendarContentHandlers } from "@/seqta/utils/googleCalendar/calendarSyncListener";
 import hostStyles from "./calendarSyncHost.css?inline";
 
 const CONTROLS_CLASS = "timetable-calendar-controls";
@@ -36,7 +36,7 @@ export async function mountGoogleCalendarButton(): Promise<void> {
   if (!toolbar) return;
 
   ensureHostStyles();
-  registerGoogleCalendarContentHandlers();
+  registerCalendarContentHandlers();
 
   const controls = document.createElement("div");
   controls.className = `${CONTROLS_CLASS} bsplus-timetable-control`;

src/seqta/utils/calendarSync/settings.ts

@@ -0,0 +1,65 @@
+import {
+  GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT,
+  GOOGLE_CALENDAR_SYNC_WEEKS_MAX,
+  GOOGLE_CALENDAR_SYNC_WEEKS_MIN,
+} from "@/config/googleCalendar";
+import { readOutlookCalendarState } from "@/seqta/utils/outlookCalendar/storage";
+import { readGoogleCalendarState } from "@/seqta/utils/googleCalendar/storage";
+import {
+  readSharedCalendarSyncSettings,
+  WEEKLY_SYNC_INTERVAL_MS,
+  writeSharedCalendarSyncSettings,
+} from "./sharedSettings";
+
+export { CALENDAR_WEEKLY_ALARM, WEEKLY_SYNC_INTERVAL_MS } from "./sharedSettings";
+
+export function clampSyncWeeks(weeks: number): number {
+  if (!Number.isFinite(weeks)) return GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT;
+  return Math.min(
+    GOOGLE_CALENDAR_SYNC_WEEKS_MAX,
+    Math.max(GOOGLE_CALENDAR_SYNC_WEEKS_MIN, Math.round(weeks)),
+  );
+}
+
+export async function getSyncWeeksAhead(): Promise<number> {
+  const settings = await readSharedCalendarSyncSettings();
+  return clampSyncWeeks(settings.syncWeeksAhead ?? GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT);
+}
+
+export async function getAutoSyncWeekly(): Promise<boolean> {
+  const settings = await readSharedCalendarSyncSettings();
+  return settings.autoSyncWeekly !== false;
+}
+
+async function isAnyCalendarConnected(): Promise<boolean> {
+  const [google, outlook] = await Promise.all([
+    readGoogleCalendarState(),
+    readOutlookCalendarState(),
+  ]);
+  return !!(
+    google.refreshToken ||
+    google.accessToken ||
+    outlook.refreshToken ||
+    outlook.accessToken
+  );
+}
+
+export async function shouldRunWeeklySync(): Promise<boolean> {
+  const settings = await readSharedCalendarSyncSettings();
+  if (settings.autoSyncWeekly === false) return false;
+  if (!(await isAnyCalendarConnected())) return false;
+  if (settings.pendingWeeklySync) return true;
+  const last = settings.lastWeeklySyncAt ?? 0;
+  return Date.now() - last >= WEEKLY_SYNC_INTERVAL_MS;
+}
+
+export async function markWeeklySyncComplete(): Promise<void> {
+  await writeSharedCalendarSyncSettings({
+    lastWeeklySyncAt: Date.now(),
+    pendingWeeklySync: false,
+  });
+}
+
+export async function markWeeklySyncPending(): Promise<void> {
+  await writeSharedCalendarSyncSettings({ pendingWeeklySync: true });
+}

src/seqta/utils/calendarSync/sharedSettings.ts

@@ -0,0 +1,48 @@
+import browser from "webextension-polyfill";
+import {
+  GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT,
+} from "@/config/googleCalendar";
+import { readGoogleCalendarState } from "@/seqta/utils/googleCalendar/storage";
+
+export const BSPLUS_CALENDAR_SYNC_SETTINGS_KEY = "bsplus_calendar_sync_settings";
+export const CALENDAR_WEEKLY_ALARM = "bsplus_calendar_weekly";
+export const WEEKLY_SYNC_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+
+export interface SharedCalendarSyncSettings {
+  syncWeeksAhead?: number;
+  autoSyncWeekly?: boolean;
+  lastWeeklySyncAt?: number;
+  pendingWeeklySync?: boolean;
+}
+
+export async function readSharedCalendarSyncSettings(): Promise<SharedCalendarSyncSettings> {
+  const got = await browser.storage.local.get(BSPLUS_CALENDAR_SYNC_SETTINGS_KEY);
+  const raw = got[BSPLUS_CALENDAR_SYNC_SETTINGS_KEY];
+  const shared =
+    raw && typeof raw === "object" && !Array.isArray(raw)
+      ? (raw as SharedCalendarSyncSettings)
+      : {};
+
+  if (Object.keys(shared).length > 0) return shared;
+
+  const legacy = await readGoogleCalendarState();
+  return {
+    syncWeeksAhead: legacy.syncWeeksAhead,
+    autoSyncWeekly: legacy.autoSyncWeekly,
+    lastWeeklySyncAt: legacy.lastWeeklySyncAt,
+    pendingWeeklySync: legacy.pendingWeeklySync,
+  };
+}
+
+export async function writeSharedCalendarSyncSettings(
+  patch: Partial<SharedCalendarSyncSettings>,
+): Promise<SharedCalendarSyncSettings> {
+  const current = await readSharedCalendarSyncSettings();
+  const next = { ...current, ...patch };
+  await browser.storage.local.set({ [BSPLUS_CALENDAR_SYNC_SETTINGS_KEY]: next });
+  return next;
+}
+
+export function defaultSyncWeeksAhead(): number {
+  return GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT;
+}

src/seqta/utils/googleCalendar/calendarSyncListener.ts

@@ -1,21 +1,51 @@
 import browser from "webextension-polyfill";
-import { shouldRunWeeklySync } from "@/seqta/utils/googleCalendar/syncSettings";
+import {
+  markWeeklySyncComplete,
+  shouldRunWeeklySync,
+} from "@/seqta/utils/calendarSync/settings";
 import {
   formatSyncResultMessage,
   runGoogleCalendarSync,
 } from "@/seqta/utils/googleCalendar/syncRunner";
+import {
+  formatOutlookSyncResultMessage,
+  runOutlookCalendarSync,
+} from "@/seqta/utils/outlookCalendar/syncRunner";
+import { readGoogleCalendarState } from "@/seqta/utils/googleCalendar/storage";
+import { readOutlookCalendarState } from "@/seqta/utils/outlookCalendar/storage";
 import type { GoogleCalendarSyncResult } from "@/seqta/utils/googleCalendar/types";
 
 let listenerRegistered = false;
 
-export function registerGoogleCalendarContentHandlers(): void {
+async function runWeeklySyncForConnectedProviders(): Promise<GoogleCalendarSyncResult[]> {
+  const [google, outlook] = await Promise.all([
+    readGoogleCalendarState(),
+    readOutlookCalendarState(),
+  ]);
+  const results: GoogleCalendarSyncResult[] = [];
+
+  if (google.refreshToken || google.accessToken) {
+    results.push(await runGoogleCalendarSync({ mode: "incremental", silent: true }));
+  }
+  if (outlook.refreshToken || outlook.accessToken) {
+    results.push(await runOutlookCalendarSync({ mode: "incremental", silent: true }));
+  }
+
+  if (results.some((r) => r.success)) {
+    await markWeeklySyncComplete();
+  }
+
+  return results;
+}
+
+export function registerCalendarContentHandlers(): void {
   if (listenerRegistered) return;
   listenerRegistered = true;
 
   browser.runtime.onMessage.addListener((request, _sender, sendResponse) => {
-    if (request?.type !== "googleCalendarRunWeeklySync") return false;
+    if (request?.type === "calendarRunWeeklySync" || request?.type === "googleCalendarRunWeeklySync") {
-    void runGoogleCalendarSync({ mode: "incremental", silent: true })
+      void runWeeklySyncForConnectedProviders()
-      .then((result: GoogleCalendarSyncResult) => sendResponse(result))
+        .then((results) => sendResponse({ success: true, results }))
         .catch((err: unknown) => {
           sendResponse({
             success: false,
@@ -23,6 +53,8 @@ export function registerGoogleCalendarContentHandlers(): void {
           });
         });
       return true;
+    }
+    return false;
   });
 }
 
@@ -31,17 +63,38 @@ export async function maybeRunDueWeeklySync(
 ): Promise<void> {
   if (!(await shouldRunWeeklySync())) return;
 
-  const result = await runGoogleCalendarSync({ mode: "incremental", silent: true });
+  const [google, outlook] = await Promise.all([
+    readGoogleCalendarState(),
+    readOutlookCalendarState(),
+  ]);
+  const results = await runWeeklySyncForConnectedProviders();
   if (!onComplete) return;
 
-  if (!result.success) {
+  const errors = results.filter((r) => !r.success);
-    onComplete(result.error ?? "Weekly calendar sync failed.", true);
+  if (errors.length > 0) {
+    onComplete(errors[0]?.error ?? "Weekly calendar sync failed.", true);
     return;
   }
 
+  const messages: string[] = [];
+  let index = 0;
+  if (google.refreshToken || google.accessToken) {
+    const result = results[index++];
     const changed =
       (result.created ?? 0) + (result.updated ?? 0) + (result.deleted ?? 0) > 0;
-  if (changed) {
+    if (changed) messages.push(formatSyncResultMessage(result));
-    onComplete(formatSyncResultMessage(result));
+  }
+  if (outlook.refreshToken || outlook.accessToken) {
+    const result = results[index++];
+    const changed =
+      (result.created ?? 0) + (result.updated ?? 0) + (result.deleted ?? 0) > 0;
+    if (changed) messages.push(formatOutlookSyncResultMessage(result));
+  }
+
+  if (messages.length > 0) {
+    onComplete(messages.join(" "));
   }
 }
+
+/** @deprecated use registerCalendarContentHandlers */
+export const registerGoogleCalendarContentHandlers = registerCalendarContentHandlers;

src/seqta/utils/googleCalendar/syncEngine.test.ts

@@ -15,7 +15,7 @@ jest.mock("@/seqta/utils/googleCalendar/storage", () => ({
   writeGoogleCalendarState: jest.fn(async (patch: unknown) => patch),
 }));
 
-jest.mock("@/seqta/utils/googleCalendar/syncSettings", () => ({
+jest.mock("@/seqta/utils/calendarSync/settings", () => ({
   getSyncWeeksAhead: jest.fn(async () => 12),
 }));
 

src/seqta/utils/googleCalendar/syncEngine.ts

@@ -10,7 +10,7 @@ import {
   isDateInRange,
   syncWindowRange,
 } from "@/seqta/utils/googleCalendar/syncDateRange";
-import { getSyncWeeksAhead } from "@/seqta/utils/googleCalendar/syncSettings";
+import { getSyncWeeksAhead } from "@/seqta/utils/calendarSync/settings";
 import {
   eventMapKey,
   readGoogleCalendarState,

src/seqta/utils/googleCalendar/syncRunner.ts

@@ -4,10 +4,7 @@ import {
   fetchTimetableLessons,
   trailingWeekRange,
 } from "@/seqta/utils/googleCalendar/fetchTimetable";
-import {
+import { getSyncWeeksAhead } from "@/seqta/utils/calendarSync/settings";
-  getSyncWeeksAhead,
-  markWeeklySyncComplete,
-} from "@/seqta/utils/googleCalendar/syncSettings";
 import { syncLessonsToGoogleCalendar } from "@/seqta/utils/googleCalendar/syncEngine";
 import type {
   GoogleCalendarSyncOptions,
@@ -63,10 +60,6 @@ export async function runGoogleCalendarSync(
     options,
   );
 
-  if (result.success && mode === "incremental") {
-    await markWeeklySyncComplete();
-  }
-
   return result;
 }
 

src/seqta/utils/googleCalendar/syncSettings.ts

@@ -1,57 +1,10 @@
-import {
+export {
-  GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT,
+  CALENDAR_WEEKLY_ALARM as GOOGLE_CALENDAR_WEEKLY_ALARM,
-  GOOGLE_CALENDAR_SYNC_WEEKS_MAX,
+  WEEKLY_SYNC_INTERVAL_MS,
-  GOOGLE_CALENDAR_SYNC_WEEKS_MIN,
+  clampSyncWeeks,
-} from "@/config/googleCalendar";
+  getAutoSyncWeekly,
-import { readGoogleCalendarState, writeGoogleCalendarState } from "./storage";
+  getSyncWeeksAhead,
-
+  markWeeklySyncComplete,
-export const GOOGLE_CALENDAR_WEEKLY_ALARM = "bsplus_google_calendar_weekly";
+  markWeeklySyncPending,
-export const WEEKLY_SYNC_INTERVAL_MS = 7 * 24 * 60 * 60 * 1000;
+  shouldRunWeeklySync,
-
+} from "@/seqta/utils/calendarSync/settings";
-export function clampSyncWeeks(weeks: number): number {
-  if (!Number.isFinite(weeks)) return GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT;
-  return Math.min(
-    GOOGLE_CALENDAR_SYNC_WEEKS_MAX,
-    Math.max(GOOGLE_CALENDAR_SYNC_WEEKS_MIN, Math.round(weeks)),
-  );
-}
-
-export async function getSyncWeeksAhead(): Promise<number> {
-  const state = await readGoogleCalendarState();
-  return clampSyncWeeks(state.syncWeeksAhead ?? GOOGLE_CALENDAR_SYNC_WEEKS_DEFAULT);
-}
-
-export async function setSyncWeeksAhead(weeks: number): Promise<number> {
-  const syncWeeksAhead = clampSyncWeeks(weeks);
-  await writeGoogleCalendarState({ syncWeeksAhead });
-  return syncWeeksAhead;
-}
-
-export async function getAutoSyncWeekly(): Promise<boolean> {
-  const state = await readGoogleCalendarState();
-  return state.autoSyncWeekly !== false;
-}
-
-export async function setAutoSyncWeekly(enabled: boolean): Promise<void> {
-  await writeGoogleCalendarState({ autoSyncWeekly: enabled });
-}
-
-export async function shouldRunWeeklySync(): Promise<boolean> {
-  const state = await readGoogleCalendarState();
-  if (!state.refreshToken && !state.accessToken) return false;
-  if (state.autoSyncWeekly === false) return false;
-  if (state.pendingWeeklySync) return true;
-  const last = state.lastWeeklySyncAt ?? state.lastSyncAt ?? 0;
-  return Date.now() - last >= WEEKLY_SYNC_INTERVAL_MS;
-}
-
-export async function markWeeklySyncComplete(): Promise<void> {
-  await writeGoogleCalendarState({
-    lastWeeklySyncAt: Date.now(),
-    pendingWeeklySync: false,
-  });
-}
-
-export async function markWeeklySyncPending(): Promise<void> {
-  await writeGoogleCalendarState({ pendingWeeklySync: true });
-}

src/seqta/utils/outlookCalendar/accountsToken.ts

@@ -0,0 +1,77 @@
+import {
+  OUTLOOK_CALENDAR_ACCOUNTS_NOT_READY_HINT,
+  OUTLOOK_CALENDAR_REFRESH_URL,
+  OUTLOOK_CALENDAR_TOKEN_URL,
+} from "@/config/outlookCalendar";
+
+type OutlookTokenPayload = {
+  access_token: string;
+  refresh_token?: string;
+  expires_in?: number;
+};
+
+async function parseAccountsJson(res: Response): Promise<Record<string, unknown>> {
+  const text = await res.text();
+  try {
+    return text ? (JSON.parse(text) as Record<string, unknown>) : {};
+  } catch {
+    return {};
+  }
+}
+
+function extractTokens(json: Record<string, unknown>): OutlookTokenPayload {
+  const access_token = json.access_token;
+  if (typeof access_token !== "string" || !access_token) {
+    throw new Error("Token response missing access_token");
+  }
+  return {
+    access_token,
+    refresh_token: typeof json.refresh_token === "string" ? json.refresh_token : undefined,
+    expires_in: typeof json.expires_in === "number" ? json.expires_in : undefined,
+  };
+}
+
+function formatAccountsTokenError(res: Response, json: Record<string, unknown>): string {
+  if (res.status === 404 || res.status === 501) {
+    return OUTLOOK_CALENDAR_ACCOUNTS_NOT_READY_HINT;
+  }
+  const err = typeof json.error === "string" ? json.error : "";
+  const desc = typeof json.error_description === "string" ? json.error_description : "";
+  return desc || err || `Accounts token API failed (${res.status})`;
+}
+
+export async function exchangeOutlookCodeViaAccounts(
+  code: string,
+  redirectUri: string,
+  codeVerifier: string,
+): Promise<OutlookTokenPayload> {
+  const res = await fetch(OUTLOOK_CALENDAR_TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      code,
+      redirect_uri: redirectUri,
+      code_verifier: codeVerifier,
+    }),
+  });
+  const json = await parseAccountsJson(res);
+  if (!res.ok) {
+    throw new Error(formatAccountsTokenError(res, json));
+  }
+  return extractTokens(json);
+}
+
+export async function refreshOutlookTokenViaAccounts(
+  refreshToken: string,
+): Promise<OutlookTokenPayload> {
+  const res = await fetch(OUTLOOK_CALENDAR_REFRESH_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ refresh_token: refreshToken }),
+  });
+  const json = await parseAccountsJson(res);
+  if (!res.ok) {
+    throw new Error(formatAccountsTokenError(res, json));
+  }
+  return extractTokens(json);
+}

src/seqta/utils/outlookCalendar/eventMapper.ts

@@ -0,0 +1,36 @@
+import { BSPLUS_OUTLOOK_CALENDAR_EVENT_CATEGORY } from "@/config/outlookCalendar";
+import type {
+  GoogleCalendarEventInput,
+  SeqtaTimetableLesson,
+} from "@/seqta/utils/googleCalendar/types";
+import {
+  lessonToGoogleEvent,
+  mapLessonsToGoogleEvents,
+} from "@/seqta/utils/googleCalendar/eventMapper";
+
+export { mapLessonsToGoogleEvents, lessonToGoogleEvent, seqtaLessonKey } from "@/seqta/utils/googleCalendar/eventMapper";
+
+export function outlookGraphEventBody(event: GoogleCalendarEventInput): Record<string, unknown> {
+  const body: Record<string, unknown> = {
+    subject: event.summary,
+    body: {
+      contentType: "text",
+      content: event.description ?? "Synced by BetterSEQTA+",
+    },
+    start: { dateTime: event.startDateTime, timeZone: event.timeZone },
+    end: { dateTime: event.endDateTime, timeZone: event.timeZone },
+    categories: [BSPLUS_OUTLOOK_CALENDAR_EVENT_CATEGORY],
+  };
+  if (event.location) {
+    body.location = { displayName: event.location };
+  }
+  return body;
+}
+
+export function mapLessonsToOutlookEvents(
+  origin: string,
+  lessons: SeqtaTimetableLesson[],
+  timeZone: string,
+): GoogleCalendarEventInput[] {
+  return mapLessonsToGoogleEvents(origin, lessons, timeZone);
+}

src/seqta/utils/outlookCalendar/storage.ts

@@ -0,0 +1,38 @@
+import browser from "webextension-polyfill";
+import type { GoogleCalendarEventMapEntry } from "@/seqta/utils/googleCalendar/eventMapEntry";
+
+export const BSPLUS_OUTLOOK_CALENDAR_STORAGE_KEY = "bsplus_outlook_calendar";
+
+export interface OutlookCalendarStoredState {
+  accessToken?: string;
+  refreshToken?: string;
+  expiresAt?: number;
+  connectedAt?: number;
+  lastSyncAt?: number;
+  lastSyncOrigin?: string;
+  eventMap?: Record<string, string | GoogleCalendarEventMapEntry>;
+}
+
+export async function readOutlookCalendarState(): Promise<OutlookCalendarStoredState> {
+  const got = await browser.storage.local.get(BSPLUS_OUTLOOK_CALENDAR_STORAGE_KEY);
+  const raw = got[BSPLUS_OUTLOOK_CALENDAR_STORAGE_KEY];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+  return raw as OutlookCalendarStoredState;
+}
+
+export async function writeOutlookCalendarState(
+  patch: Partial<OutlookCalendarStoredState>,
+): Promise<OutlookCalendarStoredState> {
+  const current = await readOutlookCalendarState();
+  const next: OutlookCalendarStoredState = { ...current, ...patch };
+  await browser.storage.local.set({ [BSPLUS_OUTLOOK_CALENDAR_STORAGE_KEY]: next });
+  return next;
+}
+
+export async function clearOutlookCalendarState(): Promise<void> {
+  await browser.storage.local.remove(BSPLUS_OUTLOOK_CALENDAR_STORAGE_KEY);
+}
+
+export function outlookEventMapKey(origin: string, seqtaKey: string): string {
+  return `${origin}::${seqtaKey}`;
+}

src/seqta/utils/outlookCalendar/syncEngine.ts

@@ -0,0 +1,348 @@
+import { verboseLog } from "@/utils/verboseLog";
+import { isOutlookCalendarConfigured } from "@/config/outlookCalendar";
+import { getSyncWeeksAhead } from "@/seqta/utils/calendarSync/settings";
+import {
+  getStoredEventId,
+  lessonDateFromSeqtaKey,
+  normalizeEventMapEntry,
+} from "@/seqta/utils/googleCalendar/eventMapEntry";
+import {
+  isDateInRange,
+  syncWindowRange,
+} from "@/seqta/utils/googleCalendar/syncDateRange";
+import type {
+  GoogleCalendarDeleteResult,
+  GoogleCalendarSyncOptions,
+  GoogleCalendarSyncProgress,
+  GoogleCalendarSyncRequest,
+  GoogleCalendarSyncResult,
+} from "@/seqta/utils/googleCalendar/types";
+import {
+  mapLessonsToOutlookEvents,
+  outlookGraphEventBody,
+} from "@/seqta/utils/outlookCalendar/eventMapper";
+import {
+  outlookEventMapKey,
+  readOutlookCalendarState,
+  writeOutlookCalendarState,
+} from "@/seqta/utils/outlookCalendar/storage";
+import {
+  deleteOutlookCalendarEvent,
+  upsertOutlookCalendarEvent,
+} from "@/seqta/utils/outlookCalendar/upsertEvent";
+
+const EVENT_MAP_PERSIST_EVERY = 10;
+
+type DeleteTrackedEventsResult = {
+  deleted: number;
+  failed: number;
+};
+
+function reportProgress(
+  onProgress: GoogleCalendarSyncOptions["onProgress"],
+  progress: GoogleCalendarSyncProgress,
+) {
+  onProgress?.(progress);
+}
+
+function lessonDateForEvent(startDateTime: string, seqtaKey: string): string {
+  return startDateTime.slice(0, 10) || lessonDateFromSeqtaKey(seqtaKey) || "";
+}
+
+async function deleteTrackedEventsFromOutlook(
+  entries: Array<[string, string]>,
+  eventMap: Record<string, string | { id: string; date: string }>,
+  getAccessToken: () => Promise<string>,
+  persistProgress = false,
+  onProgress?: GoogleCalendarSyncOptions["onProgress"],
+  progressOffset = 0,
+  progressTotal = 0,
+): Promise<DeleteTrackedEventsResult> {
+  if (entries.length === 0) return { deleted: 0, failed: 0 };
+
+  let accessToken = await getAccessToken();
+  let deleted = 0;
+  let failed = 0;
+
+  for (const [mapKey, eventId] of entries) {
+    try {
+      await deleteOutlookCalendarEvent(accessToken, eventId, async () => {
+        accessToken = await getAccessToken();
+        return accessToken;
+      });
+      delete eventMap[mapKey];
+      deleted += 1;
+
+      reportProgress(onProgress, {
+        phase: "deleting",
+        current: progressOffset + deleted + failed,
+        total: progressTotal,
+        message: `Removing old events (${deleted + failed}/${entries.length})…`,
+      });
+
+      if (persistProgress && (deleted + failed) % EVENT_MAP_PERSIST_EVERY === 0) {
+        await writeOutlookCalendarState({ eventMap });
+      }
+    } catch (err) {
+      verboseLog("[BetterSEQTA+] Outlook Calendar event delete failed:", err);
+      failed += 1;
+      reportProgress(onProgress, {
+        phase: "deleting",
+        current: progressOffset + deleted + failed,
+        total: progressTotal,
+        message: `Removing old events (${deleted + failed}/${entries.length})…`,
+      });
+    }
+  }
+
+  return { deleted, failed };
+}
+
+function originEventMapEntries(
+  eventMap: Record<string, string | { id: string; date: string }>,
+  origin: string,
+): Array<[string, string]> {
+  const prefix = `${origin}::`;
+  const entries: Array<[string, string]> = [];
+  for (const [key, value] of Object.entries(eventMap)) {
+    if (!key.startsWith(prefix)) continue;
+    const id = getStoredEventId(value);
+    if (id) entries.push([key, id]);
+  }
+  return entries;
+}
+
+function entriesToPrune(
+  eventMap: Record<string, string | { id: string; date: string }>,
+  origin: string,
+  mode: "full" | "incremental",
+  weeksAhead: number,
+  currentMapKeys: Set<string>,
+): Array<[string, string]> {
+  const window = syncWindowRange(weeksAhead);
+  const prefix = `${origin}::`;
+  const entries: Array<[string, string]> = [];
+
+  for (const [mapKey, raw] of Object.entries(eventMap)) {
+    if (!mapKey.startsWith(prefix)) continue;
+    const entry = normalizeEventMapEntry(raw);
+    if (!entry) continue;
+
+    let shouldDelete = false;
+    if (mode === "incremental") {
+      shouldDelete = false;
+    } else if (entry.date) {
+      shouldDelete = !isDateInRange(entry.date, window);
+    } else {
+      shouldDelete = !currentMapKeys.has(mapKey);
+    }
+
+    if (shouldDelete) entries.push([mapKey, entry.id]);
+  }
+
+  return entries;
+}
+
+export async function syncLessonsToOutlookCalendar(
+  request: GoogleCalendarSyncRequest,
+  getAccessToken: () => Promise<string>,
+  options: GoogleCalendarSyncOptions = {},
+): Promise<GoogleCalendarSyncResult> {
+  if (!isOutlookCalendarConfigured()) {
+    return {
+      success: false,
+      configured: false,
+      error: "Outlook Calendar is not configured in this extension build.",
+    };
+  }
+
+  const state = await readOutlookCalendarState();
+  if (!state.refreshToken && !state.accessToken) {
+    return { success: false, configured: true, connected: false, error: "Connect Outlook Calendar first." };
+  }
+
+  const mode = request.mode ?? "full";
+  const weeksAhead = request.weeksAhead ?? (await getSyncWeeksAhead());
+  const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  const events = mapLessonsToOutlookEvents(request.origin, request.lessons, timeZone);
+
+  if (events.length === 0 && mode === "full") {
+    return {
+      success: false,
+      configured: true,
+      connected: true,
+      error: "No timetable classes found to sync for the selected range.",
+    };
+  }
+
+  reportProgress(options.onProgress, {
+    phase: "preparing",
+    current: 0,
+    total: Math.max(events.length, 1),
+    message: mode === "incremental" ? "Preparing weekly sync…" : "Preparing sync…",
+  });
+
+  let accessToken = await getAccessToken();
+  const eventMap = { ...(state.eventMap ?? {}) };
+  const currentMapKeys = new Set(
+    events.map((event) => outlookEventMapKey(request.origin, event.seqtaKey)),
+  );
+  const staleEntries = entriesToPrune(eventMap, request.origin, mode, weeksAhead, currentMapKeys);
+  const totalSteps = staleEntries.length + events.length;
+
+  const staleResult = await deleteTrackedEventsFromOutlook(
+    staleEntries,
+    eventMap,
+    getAccessToken,
+    false,
+    options.onProgress,
+    0,
+    totalSteps,
+  );
+
+  let created = 0;
+  let updated = 0;
+  let failed = staleResult.failed;
+  const lastSyncAt = Date.now();
+
+  for (let i = 0; i < events.length; i++) {
+    const event = events[i];
+    const mapKey = outlookEventMapKey(request.origin, event.seqtaKey);
+    const existingId = getStoredEventId(eventMap[mapKey]);
+    try {
+      const outlookId = await upsertOutlookCalendarEvent(
+        accessToken,
+        existingId,
+        outlookGraphEventBody(event),
+        async () => {
+          accessToken = await getAccessToken();
+          return accessToken;
+        },
+      );
+      if (existingId) updated += 1;
+      else created += 1;
+      eventMap[mapKey] = {
+        id: outlookId,
+        date: lessonDateForEvent(event.startDateTime, event.seqtaKey),
+      };
+
+      reportProgress(options.onProgress, {
+        phase: "upserting",
+        current: staleEntries.length + i + 1,
+        total: totalSteps,
+        message: `Syncing events (${i + 1}/${events.length})…`,
+      });
+
+      if ((i + 1) % EVENT_MAP_PERSIST_EVERY === 0 || i === events.length - 1) {
+        await writeOutlookCalendarState({
+          eventMap,
+          lastSyncAt,
+          lastSyncOrigin: request.origin,
+        });
+      }
+    } catch (err) {
+      verboseLog("[BetterSEQTA+] Outlook Calendar event sync failed:", err);
+      failed += 1;
+      reportProgress(options.onProgress, {
+        phase: "upserting",
+        current: staleEntries.length + i + 1,
+        total: totalSteps,
+        message: `Syncing events (${i + 1}/${events.length})…`,
+      });
+    }
+  }
+
+  if (staleResult.deleted > 0 || staleEntries.length > 0 || events.length > 0) {
+    await writeOutlookCalendarState({
+      eventMap,
+      lastSyncAt,
+      lastSyncOrigin: request.origin,
+    });
+  }
+
+  reportProgress(options.onProgress, {
+    phase: "done",
+    current: totalSteps,
+    total: totalSteps,
+    message: "Sync complete",
+  });
+
+  return {
+    success: failed === 0,
+    configured: true,
+    connected: true,
+    created,
+    updated,
+    deleted: staleResult.deleted,
+    skipped: 0,
+    failed,
+    lastSyncAt,
+    error:
+      failed > 0
+        ? `Synced with ${failed} error${failed === 1 ? "" : "s"}. Check the console for details.`
+        : undefined,
+  };
+}
+
+export async function deleteSyncedEventsFromOutlookCalendar(
+  origin: string,
+  getAccessToken: () => Promise<string>,
+  options: GoogleCalendarSyncOptions = {},
+): Promise<GoogleCalendarDeleteResult> {
+  if (!isOutlookCalendarConfigured()) {
+    return {
+      success: false,
+      configured: false,
+      error: "Outlook Calendar is not configured in this extension build.",
+    };
+  }
+
+  const state = await readOutlookCalendarState();
+  if (!state.refreshToken && !state.accessToken) {
+    return { success: false, configured: true, connected: false, error: "Connect Outlook Calendar first." };
+  }
+
+  const entries = originEventMapEntries(state.eventMap ?? {}, origin);
+  if (entries.length === 0) {
+    return { success: true, configured: true, connected: true, deleted: 0, failed: 0 };
+  }
+
+  reportProgress(options.onProgress, {
+    phase: "preparing",
+    current: 0,
+    total: entries.length,
+    message: "Preparing removal…",
+  });
+
+  const eventMap = { ...(state.eventMap ?? {}) };
+  const { deleted, failed } = await deleteTrackedEventsFromOutlook(
+    entries,
+    eventMap,
+    getAccessToken,
+    true,
+    options.onProgress,
+    0,
+    entries.length,
+  );
+
+  await writeOutlookCalendarState({ eventMap });
+
+  reportProgress(options.onProgress, {
+    phase: "done",
+    current: entries.length,
+    total: entries.length,
+    message: "Removal complete",
+  });
+
+  return {
+    success: failed === 0,
+    configured: true,
+    connected: true,
+    deleted,
+    failed,
+    error:
+      failed > 0
+        ? `Removed ${deleted} event${deleted === 1 ? "" : "s"} with ${failed} error${failed === 1 ? "" : "s"}.`
+        : undefined,
+  };
+}

src/seqta/utils/outlookCalendar/syncRunner.ts

@@ -0,0 +1,76 @@
+import browser from "webextension-polyfill";
+import {
+  fetchTimetableForSync,
+  fetchTimetableLessons,
+  trailingWeekRange,
+} from "@/seqta/utils/googleCalendar/fetchTimetable";
+import { getSyncWeeksAhead } from "@/seqta/utils/calendarSync/settings";
+import { syncLessonsToOutlookCalendar } from "@/seqta/utils/outlookCalendar/syncEngine";
+import type {
+  GoogleCalendarSyncOptions,
+  GoogleCalendarSyncProgress,
+  GoogleCalendarSyncResult,
+} from "@/seqta/utils/googleCalendar/types";
+
+export type OutlookCalendarRunMode = "full" | "incremental";
+
+export interface RunOutlookCalendarSyncParams {
+  mode?: OutlookCalendarRunMode;
+  silent?: boolean;
+  onProgress?: (progress: GoogleCalendarSyncProgress) => void;
+}
+
+async function getAccessTokenFromBackground(): Promise<string> {
+  const res = (await browser.runtime.sendMessage({
+    type: "outlookCalendarGetAccessToken",
+  })) as { success?: boolean; accessToken?: string; error?: string };
+  if (!res?.success || !res.accessToken) {
+    throw new Error(res?.error ?? "Could not get Outlook Calendar access token.");
+  }
+  return res.accessToken;
+}
+
+export async function runOutlookCalendarSync(
+  params: RunOutlookCalendarSyncParams = {},
+): Promise<GoogleCalendarSyncResult> {
+  const mode = params.mode ?? "full";
+  const weeksAhead = await getSyncWeeksAhead();
+
+  params.onProgress?.({
+    phase: "preparing",
+    current: 0,
+    total: 1,
+    message: mode === "incremental" ? "Fetching new week…" : "Fetching timetable…",
+  });
+
+  const lessons =
+    mode === "incremental"
+      ? await fetchTimetableLessons(trailingWeekRange(weeksAhead))
+      : await fetchTimetableForSync(weeksAhead);
+
+  const options: GoogleCalendarSyncOptions = { onProgress: params.onProgress };
+  const result = await syncLessonsToOutlookCalendar(
+    {
+      origin: location.origin,
+      lessons,
+      mode,
+      weeksAhead,
+    },
+    getAccessTokenFromBackground,
+    options,
+  );
+
+  return result;
+}
+
+export function formatOutlookSyncResultMessage(result: GoogleCalendarSyncResult): string {
+  const created = result.created ?? 0;
+  const updated = result.updated ?? 0;
+  const deleted = result.deleted ?? 0;
+  const parts: string[] = [];
+  if (created > 0) parts.push(`${created} new`);
+  if (updated > 0) parts.push(`${updated} updated`);
+  if (deleted > 0) parts.push(`${deleted} removed`);
+  if (parts.length === 0) return "Outlook Calendar is up to date.";
+  return `Outlook Calendar updated (${parts.join(", ")}).`;
+}

src/seqta/utils/outlookCalendar/types.ts

@@ -0,0 +1,6 @@
+export interface OutlookCalendarStatus {
+  configured: boolean;
+  connected: boolean;
+  lastSyncAt?: number;
+  lastSyncOrigin?: string;
+}

src/seqta/utils/outlookCalendar/upsertEvent.test.ts

@@ -0,0 +1,48 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import { upsertOutlookCalendarEvent, deleteOutlookCalendarEvent } from "./upsertEvent";
+
+const fetchMock = jest.fn();
+global.fetch = fetchMock as unknown as typeof fetch;
+
+describe("upsertOutlookCalendarEvent", () => {
+  beforeEach(() => {
+    fetchMock.mockReset();
+  });
+
+  it("creates a new event when no existing id", async () => {
+    fetchMock.mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: async () => ({ id: "evt-1" }),
+    });
+
+    const id = await upsertOutlookCalendarEvent("token", undefined, { subject: "Math" });
+    expect(id).toBe("evt-1");
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://graph.microsoft.com/v1.0/me/events",
+      expect.objectContaining({ method: "POST" }),
+    );
+  });
+
+  it("patches when an existing id is provided", async () => {
+    fetchMock.mockResolvedValue({ ok: true, status: 200, json: async () => ({}) });
+
+    const id = await upsertOutlookCalendarEvent("token", "evt-1", { subject: "Math" });
+    expect(id).toBe("evt-1");
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://graph.microsoft.com/v1.0/me/events/evt-1",
+      expect.objectContaining({ method: "PATCH" }),
+    );
+  });
+});
+
+describe("deleteOutlookCalendarEvent", () => {
+  beforeEach(() => {
+    fetchMock.mockReset();
+  });
+
+  it("treats 404 as success", async () => {
+    fetchMock.mockResolvedValue({ ok: false, status: 404, json: async () => ({}) });
+    await expect(deleteOutlookCalendarEvent("token", "evt-1")).resolves.toBeUndefined();
+  });
+});

src/seqta/utils/outlookCalendar/upsertEvent.ts

@@ -0,0 +1,68 @@
+import { OUTLOOK_GRAPH_API } from "@/config/outlookCalendar";
+
+export async function upsertOutlookCalendarEvent(
+  accessToken: string,
+  existingEventId: string | undefined,
+  body: Record<string, unknown>,
+  refreshAccessToken?: () => Promise<string>,
+): Promise<string> {
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+  };
+
+  if (existingEventId) {
+    const res = await fetch(`${OUTLOOK_GRAPH_API}/me/events/${encodeURIComponent(existingEventId)}`, {
+      method: "PATCH",
+      headers,
+      body: JSON.stringify(body),
+    });
+    if (res.status === 401 && refreshAccessToken) {
+      const nextToken = await refreshAccessToken();
+      return upsertOutlookCalendarEvent(nextToken, existingEventId, body);
+    }
+    if (res.ok) return existingEventId;
+    if (res.status !== 404) {
+      const err = (await res.json().catch(() => ({}))) as {
+        error?: { message?: string };
+      };
+      throw new Error(err?.error?.message ?? `Outlook Calendar update failed (${res.status})`);
+    }
+  }
+
+  const res = await fetch(`${OUTLOOK_GRAPH_API}/me/events`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  if (res.status === 401 && refreshAccessToken) {
+    const nextToken = await refreshAccessToken();
+    return upsertOutlookCalendarEvent(nextToken, undefined, body);
+  }
+  const json = (await res.json().catch(() => ({}))) as {
+    id?: string;
+    error?: { message?: string };
+  };
+  if (!res.ok || !json.id) {
+    throw new Error(json?.error?.message ?? `Outlook Calendar create failed (${res.status})`);
+  }
+  return json.id;
+}
+
+export async function deleteOutlookCalendarEvent(
+  accessToken: string,
+  eventId: string,
+  refreshAccessToken?: () => Promise<string>,
+): Promise<void> {
+  const res = await fetch(`${OUTLOOK_GRAPH_API}/me/events/${encodeURIComponent(eventId)}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+  if (res.status === 401 && refreshAccessToken) {
+    const nextToken = await refreshAccessToken();
+    return deleteOutlookCalendarEvent(nextToken, eventId);
+  }
+  if (res.ok || res.status === 404 || res.status === 410) return;
+  const err = (await res.json().catch(() => ({}))) as { error?: { message?: string } };
+  throw new Error(err?.error?.message ?? `Outlook Calendar delete failed (${res.status})`);
+}

vite.config.ts

@@ -80,6 +80,7 @@ export default defineConfig(({ command, mode: viteMode }) => {
     __UPDATE_CHANNEL__: JSON.stringify(process.env.UPDATE_CHANNEL ?? "stable"),
     __BUILD_LABEL__: JSON.stringify(process.env.BUILD_LABEL ?? ""),
     __GOOGLE_OAUTH_CLIENT_ID__: JSON.stringify(env.GOOGLE_OAUTH_CLIENT_ID ?? ""),
+    __OUTLOOK_OAUTH_CLIENT_ID__: JSON.stringify(env.OUTLOOK_OAUTH_CLIENT_ID ?? ""),
   },
   envDir: repoRoot,
   plugins: [