@wirecat/cli-core 0.454.0 → 0.456.0

package/dist/meetings/event-store.d.ts

@@ -1,12 +1,23 @@
 import type { Event } from "./model.js";
+/** RFC 5545 PARTSTAT: a participant's answer, and the owner's own. */
+export type ParticipantResponse = "needs-action" | "accepted" | "tentative" | "declined" | "delegated";
+/** What kind of entry it is. Only `default` and `from-mail` are searched (requirements 3.4). */
+export type EntryEventType = "default" | "out-of-office" | "focus" | "working-location" | "birthday" | "from-mail";
+/** RFC 5545 TRANSP. */
+export type EntryTransparency = "opaque" | "transparent";
+/** RFC 5545 CLASS, plus `default`: the calendar's own setting. */
+export type EntryVisibility = "default" | "public" | "private" | "confidential";
+/** What the owner may do with a calendar: `free-busy` sees only busy slots. */
+export type CalendarAccessRole = "owner" | "writer" | "reader" | "free-busy";
 /** One calendar as a provider lists it. */
 export interface CalendarInput {
     externalId: string;
     title: string | null;
     timezone: string | null;
-    /** owner, writer, reader, freeBusyReader. A calendar the owner owns syncs by default. */
-    accessRole: string | null;
+    accessRole: CalendarAccessRole | null;
     primary: boolean;
+    /** Whether a calendar seen for the first time syncs; the adapter decides. Later lists leave `synced` alone. */
+    syncByDefault: boolean;
 }
 export interface StoredCalendar {
     id: number;
@@ -14,7 +25,7 @@ export interface StoredCalendar {
     externalId: string;
     title: string | null;
     timezone: string | null;
-    accessRole: string | null;
+    accessRole: CalendarAccessRole | null;
     primary: boolean;
     synced: boolean;
     seenAt: number | null;
@@ -23,7 +34,7 @@ export interface StoredCalendar {
 export interface EntryParticipantInput {
     email: string;
     name?: string | null;
-    response?: string | null;
+    response?: ParticipantResponse | null;
     optional?: boolean;
     organizer?: boolean;
     self?: boolean;
@@ -53,10 +64,11 @@ export type EntryStatus = "confirmed" | "tentative" | "cancelled";
 export interface EntryInput {
     externalId: string;
     kind: EntryKind;
-    /** An occurrence's series, by the series entry's `externalId` (Google's `recurringEventId`). */
+    /** An occurrence's series, by the series entry's `externalId`. */
     seriesExternalId?: string | null;
+    /** The RFC 5545 UID of the series: the same on the series and every occurrence, and across calendars. */
     icalUid?: string | null;
-    /** An occurrence's slot in its series (Google's `originalStartTime`). */
+    /** An occurrence's slot in its series, as first scheduled; an all-day slot is midnight UTC of its date. */
     originalStartsAt?: number | null;
     exception?: boolean;
     status: EntryStatus;
@@ -72,10 +84,10 @@ export interface EntryInput {
     recurrence?: string[] | null;
     /** A series' last slot; `null` repeats indefinitely. */
     recurrenceEndsAt?: number | null;
-    eventType?: string | null;
-    transparency?: string | null;
-    visibility?: string | null;
-    ownResponse?: string | null;
+    eventType?: EntryEventType | null;
+    transparency?: EntryTransparency | null;
+    visibility?: EntryVisibility | null;
+    ownResponse?: ParticipantResponse | null;
     organizer?: {
         email: string;
         name?: string | null;
@@ -101,6 +113,8 @@ export interface StoredEntry {
     calendarId: number;
     kind: EntryKind;
     seriesEntryId: number | null;
+    /** On an occurrence: its series' `externalId`, also before that series is stored. */
+    seriesExternalId: string | null;
     eventId: number | null;
     eventSeriesId: number | null;
     externalId: string;
@@ -119,8 +133,8 @@ export interface StoredEntry {
     timezone: string | null;
     recurrence: string[] | null;
     recurrenceEndsAt: number | null;
-    eventType: string | null;
-    ownResponse: string | null;
+    eventType: EntryEventType | null;
+    ownResponse: ParticipantResponse | null;
     organizerIdentityId: number | null;
     joinUrl: string | null;
     joinKey: string | null;
@@ -134,7 +148,7 @@ export interface StoredParticipant {
     identityId: number | null;
     email: string;
     name: string | null;
-    response: string | null;
+    response: ParticipantResponse | null;
     optional: boolean;
     organizer: boolean;
     self: boolean;
@@ -205,13 +219,26 @@ export interface EventStore {
     /** One sync page, matched by rules 1–5, in one transaction. */
     saveEntries(calendarId: number, entries: EntryInput[], now: number): Promise<StoredEntry[]>;
     /**
-     * After a full list (`410 Gone`): entries not seen since `seenBefore` get `deleted_at`. Plain occurrences come only
-     * from the window fetched, so only those inside it count. Events, series and links stay.
+     * Entries the provider confirmed deleted and names only by id, cancelled as a cancelled entry would be: past events
+     * stay as history, future ones cancel, a series cancels its occurrences. Unknown ids are skipped; the count is of
+     * entries cancelled now.
+     */
+    removeEntries(calendarId: number, externalIds: string[], now: number): Promise<number>;
+    /**
+     * After a full list: entries not seen since `seenBefore` get `deleted_at`. Plain occurrences come only from the
+     * window fetched, so only those inside it count. Events, series and links stay.
      */
     markUnseen(calendarId: number, seenBefore: number, window: {
         from: number;
         to: number;
     }, now: number): Promise<number>;
+    /**
+     * Where the calendar's last sync stopped, as the sync engine wrote it (`{"v":1,"token":…,"window":…,"fullAt":…}`),
+     * or `null` before the first one.
+     */
+    cursor(calendarId: number): Promise<string | null>;
+    /** `null` forgets the cursor, so the next sync is a full list. */
+    setCursor(calendarId: number, value: string | null, now: number): Promise<void>;
     events(filter?: EventFilter): Promise<Event[]>;
     event(id: number): Promise<EventDetails | null>;
     /** The owner's link of an entry to an event; no rule replaces it. */

package/dist/meetings/index.d.ts

@@ -4,7 +4,7 @@ export { calendarText, ENTRY_METADATA_KEYS, entryMetadata, withoutLinkQueries }
 export type { MeetingContextStore, MeetingEventLinkInput, MeetingEventLinkReceipt, ParticipantPerson, ParticipantPersonInput, ParticipantPersonLinkInput, ParticipantPersonLinkReceipt, } from "./context-store.js";
 export { type MeetingCueIdentity, meetingCueFingerprint } from "./cue-fingerprint.js";
 export { EVENT_QUERY } from "./event-query.js";
-export type { CalendarInput, EntryAttachment, EntryAttachmentInput, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EventDetails, EventFilter, EventStore, LinkReview, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "./event-store.js";
+export type { CalendarAccessRole, CalendarInput, EntryAttachment, EntryAttachmentInput, EntryEventType, EntryInput, EntryKind, EntryParticipantInput, EntryRevision, EntryStatus, EntryTransparency, EntryVisibility, EventDetails, EventFilter, EventStore, LinkReview, ParticipantResponse, ReviewDecision, StoredCalendar, StoredEntry, StoredParticipant, } from "./event-store.js";
 export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";

package/dist/meetings/testing/event-store-contract.js

@@ -16,20 +16,73 @@ export const eventStoreContract = (make) => {
         name,
         async run() {
             const fixture = await make();
-            const [calendar] = await fixture.store.saveCalendars(fixture.accountId, [{ externalId: "primary", title: "Work", timezone: "UTC", accessRole: "owner", primary: true }], 1);
+            const [calendar] = await fixture.store.saveCalendars(fixture.accountId, [
+                {
+                    externalId: "primary",
+                    title: "Work",
+                    timezone: "UTC",
+                    accessRole: "owner",
+                    primary: true,
+                    syncByDefault: true,
+                },
+            ], 1);
             await check({ ...fixture, calendar: calendar.id });
         },
     });
-    const second = async ({ store, accountId }, externalId = "personal") => (await store.saveCalendars(accountId, [{ externalId, title: externalId, timezone: "UTC", accessRole: "owner", primary: false }], 1))[0].id;
+    const second = async ({ store, accountId }, externalId = "personal") => (await store.saveCalendars(accountId, [
+        {
+            externalId,
+            title: externalId,
+            timezone: "UTC",
+            accessRole: "owner",
+            primary: false,
+            syncByDefault: true,
+        },
+    ], 1))[0].id;
     const later = CONTRACT_NOW + 24 * HOUR;
     const earlier = CONTRACT_NOW - 24 * HOUR;
     return [
-        test("a calendar the owner owns syncs; one shared with them is listed and does not", async ({ store, accountId, }) => {
-            await store.saveCalendars(accountId, [{ externalId: "team", title: "Team", timezone: null, accessRole: "reader", primary: false }], 2);
+        test("a new calendar syncs as its adapter decides, and a later list keeps the owner's choice", async ({ store, accountId, }) => {
+            await store.saveCalendars(accountId, [
+                {
+                    externalId: "team",
+                    title: "Team",
+                    timezone: null,
+                    accessRole: "reader",
+                    primary: false,
+                    syncByDefault: false,
+                },
+            ], 2);
             assert.deepEqual((await store.calendars(accountId)).map(({ externalId, synced }) => [externalId, synced]), [
                 ["primary", true],
                 ["team", false],
             ]);
+            const team = (await store.calendars(accountId)).find(({ externalId }) => externalId === "team");
+            await store.setCalendarSynced(team?.id, true, 3);
+            await store.saveCalendars(accountId, [
+                {
+                    externalId: "team",
+                    title: "Team",
+                    timezone: null,
+                    accessRole: "free-busy",
+                    primary: false,
+                    syncByDefault: false,
+                },
+            ], 4);
+            const again = (await store.calendars(accountId)).find(({ externalId }) => externalId === "team");
+            assert.deepEqual([again?.synced, again?.accessRole], [true, "free-busy"]);
+        }),
+        test("calendar words are kept in their neutral spelling", async ({ store, calendar }) => {
+            const [entry] = await store.saveEntries(calendar, [
+                single("ooo", later, {
+                    eventType: "out-of-office",
+                    ownResponse: "needs-action",
+                    participants: [{ email: "alice@example.com", response: "delegated" }],
+                }),
+            ], 2);
+            assert.deepEqual([entry?.eventType, entry?.ownResponse], ["out-of-office", "needs-action"]);
+            const details = await store.event(entry?.eventId);
+            assert.equal(details?.participants[0]?.response, "delegated");
         }),
         test("rule 1: the same calendar and id is the same entry; a change keeps the old values", async ({ store, calendar, }) => {
             const [first] = await store.saveEntries(calendar, [single("e1", later)], 2);
@@ -124,6 +177,32 @@ export const eventStoreContract = (make) => {
             const after = await store.event(future?.eventId);
             assert.equal(after?.event.status, "cancelled");
         }),
+        test("entries removed by id: past stays as history, future cancels, a series cancels its slots", async ({ store, calendar, }) => {
+            const series = { ...single("s", earlier - HOUR), kind: "series", recurrence: ["RRULE:FREQ=DAILY"] };
+            const slot = (at) => single(`s_${at}`, at, { kind: "occurrence", seriesExternalId: "s", originalStartsAt: at });
+            const [past, future, , , slotLater] = await store.saveEntries(calendar, [single("p", earlier), single("f", later), series, slot(earlier), slot(later)], 2);
+            assert.equal(await store.removeEntries(calendar, ["p", "f", "s", "unknown"], CONTRACT_NOW), 3);
+            const happened = (await store.event(past?.eventId))?.event;
+            assert.equal(happened?.sourceDeletedAt, CONTRACT_NOW);
+            assert.equal(happened?.title, "Example review");
+            assert.equal((await store.event(future?.eventId))?.event.status, "cancelled");
+            const occurrence = await store.event(slotLater?.eventId);
+            assert.deepEqual([occurrence?.event.status, occurrence?.entries[0]?.status], ["cancelled", "cancelled"]);
+            assert.equal(occurrence?.entries[0]?.deletedAt, null);
+            assert.equal(await store.removeEntries(calendar, ["p"], CONTRACT_NOW + 1), 0);
+        }),
+        test("a calendar's cursor is its own, and null forgets it", async (fixture) => {
+            const { store, calendar } = fixture;
+            const other = await second(fixture);
+            assert.equal(await store.cursor(calendar), null);
+            const value = JSON.stringify({ v: 1, token: "token-1", window: { from: earlier, to: later }, fullAt: 2 });
+            await store.setCursor(calendar, value, 2);
+            await store.setCursor(other, "other", 2);
+            assert.equal(await store.cursor(calendar), value);
+            await store.setCursor(calendar, null, 3);
+            assert.equal(await store.cursor(calendar), null);
+            assert.equal(await store.cursor(other), "other");
+        }),
         test("a full list marks the entries it did not return, plain occurrences only inside the window", async ({ store, calendar, }) => {
             const outside = later + 30 * 24 * HOUR;
             const [kept, gone, far] = await store.saveEntries(calendar, [

package/dist/sends/guard.d.ts

@@ -93,6 +93,8 @@ export interface GuardSettings {
     readOnlyLock?: string;
     permissions: Readonly<Record<PermissionKey, Level>>;
     permissionSources: Readonly<Record<PermissionKey, string>>;
+    /** A CLI's own defaults (`commandPermissions`); without them a key falls back to the messenger's. */
+    permissionDefaults?: Readonly<Record<PermissionKey, Level>>;
     sendsPerHour: number;
 }
 /**

package/dist/sends/guard.js

@@ -259,6 +259,7 @@ export const guardFor = (app, settings, warn, env = process.env, ask) => sendGua
     ...(settings.readOnlyLock ? { readOnlyLock: settings.readOnlyLock } : {}),
     permissions: () => settings.permissions,
     permissionSources: settings.permissionSources,
+    ...(settings.permissionDefaults ? { permissionDefaults: settings.permissionDefaults } : {}),
     ...(ask ? { ask } : {}),
     sendsPerHour: settings.sendsPerHour,
     journal: new SendJournal(sendsPathFor(app, settings.profile, env), { service: app.command, version: app.version }),

package/dist/services/index.d.ts

@@ -83,7 +83,7 @@ export { searchStore } from "./messages-archive-search.js";
 export type { ModerateOptions, ModerationService, ShownRules } from "./moderation.js";
 export { moderationService } from "./moderation.js";
 export type { ContactSync, PeopleService } from "./people.js";
-export { peopleService, phoneOf } from "./people.js";
+export { linkPeople, peopleService, phoneOf } from "./people.js";
 export type { ContextEvent, ContextMessage, ContextOptions, NotReadReason, PersonContext, SharedChat, } from "./person-context.js";
 export { CONTEXT_BYTES, CONTEXT_MESSAGES, identityIn, personContext } from "./person-context.js";
 export type { PersonPreparation, WaitingDialog } from "./person-preparation.js";

package/dist/services/index.js

@@ -58,7 +58,7 @@ export { chatIdIn, storedChatId } from "./message-resolution.js";
 export { DELETE_AT_ONCE, messagesService } from "./messages.js";
 export { searchStore } from "./messages-archive-search.js";
 export { moderationService } from "./moderation.js";
-export { peopleService, phoneOf } from "./people.js";
+export { linkPeople, peopleService, phoneOf } from "./people.js";
 export { CONTEXT_BYTES, CONTEXT_MESSAGES, identityIn, personContext } from "./person-context.js";
 export { PREPARE_BYTES, personPreparation } from "./person-preparation.js";
 export { personTimeline, SCOPES, TIMELINE_ITEMS, TIMELINE_MAX } from "./person-timeline.js";

package/dist/services/people.d.ts

@@ -1,7 +1,7 @@
 import { type Predicate } from "@wirecat/cli-base/query";
 import type { Contact, Id, Member, Page, PersonCard, PersonProfile, PhoneBookEntry } from "../domain/models.js";
 import { type Operated } from "../sends/guarded.js";
-import type { PersonRecord } from "../store/store.js";
+import type { AccountKey, MessageStore, PersonRecord } from "../store/store.js";
 import type { PageWindow } from "./chats.js";
 import { type ServiceDeps } from "./deps.js";
 import { type ContextOptions, type Detail, type PersonContext, type PersonMessages } from "./person-context.js";
@@ -83,6 +83,11 @@ export interface PeopleService {
 }
 export declare const peopleService: (deps: ServiceDeps) => PeopleService;
 /** Digits, with the `+` and the spaces, dashes and brackets people type dropped. */
+/**
+ * The owner's link of two people, each read in the account's messenger unless prefixed (`max:Ana`, `email:ana@x.com`,
+ * `person:12`); `me` links the first to the owner. A tool without a messenger (a calendar CLI) calls it directly.
+ */
+export declare const linkPeople: (store: MessageStore, account: AccountKey, person: string, other: string, method?: string) => Promise<PersonRecord>;
 export declare const phoneOf: (typed: string) => string;
 /** The phone cut to its last four digits: enough to tell two accounts apart. */
 export declare const maskedAccount: <T extends {

package/dist/services/people.js

@@ -109,17 +109,7 @@ export const peopleService = (deps) => {
                 ...(detail ? { detail } : {}),
             });
         },
-        link: async (person, other, method = "manual") => {
-            const store = await deps.store();
-            const account = await deps.account();
-            const one = await identityIn(store, account, person);
-            if (other === "me")
-                return store.people.linkToOwner(one);
-            const two = await identityIn(store, account, other);
-            if (one.provider === two.provider && one.id === two.id)
-                throw new CliError("validation_error", "that is the same person twice");
-            return store.people.linkIdentities(one, two, { method, by: "owner" });
-        },
+        link: async (person, other, method = "manual") => linkPeople(await deps.store(), await deps.account(), person, other, method),
         unlink: async (person) => {
             const store = await deps.store();
             return store.people.unlinkIdentity(await identityIn(store, await deps.account(), person), {
@@ -199,6 +189,19 @@ export const peopleService = (deps) => {
 /** Numbers per request: one big list in one request is what a contact-scraping account sends. */
 const IMPORT_CHUNK = 10;
 /** Digits, with the `+` and the spaces, dashes and brackets people type dropped. */
+/**
+ * The owner's link of two people, each read in the account's messenger unless prefixed (`max:Ana`, `email:ana@x.com`,
+ * `person:12`); `me` links the first to the owner. A tool without a messenger (a calendar CLI) calls it directly.
+ */
+export const linkPeople = async (store, account, person, other, method = "manual") => {
+    const one = await identityIn(store, account, person);
+    if (other === "me")
+        return store.people.linkToOwner(one);
+    const two = await identityIn(store, account, other);
+    if (one.provider === two.provider && one.id === two.id)
+        throw new CliError("validation_error", "that is the same person twice");
+    return store.people.linkIdentities(one, two, { method, by: "owner" });
+};
 export const phoneOf = (typed) => {
     const digits = typed.replace(/[\s()+-]/g, "");
     if (!/^\d{6,15}$/.test(digits)) {

package/dist/store/sqlite/calendar.js

@@ -22,6 +22,7 @@ const entryOf = (row) => ({
     calendarId: Number(row.calendar_id),
     kind: row.kind,
     seriesEntryId: int(row.series_entry_id),
+    seriesExternalId: str(row.series_external_id),
     eventId: int(row.event_id),
     eventSeriesId: int(row.event_series_id),
     externalId: String(row.external_id),
@@ -94,6 +95,7 @@ const attachmentOf = (row) => ({
 });
 const TRACKED = ["title", "starts_at", "ends_at", "location", "status", "recurrence", "recurrence_ends_at"];
 const flag = (value) => (value ? 1 : 0);
+const cursorKey = (calendarId) => `calendar:${calendarId}`;
 const addressOf = (email) => email.trim().toLowerCase();
 /** The `email` contact of an address: the same one mail uses, made when missing; it gets a name only when new. */
 const contactOf = (context, email, name) => {
@@ -331,7 +333,7 @@ export const eventStoreOver = (context) => {
                 .get(seriesEntryId, input.originalStartsAt);
         return database
             .prepare("SELECT * FROM calendar_entries WHERE calendar_id = ? AND series_entry_id IS NULL AND original_starts_at = ? " +
-            "AND json_extract(metadata, '$.recurring_event_id') = ?")
+            "AND series_external_id = ?")
             .get(calendarId, input.originalStartsAt, input.seriesExternalId ?? null);
     };
     const saveEntry = (calendarId, input, now) => {
@@ -347,6 +349,7 @@ export const eventStoreOver = (context) => {
         const values = {
             kind: input.kind,
             series_entry_id: seriesEntryId,
+            series_external_id: input.kind === "occurrence" ? (input.seriesExternalId ?? null) : null,
             external_id: input.externalId,
             ical_uid: input.icalUid ?? null,
             original_starts_at: input.originalStartsAt ?? null,
@@ -371,17 +374,11 @@ export const eventStoreOver = (context) => {
             join_url: joinUrl,
             join_key: joinUrl ? (joinKeyOf(joinUrl) ?? "") : null,
             conference: input.conference ?? null,
-            // The calendar's own page of the event names it in the query (`eid`), which opens nothing on its own.
             url: input.url ?? null,
             sequence: input.sequence ?? null,
             etag: input.etag ?? null,
             external_updated_at: input.externalUpdatedAt ?? null,
-            metadata: toJson({
-                ...entryMetadata(input.metadata),
-                ...(input.kind === "occurrence" && input.seriesExternalId
-                    ? { recurring_event_id: input.seriesExternalId }
-                    : {}),
-            }),
+            metadata: toJson(entryMetadata(input.metadata)),
             seen_at: now,
             deleted_at: null,
         };
@@ -415,23 +412,39 @@ export const eventStoreOver = (context) => {
         if (input.kind === "series")
             database
                 .prepare("UPDATE calendar_entries SET series_entry_id = ?, updated_at = ? WHERE calendar_id = ? AND kind = 'occurrence' " +
-                "AND series_entry_id IS NULL AND json_extract(metadata, '$.recurring_event_id') = ?")
+                "AND series_entry_id IS NULL AND series_external_id = ?")
                 .run(id, now, calendarId, input.externalId);
         return entryOf(entryRow(id));
     };
+    const cancel = (row, now) => {
+        database
+            .prepare(`INSERT INTO calendar_entry_revisions (entry_id, title, starts_at, ends_at, location, status, recurrence,
+           recurrence_ends_at, external_updated_at, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(Number(row.id), str(row.title), int(row.starts_at), int(row.ends_at), str(row.location), str(row.status), str(row.recurrence), int(row.recurrence_ends_at), int(row.external_updated_at), now);
+        database
+            .prepare("UPDATE calendar_entries SET status = 'cancelled', updated_at = ? WHERE id = ?")
+            .run(now, Number(row.id));
+    };
     /** A series cancelled at the provider cancels its occurrences: past ones stay as history, future ones cancel. */
-    const cancelOccurrences = (series, now) => {
+    const cancelOccurrences = (seriesEntryId, now) => {
         const occurrences = database
             .prepare("SELECT * FROM calendar_entries WHERE series_entry_id = ? AND status <> 'cancelled' AND deleted_at IS NULL")
-            .all(series.id);
-        for (const row of occurrences) {
-            database
-                .prepare(`INSERT INTO calendar_entry_revisions (entry_id, title, starts_at, ends_at, location, status, recurrence,
-             recurrence_ends_at, external_updated_at, created_at) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?)`)
-                .run(Number(row.id), str(row.title), int(row.starts_at), int(row.ends_at), str(row.location), str(row.status), int(row.external_updated_at), now);
-            database
-                .prepare("UPDATE calendar_entries SET status = 'cancelled', updated_at = ? WHERE id = ?")
-                .run(now, Number(row.id));
+            .all(seriesEntryId);
+        for (const row of occurrences)
+            cancel(row, now);
+    };
+    /** The events and series of these entries and of their occurrences take their fields again. */
+    const refreshAround = (entryIds, now) => {
+        const ids = JSON.stringify(entryIds);
+        const touched = database
+            .prepare(`SELECT DISTINCT ce.event_id, ce.event_series_id FROM calendar_entries ce
+          WHERE ce.id IN (SELECT value FROM json_each(?)) OR ce.series_entry_id IN (SELECT value FROM json_each(?))`)
+            .all(ids, ids);
+        for (const row of touched) {
+            if (row.event_series_id != null)
+                refreshSeries(Number(row.event_series_id), now);
+            if (row.event_id != null)
+                refreshEvent(Number(row.event_id), now);
         }
     };
     return {
@@ -442,7 +455,7 @@ export const eventStoreOver = (context) => {
              access_role = excluded.access_role, primary_calendar = excluded.primary_calendar, seen_at = excluded.seen_at,
              deleted_at = NULL, updated_at = excluded.updated_at
            RETURNING *`);
-            return calendars.map((one) => calendarOf(upsert.get(accountId, one.externalId, one.title, one.timezone, one.accessRole, flag(one.primary), flag(one.accessRole === "owner"), now, now, now)));
+            return calendars.map((one) => calendarOf(upsert.get(accountId, one.externalId, one.title, one.timezone, one.accessRole, flag(one.primary), flag(one.syncByDefault), now, now, now)));
         }),
         calendars: async (accountId) => database
             .prepare("SELECT * FROM calendars WHERE account_id = ? ORDER BY primary_calendar DESC, title, id")
@@ -466,22 +479,28 @@ export const eventStoreOver = (context) => {
             });
             for (const entry of saved)
                 if (entry.kind === "series" && entry.status === "cancelled")
-                    cancelOccurrences(entry, now);
+                    cancelOccurrences(entry.id, now);
             const current = saved.map(({ id }) => entryOf(entryRow(id)));
             for (const entry of current)
                 link(entry, now);
-            const touched = database
-                .prepare(`SELECT DISTINCT ce.event_id, ce.event_series_id FROM calendar_entries ce
-              WHERE ce.id IN (SELECT value FROM json_each(?)) OR ce.series_entry_id IN (SELECT value FROM json_each(?))`)
-                .all(JSON.stringify(current.map(({ id }) => id)), JSON.stringify(current.map(({ id }) => id)));
-            for (const row of touched) {
-                if (row.event_series_id != null)
-                    refreshSeries(Number(row.event_series_id), now);
-                if (row.event_id != null)
-                    refreshEvent(Number(row.event_id), now);
-            }
+            refreshAround(current.map(({ id }) => id), now);
             return entries.map((input) => entryOf(entryRow(ids.get(input))));
         }),
+        removeEntries: async (calendarId, externalIds, now) => write(database, () => {
+            calendarRow(calendarId);
+            const removed = database
+                .prepare(`SELECT * FROM calendar_entries WHERE calendar_id = ? AND external_id IN (SELECT value FROM json_each(?))
+               AND status <> 'cancelled' AND deleted_at IS NULL`)
+                .all(calendarId, JSON.stringify(externalIds));
+            for (const row of removed) {
+                cancel(row, now);
+                database.prepare("UPDATE calendar_entries SET seen_at = ? WHERE id = ?").run(now, Number(row.id));
+                if (row.kind === "series")
+                    cancelOccurrences(Number(row.id), now);
+            }
+            refreshAround(removed.map((row) => Number(row.id)), now);
+            return removed.length;
+        }),
         markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => {
             const marked = database
                 .prepare(`UPDATE calendar_entries SET deleted_at = ?, updated_at = ? WHERE calendar_id = ? AND deleted_at IS NULL
@@ -494,6 +513,24 @@ export const eventStoreOver = (context) => {
                     refreshEvent(eventId, now);
             return marked.length;
         }),
+        cursor: async (calendarId) => read(database, () => {
+            const { account_id } = calendarRow(calendarId);
+            return str(database
+                .prepare("SELECT value FROM sync_cursors WHERE account_id = ? AND key = ?")
+                .get(Number(account_id), cursorKey(calendarId))?.value);
+        }),
+        setCursor: async (calendarId, value, now) => write(database, () => {
+            const accountId = Number(calendarRow(calendarId).account_id);
+            if (value === null)
+                database
+                    .prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?")
+                    .run(accountId, cursorKey(calendarId));
+            else
+                database
+                    .prepare(`INSERT INTO sync_cursors (account_id, key, value, created_at, updated_at) VALUES (?, ?, ?, ?, ?)
+               ON CONFLICT (account_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`)
+                    .run(accountId, cursorKey(calendarId), value, now, now);
+        }),
         events: async (filter = {}) => {
             const clauses = ["e.deleted_at IS NULL"];
             const params = [];

package/dist/store/sqlite/manifest.js

@@ -45,6 +45,8 @@ export const MANIFEST = [
     { name: "20261025072644_version-33-calendars-triggers", version: 33, minCompatible: 32 },
     { name: "20261025182500_version-34-vector-index", version: 34, minCompatible: 34 },
     { name: "20261025182501_version-34-vector-index-triggers", version: 34, minCompatible: 34 },
+    { name: "20261027102259_version-35-calendar-neutral", version: 35, minCompatible: 34 },
+    { name: "20261027102302_version-35-calendar-neutral-data", version: 35, minCompatible: 34 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -761,5 +761,22 @@ export const GENERATED = [
             "CREATE TRIGGER vector_index_conversation_au AFTER UPDATE OF chat_id ON conversations\n  WHEN old.chat_id IS NOT new.chat_id BEGIN\n  INSERT INTO vector_index_redo (chunk_id)\n    SELECT id FROM chunks WHERE chunkable_type = 'conversation' AND chunkable_id = new.id;\n  DELETE FROM vector_index_redo;\nEND;",
             "-- Images and conversations are indexed under their chat's account; messages carry their own.\nCREATE TRIGGER vector_index_chat_au AFTER UPDATE OF account_id ON chats WHEN old.account_id IS NOT new.account_id BEGIN\n  INSERT INTO vector_index_redo (chunk_id)\n    SELECT k.id FROM messages m JOIN attachments a ON a.attachable_type = 'message' AND a.attachable_id = m.id\n      JOIN chunks k ON k.chunkable_type = 'image' AND k.chunkable_id = a.id WHERE m.chat_id = new.id\n    UNION ALL SELECT k.id FROM conversations c JOIN chunks k ON k.chunkable_type = 'conversation' AND k.chunkable_id = c.id\n      WHERE c.chat_id = new.id;\n  DELETE FROM vector_index_redo;\nEND;"
         ]
+    },
+    {
+        "name": "20261027102259_version-35-calendar-neutral",
+        "statements": [
+            "ALTER TABLE `calendar_entries` ADD `series_external_id` text;",
+            "CREATE INDEX `calendar_entries_by_calendar_id_series_external_id` ON `calendar_entries` (`calendar_id`,`series_external_id`) WHERE series_external_id IS NOT NULL;"
+        ]
+    },
+    {
+        "name": "20261027102302_version-35-calendar-neutral-data",
+        "statements": [
+            "-- `metadata.recurring_event_id` stays on the rows it is on: a version-34 build may still open this file and reads it.\nUPDATE calendar_entries SET series_external_id = json_extract(metadata, '$.recurring_event_id')\n  WHERE kind = 'occurrence' AND json_valid(metadata) AND json_extract(metadata, '$.recurring_event_id') IS NOT NULL;",
+            "UPDATE calendar_entries SET event_type = CASE event_type\n    WHEN 'outOfOffice' THEN 'out-of-office'\n    WHEN 'focusTime' THEN 'focus'\n    WHEN 'workingLocation' THEN 'working-location'\n    WHEN 'fromGmail' THEN 'from-mail'\n  END\n  WHERE event_type IN ('outOfOffice', 'focusTime', 'workingLocation', 'fromGmail');",
+            "UPDATE calendar_entries SET own_response = 'needs-action' WHERE own_response = 'needsAction';",
+            "UPDATE calendar_entry_participants SET response = 'needs-action' WHERE response = 'needsAction';",
+            "UPDATE calendars SET access_role = 'free-busy' WHERE access_role = 'freeBusyReader';"
+        ]
     }
 ];

package/dist/store/sqlite/note-index.d.ts

@@ -34,7 +34,7 @@ export interface Corpus {
 /** What an event `e` is searched by besides its title: the cleaned description, the place and the attendees' names. */
 export declare const EVENT_TEXT: string;
 /** Calendar entry types that are listed, never searched (requirements 3.4). */
-export declare const UNSEARCHED_EVENT_TYPES: readonly ["workingLocation", "focusTime", "outOfOffice", "birthday"];
+export declare const UNSEARCHED_EVENT_TYPES: readonly ["working-location", "focus", "out-of-office", "birthday"];
 /** Visibilities whose entry, when it carries no text, is a busy-only slot: stored, never searched (requirements 3.4). */
 export declare const BUSY_ONLY_VISIBILITIES: readonly ["private", "confidential"];
 /**

package/dist/store/sqlite/note-index.js

@@ -14,7 +14,12 @@ export const EVENT_TEXT = "trim(coalesce(e.description, '') || ' ' || coalesce(e
     "SELECT group_concat(p.name, ' ') FROM calendar_entries ce JOIN calendar_entry_participants p ON p.entry_id = ce.id " +
     "WHERE ce.event_id = e.id AND ce.deleted_at IS NULL AND p.resource = 0 AND p.name IS NOT NULL), ''))";
 /** Calendar entry types that are listed, never searched (requirements 3.4). */
-export const UNSEARCHED_EVENT_TYPES = ["workingLocation", "focusTime", "outOfOffice", "birthday"];
+export const UNSEARCHED_EVENT_TYPES = [
+    "working-location",
+    "focus",
+    "out-of-office",
+    "birthday",
+];
 /** Visibilities whose entry, when it carries no text, is a busy-only slot: stored, never searched (requirements 3.4). */
 export const BUSY_ONLY_VISIBILITIES = ["private", "confidential"];
 const sqlList = (values) => values.map((value) => `'${value}'`).join(", ");

package/dist/store/sqlite/schema.d.ts

@@ -8930,6 +8930,22 @@ export declare const calendarEntries: import("drizzle-orm/sqlite-core").SQLiteTa
             identity: undefined;
             generated: undefined;
         }, {}>;
+        seriesExternalId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "calendar_entries";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: 'sqlite';
     isAlias: false;

package/dist/store/sqlite/schema.js

@@ -911,12 +911,16 @@ export const calendarEntries = sqliteTable("calendar_entries", {
     createdAt: integer("created_at").notNull(),
     updatedAt: integer("updated_at").notNull(),
     deletedAt: integer("deleted_at"),
+    seriesExternalId: text("series_external_id"),
 }, (table) => [
     unique().on(table.calendarId, table.externalId),
     unique().on(table.seriesEntryId, table.originalStartsAt),
     index("calendar_entries_by_calendar_id_starts_at").on(table.calendarId, table.startsAt),
     index("calendar_entries_by_ical_uid").on(table.icalUid).where(sql `ical_uid IS NOT NULL`),
     index("calendar_entries_by_join_key").on(table.joinKey).where(sql `join_key IS NOT NULL`),
+    index("calendar_entries_by_calendar_id_series_external_id")
+        .on(table.calendarId, table.seriesExternalId)
+        .where(sql `series_external_id IS NOT NULL`),
     index("calendar_entries_by_event_id").on(table.eventId),
     index("calendar_entries_by_event_series_id").on(table.eventSeriesId),
     index("calendar_entries_by_event_type_event_id").on(table.eventType, table.eventId),