fix(calendar): propagate event-link priority through same-batch merge

processCalendarEventsFn/processOutlookEventsFn coalesce same-source links
within one sync batch via addLink(), but the merge didn't copy `priority`.
Recurring-event instance/exception links never set a priority; when an
instance is coalesced before its master in the same batch, the merged
link's priority ended up undefined (server default 0), letting a bundled
email tie/win primacy depending on ordering within the page.

Fix: addLink() now sets priority = max(existing, incoming), so the
master's floor (>= 1) survives regardless of instance-vs-master order.
Adds a regression test per connector proving a same-batch, instance-
before-master pair coalesces to priority >= 1.

Author: KrisBraun

connectors/google-calendar/src/sync.test.ts

@@ -1647,4 +1647,54 @@ describe("processCalendarEventsFn — event link priority", () => {
       .find((l) => l.source === "google-calendar:uid-cancelled");
     expect(link?.priority).toBe(1);
   });
+
+  it("floors the coalesced priority when a recurring instance is merged before its master in the same batch", async () => {
+    // Regression test: addLink() coalesces same-source links within one
+    // sync batch but previously didn't propagate `priority`. Recurring
+    // instance/exception links never set `priority` at all, so when an
+    // instance is processed (and becomes the batch's `existing` entry)
+    // before its master arrives, the merge left `existing.priority`
+    // `undefined` (-> server default 0) even though the master carries a
+    // floor of >= 1 — letting a bundled email tie/win primacy depending on
+    // event-vs-instance ordering within the page.
+    const host = makeFakeHost({ calendarId });
+    vi.stubGlobal("fetch", vi.fn(async () => makeEventsResponse([])));
+
+    // Instance/exception link — no `iCalUID`, so it falls back to
+    // `recurringEventId` for its canonical (master) source, and it carries
+    // no `priority` field at all.
+    const instance = {
+      id: "instance-1",
+      recurringEventId: "master-1",
+      originalStartTime: { dateTime: isoDaysFromNow(2) },
+      status: "confirmed" as const,
+      start: { dateTime: isoDaysFromNow(2) },
+      end: { dateTime: isoDaysFromNow(2) },
+    };
+
+    // Master — no `iCalUID` either, so its canonical source is
+    // `google-calendar:master-1`, matching the instance's fallback above.
+    // Organizer is someone else and there are no attendees, so this floors
+    // to priority 1 (the lowest non-zero floor).
+    const master = {
+      id: "master-1",
+      status: "confirmed" as const,
+      summary: "Recurring sync",
+      organizer: { email: "boss@x.com", self: false },
+      attendees: [],
+      start: { dateTime: isoDaysFromNow(1) },
+      end: { dateTime: isoDaysFromNow(1) },
+    };
+
+    // Instance BEFORE master, in one batch — the exact ordering that
+    // previously dropped the priority floor.
+    await processCalendarEventsFn(host, [instance, master], calendarId, false);
+
+    const saved = host.savedLinks.flat();
+    // Coalesced onto a single link, not two.
+    expect(saved.filter((l) => l.source === "google-calendar:master-1")).toHaveLength(1);
+
+    const link = saved.find((l) => l.source === "google-calendar:master-1");
+    expect(link?.priority).toBeGreaterThanOrEqual(1);
+  });
 });

connectors/google-calendar/src/sync.ts

@@ -644,6 +644,11 @@ export async function processCalendarEventsFn(
       existing.meta = { ...(existing.meta || {}), ...(link.meta || {}) };
       if (link.unread !== undefined) existing.unread = link.unread;
       if (link.archived !== undefined) existing.archived = link.archived;
+      // Never let the merge LOWER an already-set priority. Recurring-event
+      // instance links carry no priority; when an instance is coalesced
+      // before its master in the same batch, this floor ensures the
+      // master's priority (>= 1) survives regardless of ordering.
+      existing.priority = Math.max(existing.priority ?? 0, link.priority ?? 0);
     }
   };
 

connectors/outlook-calendar/src/sync.test.ts

@@ -331,4 +331,49 @@ describe("processOutlookEventsFn — event link priority", () => {
       .find((l) => l.source === `outlook-calendar:${calendarId}:e2`);
     expect(link?.priority).toBeGreaterThanOrEqual(1);
   });
+
+  it("floors the coalesced priority when a recurring instance is merged before its master in the same batch", async () => {
+    // Regression test: addLink() coalesces same-source links within one
+    // sync batch but previously didn't propagate `priority`. Recurring
+    // instance/exception links never set `priority` at all, so when an
+    // instance is processed (and becomes the batch's `existing` entry)
+    // before its master arrives, the merge left `existing.priority`
+    // `undefined` (-> server default 0) even though the master carries a
+    // constant floor of 1 — letting a bundled email tie/win primacy
+    // depending on event-vs-instance ordering within the page.
+    const host = makeFakeHost();
+
+    const instance = outlookEventFixture({
+      id: "instance-1",
+      type: "occurrence",
+      seriesMasterId: "master-1",
+      originalStart: isoDaysFromNow(2),
+    });
+
+    const master = outlookEventFixture({
+      id: "master-1",
+      subject: "Recurring sync",
+      organizer: { emailAddress: { address: "org@x.com", name: "Org" } },
+      attendees: [
+        { emailAddress: { address: "bob@x.com" }, type: "required" },
+      ],
+    });
+
+    // Instance BEFORE master, in one batch — the exact ordering that
+    // previously dropped the priority floor.
+    await processOutlookEventsFn(
+      host,
+      [instance, master],
+      calendarId,
+      false
+    );
+
+    const saved = host.savedLinks.flat();
+    const masterSource = `outlook-calendar:${calendarId}:master-1`;
+    // Coalesced onto a single link, not two.
+    expect(saved.filter((l) => l.source === masterSource)).toHaveLength(1);
+
+    const link = saved.find((l) => l.source === masterSource);
+    expect(link?.priority).toBeGreaterThanOrEqual(1);
+  });
 });

connectors/outlook-calendar/src/sync.ts

@@ -701,6 +701,11 @@ export async function processOutlookEventsFn(
       existing.meta = { ...(existing.meta || {}), ...(link.meta || {}) };
       if (link.unread !== undefined) existing.unread = link.unread;
       if (link.archived !== undefined) existing.archived = link.archived;
+      // Never let the merge LOWER an already-set priority. Recurring-event
+      // instance links carry no priority; when an instance is coalesced
+      // before its master in the same batch, this floor ensures the
+      // master's priority (>= 1) survives regardless of ordering.
+      existing.priority = Math.max(existing.priority ?? 0, link.priority ?? 0);
     }
   };