@wirecat/cli-core 0.455.0 → 0.456.0

package/dist/calendar/testing/source-contract.d.ts

@@ -0,0 +1,31 @@
+import type { ContractCase } from "../../meetings/index.js";
+import type { CalendarSource, SyncWindow } from "../source.js";
+/**
+ * One adapter over recorded responses, fresh for each case. Recorded fixtures answer by request, so a second round
+ * with the first round's cursor returns the recorded changes; a source that holds state changes it in `afterFullList`.
+ */
+export interface CalendarSourceFixture {
+    source: CalendarSource;
+    window: SyncWindow;
+    /** A cursor the provider refuses; absent for a source with `fullListOnly`. */
+    deadCursor?: string;
+    /** Called once after the first full list, before the second round. */
+    afterFullList?: () => void | Promise<void>;
+    /** Every `externalId` the second round holds, entries and removed ids together; absent skips that case. */
+    changed?: string[];
+    /** An entry the second round moved outside the window: never reported as removed. */
+    movedOut?: string;
+    /**
+     * A slot of a series cancelled at the provider: a cancelled entry or a removed id, or for `expands: "local"` an
+     * EXDATE line of its series.
+     */
+    cancelledSlot?: {
+        seriesExternalId: string;
+        originalStartsAt: number;
+    };
+}
+/**
+ * Every adapter runs this over recorded provider responses (foundation §6.3): calendar ids, all-day and repeating
+ * entries, neutral words, zones, no meeting secret, RFC 5545 lines, a dead cursor and a second round.
+ */
+export declare const calendarSourceContract: (make: () => CalendarSourceFixture | Promise<CalendarSourceFixture>) => ContractCase[];

package/dist/calendar/testing/source-contract.js

@@ -0,0 +1,171 @@
+import assert from "node:assert/strict";
+const STATUS = ["confirmed", "tentative", "cancelled"];
+const RESPONSE = ["needs-action", "accepted", "tentative", "declined", "delegated"];
+const EVENT_TYPE = ["default", "out-of-office", "focus", "working-location", "birthday", "from-mail"];
+const TRANSPARENCY = ["opaque", "transparent"];
+const VISIBILITY = ["default", "public", "private", "confidential"];
+const RECURRENCE_LINE = /^(RRULE|RDATE|EXDATE|EXRULE)[:;]\S/u;
+const SECRET = /\b(?:passcode|password|pin)\s*[:=#]\s*\S|[?&](?:pwd|passcode|pin)=/iu;
+const zoneOk = (zone) => {
+    if (zone == null)
+        return true;
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: zone });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const storedOf = (calendar) => ({
+    id: 1,
+    accountId: 1,
+    externalId: calendar.externalId,
+    title: calendar.title,
+    timezone: calendar.timezone,
+    accessRole: calendar.accessRole,
+    primary: calendar.primary,
+    synced: true,
+    seenAt: null,
+    deletedAt: null,
+});
+const round = async (source, calendar, cursor, window) => {
+    const listed = { calendar, entries: [], removed: [], cursor: null };
+    let page;
+    for (let pages = 0; pages < 1000; pages++) {
+        const result = await source.changes(calendar, { cursor, window, ...(page === undefined ? {} : { page }) });
+        if ("reset" in result)
+            return "reset";
+        const { entries, removed, nextPage, cursor: next } = result;
+        listed.entries.push(...entries);
+        listed.removed.push(...removed);
+        if (nextPage === undefined) {
+            listed.cursor = next ?? null;
+            return listed;
+        }
+        page = nextPage;
+    }
+    throw new assert.AssertionError({ message: "the source never stopped paging" });
+};
+const fullList = async (fixture) => {
+    const [first] = await fixture.source.calendars();
+    assert.ok(first, "the source lists at least one calendar");
+    const listed = await round(fixture.source, storedOf(first), null, fixture.window);
+    assert.notEqual(listed, "reset", "a full list is never a reset");
+    return listed;
+};
+/** The entries and every series' slots, as the engine would see them. */
+const everything = async (fixture, listed) => {
+    const slots = [];
+    if (fixture.source.traits.expands === "on-request")
+        for (const series of listed.entries.filter(({ kind, status }) => kind === "series" && status !== "cancelled"))
+            slots.push(...((await fixture.source.occurrences?.(listed.calendar, series.externalId, fixture.window)) ?? []));
+    return [...listed.entries, ...slots];
+};
+/**
+ * Every adapter runs this over recorded provider responses (foundation §6.3): calendar ids, all-day and repeating
+ * entries, neutral words, zones, no meeting secret, RFC 5545 lines, a dead cursor and a second round.
+ */
+export const calendarSourceContract = (make) => {
+    const test = (name, check) => ({
+        name,
+        async run() {
+            await check(await make());
+        },
+    });
+    return [
+        test("calendars have stable, distinct ids", async ({ source }) => {
+            const ids = (await source.calendars()).map(({ externalId }) => externalId);
+            assert.ok(ids.length > 0 && ids.every((id) => id.trim() !== ""));
+            assert.equal(new Set(ids).size, ids.length);
+            assert.deepEqual((await source.calendars()).map(({ externalId }) => externalId), ids);
+        }),
+        test("traits agree with the methods the source has", async ({ source, deadCursor }) => {
+            assert.equal(typeof source.occurrences === "function", source.traits.expands === "on-request");
+            assert.equal(deadCursor === undefined, source.traits.fullListOnly);
+        }),
+        test("only neutral words, IANA zones and RFC 5545 lines reach the entries", async (fixture) => {
+            for (const entry of await everything(fixture, await fullList(fixture))) {
+                const where = `entry ${entry.externalId}`;
+                assert.ok(STATUS.includes(entry.status), `${where}: status ${entry.status}`);
+                for (const [value, allowed] of [
+                    [entry.ownResponse, RESPONSE],
+                    [entry.eventType, EVENT_TYPE],
+                    [entry.transparency, TRANSPARENCY],
+                    [entry.visibility, VISIBILITY],
+                    ...(entry.participants ?? []).map(({ response }) => [response, RESPONSE]),
+                ])
+                    assert.ok(value == null || allowed.includes(value), `${where}: ${value} is not a neutral word`);
+                assert.ok(zoneOk(entry.timezone), `${where}: ${entry.timezone} is not an IANA zone`);
+                for (const line of entry.recurrence ?? [])
+                    assert.match(line, RECURRENCE_LINE, `${where}: ${line}`);
+            }
+        }),
+        test("no join link query, passcode or PIN anywhere in the output", async (fixture) => {
+            for (const entry of await everything(fixture, await fullList(fixture))) {
+                if (entry.joinUrl)
+                    assert.equal(new URL(entry.joinUrl).search, "", `entry ${entry.externalId}: join link`);
+                assert.doesNotMatch(JSON.stringify(entry), SECRET, `entry ${entry.externalId}: a meeting secret`);
+            }
+        }),
+        test("all-day entries carry dates with an exclusive end; slots are UTC milliseconds", async (fixture) => {
+            for (const entry of await everything(fixture, await fullList(fixture))) {
+                const where = `entry ${entry.externalId}`;
+                if (entry.allDay) {
+                    assert.match(entry.startDate ?? "", /^\d{4}-\d{2}-\d{2}$/u, `${where}: start date`);
+                    assert.ok((entry.endDate ?? "") > (entry.startDate ?? ""), `${where}: the end date is exclusive`);
+                }
+                if (entry.startsAt != null && entry.endsAt != null)
+                    assert.ok(entry.endsAt >= entry.startsAt, where);
+                if (entry.kind === "occurrence") {
+                    assert.ok(Number.isSafeInteger(entry.originalStartsAt), `${where}: original start in milliseconds`);
+                    if (entry.allDay)
+                        assert.equal(entry.originalStartsAt % 86_400_000, 0, `${where}: midnight UTC`);
+                }
+            }
+        }),
+        test("a series and its occurrences share one iCalendar UID", async (fixture) => {
+            const all = await everything(fixture, await fullList(fixture));
+            const uids = new Map(all.filter(({ kind }) => kind === "series").map((one) => [one.externalId, one.icalUid]));
+            for (const entry of all.filter(({ kind }) => kind === "occurrence")) {
+                const uid = entry.seriesExternalId ? uids.get(entry.seriesExternalId) : undefined;
+                if (uid && entry.icalUid)
+                    assert.equal(entry.icalUid, uid, `entry ${entry.externalId}`);
+            }
+        }),
+        test("a cancelled slot arrives as a cancelled entry or a removed id, never silently", async (fixture) => {
+            if (!fixture.cancelledSlot)
+                return;
+            const { seriesExternalId, originalStartsAt } = fixture.cancelledSlot;
+            const listed = await fullList(fixture);
+            const all = await everything(fixture, listed);
+            const slot = all.find((one) => one.seriesExternalId === seriesExternalId && one.originalStartsAt === originalStartsAt);
+            // A source the engine expands locally says it with an EXDATE line of the series instead.
+            const excluded = fixture.source.traits.expands === "local" &&
+                all.some((one) => one.kind === "series" &&
+                    one.externalId === seriesExternalId &&
+                    (one.recurrence ?? []).some((line) => line.startsWith("EXDATE")));
+            assert.ok(excluded || slot?.status === "cancelled" || (slot !== undefined && listed.removed.includes(slot.externalId)), "the cancelled slot is missing");
+        }),
+        test("a dead cursor gives a reset", async (fixture) => {
+            if (fixture.deadCursor === undefined)
+                return;
+            const [first] = await fixture.source.calendars();
+            assert.equal(await round(fixture.source, storedOf(first), fixture.deadCursor, fixture.window), "reset");
+        }),
+        test("a second round with the cursor returns only the changes", async (fixture) => {
+            if (fixture.source.traits.fullListOnly)
+                return;
+            const listed = await fullList(fixture);
+            assert.notEqual(listed.cursor, null, "the last page carries a cursor");
+            await fixture.afterFullList?.();
+            const second = await round(fixture.source, listed.calendar, listed.cursor, fixture.window);
+            assert.notEqual(second, "reset");
+            const { entries, removed } = second;
+            if (fixture.changed)
+                assert.deepEqual([...entries.map(({ externalId }) => externalId), ...removed].sort(), [...fixture.changed].sort());
+            if (fixture.movedOut)
+                assert.ok(!removed.includes(fixture.movedOut), "an entry outside the window is no removal");
+        }),
+    ];
+};

package/dist/calendar/testing/source.d.ts

@@ -0,0 +1,38 @@
+import type { CalendarInput, EntryInput } from "../../meetings/index.js";
+import type { CalendarSource, CalendarSourceTraits, SyncWindow } from "../source.js";
+export interface FakeCalendarSourceOptions {
+    provider?: string;
+    traits?: Partial<CalendarSourceTraits>;
+    calendars?: CalendarInput[];
+    /** Entries per page of `changes()`. */
+    pageSize?: number;
+}
+/**
+ * A provider held in memory. Every `put` and `remove` is one change; the cursor names the last change it saw, so a
+ * later `changes()` returns only what came after it. A source whose cursor holds the window refuses a cursor asked
+ * for another window, as Graph's delta link would silently keep the old one.
+ */
+export interface FakeCalendarSource extends CalendarSource {
+    /** Adds or replaces entries of one calendar, by `externalId`. */
+    put(calendar: string, ...entries: EntryInput[]): void;
+    /** Deletes entries at the provider and reports them in the next round's `removed`. */
+    remove(calendar: string, ...externalIds: string[]): void;
+    /** Deletes entries without a word: only a full list notices. */
+    drop(calendar: string, ...externalIds: string[]): void;
+    /** What `occurrences()` returns for a series (`expands: "on-request"`). */
+    setOccurrences(seriesExternalId: string, entries: EntryInput[]): void;
+    /** Every cursor given out so far is dead: the next round with one gets `{ reset: true }`. */
+    expireCursors(): void;
+    /** The `changes()` call after this many more succeeds throws once. */
+    failAfter(calls: number): void;
+    readonly calls: {
+        changes: {
+            calendar: string;
+            cursor: string | null;
+            page?: string;
+            window: SyncWindow;
+        }[];
+        occurrences: string[];
+    };
+}
+export declare const fakeCalendarSource: (options?: FakeCalendarSourceOptions) => FakeCalendarSource;

package/dist/calendar/testing/source.js

@@ -0,0 +1,110 @@
+import { CliError } from "@wirecat/cli-base";
+const DEFAULT_TRAITS = { expands: "on-request", cursorHoldsWindow: false, fullListOnly: false };
+const inside = (entry, window) => entry.kind === "series" ||
+    entry.startsAt == null ||
+    (entry.startsAt < window.to && (entry.endsAt ?? entry.startsAt + 1) > window.from);
+export const fakeCalendarSource = (options = {}) => {
+    const traits = { ...DEFAULT_TRAITS, ...options.traits };
+    const pageSize = options.pageSize ?? 50;
+    const calendars = options.calendars ?? [
+        {
+            externalId: "primary",
+            title: "Example work",
+            timezone: "UTC",
+            accessRole: "owner",
+            primary: true,
+            syncByDefault: true,
+        },
+    ];
+    const held = new Map();
+    const log = [];
+    const occurrences = new Map();
+    let version = 0;
+    let deadBefore = 0;
+    let failIn = null;
+    const calls = { changes: [], occurrences: [] };
+    const of = (calendar) => {
+        if (!held.has(calendar))
+            held.set(calendar, new Map());
+        return held.get(calendar);
+    };
+    const token = (window) => traits.fullListOnly ? null : `v${version}${traits.cursorHoldsWindow ? `@${window.from}-${window.to}` : ""}`;
+    return {
+        provider: options.provider ?? "example-calendar",
+        traits,
+        calls,
+        async calendars() {
+            return calendars.map((one) => ({ ...one }));
+        },
+        async changes(calendar, { cursor, page, window }) {
+            calls.changes.push({ calendar: calendar.externalId, cursor, window, ...(page === undefined ? {} : { page }) });
+            if (failIn !== null && failIn-- === 0) {
+                failIn = null;
+                throw new CliError("provider_error", "example provider failed");
+            }
+            let entries;
+            let removed = [];
+            if (cursor === null || traits.fullListOnly)
+                entries = [...of(calendar.externalId).values()];
+            else {
+                const [, seen, holds] = /^v(\d+)(?:@(.*))?$/u.exec(cursor) ?? [];
+                if (seen === undefined || Number(seen) < deadBefore)
+                    return { reset: true };
+                if (traits.cursorHoldsWindow && holds !== `${window.from}-${window.to}`)
+                    throw new CliError("validation_error", "this cursor holds another window");
+                const after = log.filter((one) => one.version > Number(seen) && one.calendar === calendar.externalId);
+                const changed = new Map();
+                for (const one of after)
+                    if (one.put)
+                        changed.set(one.put.externalId, one.put);
+                removed = after.flatMap(({ removed }) => (removed === undefined ? [] : [removed]));
+                entries = [...changed.values()].filter(({ externalId }) => !removed.includes(externalId));
+            }
+            if (cursor === null || traits.fullListOnly)
+                entries = entries.filter((entry) => inside(entry, window));
+            const from = page === undefined ? 0 : Number(page);
+            const slice = entries.slice(from, from + pageSize);
+            const more = from + pageSize < entries.length;
+            return {
+                entries: slice.map((entry) => structuredClone(entry)),
+                removed: from === 0 ? removed : [],
+                ...(more ? { nextPage: String(from + pageSize) } : { cursor: token(window) }),
+            };
+        },
+        ...(traits.expands === "on-request"
+            ? {
+                async occurrences(_calendar, seriesExternalId, window) {
+                    calls.occurrences.push(seriesExternalId);
+                    return (occurrences.get(seriesExternalId) ?? [])
+                        .filter((entry) => inside(entry, window))
+                        .map((entry) => structuredClone(entry));
+                },
+            }
+            : {}),
+        put(calendar, ...entries) {
+            for (const entry of entries) {
+                of(calendar).set(entry.externalId, structuredClone(entry));
+                log.push({ version: ++version, calendar, put: structuredClone(entry) });
+            }
+        },
+        remove(calendar, ...externalIds) {
+            for (const externalId of externalIds) {
+                of(calendar).delete(externalId);
+                log.push({ version: ++version, calendar, removed: externalId });
+            }
+        },
+        drop(calendar, ...externalIds) {
+            for (const externalId of externalIds)
+                of(calendar).delete(externalId);
+        },
+        setOccurrences(seriesExternalId, entries) {
+            occurrences.set(seriesExternalId, entries);
+        },
+        expireCursors() {
+            deadBefore = ++version;
+        },
+        failAfter(n) {
+            failIn = n;
+        },
+    };
+};

package/dist/calendar/testing/sync-contract.d.ts

@@ -0,0 +1,15 @@
+import type { ContractCase, EventStore } from "../../meetings/index.js";
+import type { CalendarSourceTraits } from "../source.js";
+/** A fresh, empty store and one calendar account in it. */
+export interface CalendarSyncFixture {
+    store: EventStore;
+    accountId: number;
+}
+/** Every combination of the source traits: the engine must handle each. */
+export declare const CALENDAR_TRAIT_COMBINATIONS: readonly CalendarSourceTraits[];
+/**
+ * The sync engine over `fakeCalendarSource`, once for each trait combination: changes after a cursor, removal by id,
+ * a dead cursor, a window that moved, each way of expanding a series and a slot cancelled later, a failed page, an
+ * unsynced calendar and a full list. Run it over the store the CLI uses.
+ */
+export declare const calendarSyncContract: (make: () => CalendarSyncFixture | Promise<CalendarSyncFixture>) => ContractCase[];

package/dist/calendar/testing/sync-contract.js

@@ -0,0 +1,211 @@
+import assert from "node:assert/strict";
+import { parseCalendarCursor, syncCalendars } from "../sync.js";
+import { fakeCalendarSource } from "./source.js";
+/** Every combination of the source traits: the engine must handle each. */
+export const CALENDAR_TRAIT_COMBINATIONS = ["on-request", "in-changes", "local"].flatMap((expands) => [false, true].flatMap((cursorHoldsWindow) => [false, true].map((fullListOnly) => ({ expands, cursorHoldsWindow, fullListOnly }))));
+const HOUR = 3_600_000;
+const DAY = 24 * HOUR;
+const NOW = Date.UTC(2026, 9, 27, 9);
+const AT = NOW + DAY;
+const single = (externalId, at = AT, extra = {}) => ({
+    externalId,
+    kind: "single",
+    status: "confirmed",
+    title: "Example review",
+    startsAt: at,
+    endsAt: at + HOUR,
+    ...extra,
+});
+const utc = (at) => new Date(at).toISOString().replace(/[-:]|\.\d{3}/gu, "");
+const slotId = (series, at) => `${series}_${utc(at)}`;
+const slot = (series, at, status = "confirmed") => ({
+    ...single(slotId(series, at), at, { status }),
+    kind: "occurrence",
+    seriesExternalId: series,
+    originalStartsAt: at,
+    icalUid: `${series}@example.com`,
+});
+/** Daily slots of `RRULE:FREQ=DAILY;COUNT=n`; an `EXDATE` slot comes back cancelled. Enough for the contract. */
+const exampleExpander = (series, window) => {
+    const count = Number(/COUNT=(\d+)/u.exec(series.recurrence?.find((line) => line.startsWith("RRULE")) ?? "")?.[1]);
+    const skipped = new Set((series.recurrence ?? []).filter((line) => line.startsWith("EXDATE")).map((line) => line.split(":")[1]));
+    return Array.from({ length: count }, (_, n) => series.startsAt + n * DAY)
+        .filter((at) => at >= window.from && at < window.to)
+        .map((at) => slot(series.externalId, at, skipped.has(utc(at)) ? "cancelled" : "confirmed"));
+};
+const seriesOf = (externalId, exdates = []) => ({
+    ...single(externalId),
+    kind: "series",
+    icalUid: `${externalId}@example.com`,
+    recurrence: ["RRULE:FREQ=DAILY;COUNT=3", ...exdates.map((at) => `EXDATE:${utc(at)}`)],
+});
+/** Every stored entry that belongs to an event, found through the store's own reads. */
+const entriesOf = async (store) => {
+    const found = new Map();
+    for (const event of await store.events({ limit: 1000 }))
+        for (const entry of (await store.event(event.id))?.entries ?? [])
+            found.set(entry.externalId, entry);
+    return found;
+};
+const nameOf = ({ expands, cursorHoldsWindow, fullListOnly }) => `[expands ${expands}${cursorHoldsWindow ? ", cursor holds the window" : ""}${fullListOnly ? ", full list only" : ""}]`;
+/**
+ * The sync engine over `fakeCalendarSource`, once for each trait combination: changes after a cursor, removal by id,
+ * a dead cursor, a window that moved, each way of expanding a series and a slot cancelled later, a failed page, an
+ * unsynced calendar and a full list. Run it over the store the CLI uses.
+ */
+export const calendarSyncContract = (make) => CALENDAR_TRAIT_COMBINATIONS.flatMap((traits) => {
+    const test = (name, check, options = {}) => ({
+        name: `${name} ${nameOf(traits)}`,
+        async run() {
+            const fixture = await make();
+            const source = fakeCalendarSource({ ...options, traits });
+            const sync = (at, extra = {}) => syncCalendars(source, fixture.store, {
+                accountId: fixture.accountId,
+                now: at,
+                ...(traits.expands === "local" ? { expand: exampleExpander } : {}),
+                ...extra,
+            });
+            await check({ ...fixture, source, sync });
+        },
+    });
+    const cursorOf = async (store, calendarId) => parseCalendarCursor(await store.cursor(calendarId));
+    const putSeries = (source, series, slots) => {
+        if (traits.expands === "in-changes")
+            source.put("primary", series, ...slots);
+        else
+            source.put("primary", series);
+        if (traits.expands === "on-request")
+            source.setOccurrences(series.externalId, slots);
+    };
+    return [
+        test("the first run lists the window; the next reads only what changed", async ({ store, source, sync }) => {
+            source.put("primary", single("e1"), single("e2"));
+            const first = await sync(NOW);
+            const [one] = first.synced;
+            assert.deepEqual([one?.round, one?.saved, first.complete], ["full", 2, true]);
+            const cursor = await cursorOf(store, one?.calendarId);
+            assert.equal(cursor?.fullAt, NOW);
+            assert.equal(cursor?.token === null, traits.fullListOnly);
+            source.put("primary", single("e3"));
+            const second = (await sync(NOW + HOUR)).synced[0];
+            assert.equal(second?.round, traits.fullListOnly ? "full" : "changes");
+            assert.equal(second?.saved, traits.fullListOnly ? 3 : 1);
+            assert.equal(source.calls.changes.at(-1)?.cursor === null, traits.fullListOnly);
+            assert.deepEqual([...(await entriesOf(store)).keys()].sort(), ["e1", "e2", "e3"]);
+        }),
+        test("an entry the provider deletes is cancelled, or marked when only a full list shows it", async ({ store, source, sync, }) => {
+            source.put("primary", single("e1"));
+            await sync(NOW);
+            source.remove("primary", "e1");
+            const after = (await sync(NOW + HOUR)).synced[0];
+            const entry = (await entriesOf(store)).get("e1");
+            if (traits.fullListOnly) {
+                assert.equal(after?.unseen, 1);
+                assert.equal(entry?.deletedAt, NOW + HOUR);
+            }
+            else {
+                assert.equal(after?.removed, 1);
+                assert.deepEqual([entry?.status, entry?.deletedAt], ["cancelled", null]);
+            }
+        }),
+        test("a dead cursor is forgotten and the window listed again", async ({ store, source, sync }) => {
+            source.put("primary", single("e1"));
+            await sync(NOW);
+            source.expireCursors();
+            source.put("primary", single("e2"));
+            const after = (await sync(NOW + HOUR)).synced[0];
+            assert.equal(after?.round, "full");
+            assert.equal(after?.reset, !traits.fullListOnly);
+            assert.deepEqual(source.calls.changes.slice(traits.fullListOnly ? -1 : -2).map(({ cursor }) => cursor === null), traits.fullListOnly ? [true] : [false, true]);
+            assert.equal((await cursorOf(store, after?.calendarId))?.fullAt, NOW + HOUR);
+            assert.deepEqual([...(await entriesOf(store)).keys()].sort(), ["e1", "e2"]);
+        }),
+        test("a window that moved means a full round only when the cursor holds the window", async ({ store, source, sync, }) => {
+            const window = { from: NOW - 30 * DAY, to: NOW + 30 * DAY };
+            source.put("primary", single("e1"));
+            await sync(NOW, { window });
+            const moved = await sync(NOW + HOUR, { window: { from: window.from + DAY, to: window.to + DAY } });
+            assert.equal(moved.complete, true);
+            assert.equal(moved.synced[0]?.round, traits.cursorHoldsWindow || traits.fullListOnly ? "full" : "changes");
+            assert.deepEqual((await cursorOf(store, moved.synced[0]?.calendarId))?.window, {
+                from: window.from + DAY,
+                to: window.to + DAY,
+            });
+        }),
+        test("a series' slots come as the source expands them", async ({ store, source, sync }) => {
+            const slots = [slot("s", AT), slot("s", AT + DAY, "cancelled"), slot("s", AT + 2 * DAY)];
+            putSeries(source, seriesOf("s", [AT + DAY]), slots);
+            const report = (await sync(NOW)).synced[0];
+            assert.equal(report?.occurrences, traits.expands === "in-changes" ? 0 : 3);
+            assert.deepEqual(source.calls.occurrences, traits.expands === "on-request" ? ["s"] : []);
+            const entries = await entriesOf(store);
+            assert.deepEqual([slotId("s", AT), slotId("s", AT + 2 * DAY)].map((id) => entries.get(id)?.status), ["confirmed", "confirmed"]);
+            assert.equal(entries.get(slotId("s", AT))?.seriesExternalId, "s");
+        }),
+        test("a slot cancelled after it was stored is cancelled, never deleted", async ({ store, source, sync }) => {
+            putSeries(source, seriesOf("s"), [slot("s", AT), slot("s", AT + DAY), slot("s", AT + 2 * DAY)]);
+            await sync(NOW);
+            if (traits.expands === "in-changes")
+                source.put("primary", slot("s", AT + DAY, "cancelled"));
+            else
+                putSeries(source, seriesOf("s", [AT + DAY]), [
+                    slot("s", AT),
+                    slot("s", AT + DAY, "cancelled"),
+                    slot("s", AT + 2 * DAY),
+                ]);
+            await sync(NOW + HOUR);
+            const entry = (await entriesOf(store)).get(slotId("s", AT + DAY));
+            assert.deepEqual([entry?.status, entry?.deletedAt], ["cancelled", null]);
+            const event = await store.event(entry?.eventId);
+            assert.equal(event?.event.status, "cancelled");
+        }),
+        test("a failed page keeps the old cursor, and the next run reads the same changes again", async ({ store, source, sync }) => {
+            source.put("primary", single("e1"));
+            const first = await sync(NOW);
+            const calendarId = first.synced[0]?.calendarId;
+            const before = await store.cursor(calendarId);
+            source.put("primary", single("e2"), single("e3"));
+            source.failAfter(1);
+            const failed = await sync(NOW + HOUR);
+            assert.equal(failed.complete, false);
+            assert.match(failed.synced[0]?.error ?? "", /example provider failed/u);
+            assert.equal(await store.cursor(calendarId), before);
+            const again = await sync(NOW + 2 * HOUR);
+            assert.equal(again.complete, true);
+            assert.deepEqual([...(await entriesOf(store)).keys()].sort(), ["e1", "e2", "e3"]);
+        }, { pageSize: 1 }),
+        test("a calendar the owner does not sync is listed and never read", async ({ source, sync }) => {
+            const report = await sync(NOW);
+            assert.deepEqual(report.notSynced.map(({ externalId }) => externalId), ["team"]);
+            assert.deepEqual(new Set(source.calls.changes.map(({ calendar }) => calendar)), new Set(["primary"]));
+        }, {
+            calendars: [
+                {
+                    externalId: "primary",
+                    title: "Work",
+                    timezone: "UTC",
+                    accessRole: "owner",
+                    primary: true,
+                    syncByDefault: true,
+                },
+                {
+                    externalId: "team",
+                    title: "Team",
+                    timezone: null,
+                    accessRole: "reader",
+                    primary: false,
+                    syncByDefault: false,
+                },
+            ],
+        }),
+        test("a full run marks what the provider dropped without a word", async ({ store, source, sync }) => {
+            source.put("primary", single("e1"), single("e2"));
+            await sync(NOW);
+            source.drop("primary", "e2");
+            const after = (await sync(NOW + HOUR, { full: true })).synced[0];
+            assert.deepEqual([after?.round, after?.unseen], ["full", 1]);
+            const entries = await entriesOf(store);
+            assert.deepEqual([entries.get("e1")?.deletedAt, entries.get("e2")?.deletedAt], [null, NOW + HOUR]);
+        }),
+    ];
+});

package/dist/errors/reasons.js

@@ -53,6 +53,7 @@ const OTHERS = [
     validation("push.unreadable", "the folder to push could not be read"),
     validation("spreadsheet.unreadable", "the workbook could not be read"),
     ["state.invalid", "configuration_error", "the saved sync state is unreadable or invalid; it is kept, not reset"],
+    ["sync.partial", "provider_error", "some calendars did not sync; the next sync retries them"],
     validation("store.refused", "the local store refused the document text"),
     ["store.not-writable", "permission_error", "the message store cannot be written from this process"],
     [

package/dist/meetings/calendar-text.d.ts

@@ -9,5 +9,5 @@ export declare const calendarText: (text: string | null | undefined, { dropSecre
     dropSecretLines?: boolean;
 }) => string | null;
 /** The provider fields a calendar entry may keep in `metadata`: none of them can open a meeting. */
-export declare const ENTRY_METADATA_KEYS: readonly ["colorId", "guestsCanInviteOthers", "guestsCanModify", "guestsCanSeeOtherGuests", "hangoutLink", "locked", "privateCopy", "recurring_event_id"];
+export declare const ENTRY_METADATA_KEYS: readonly ["colorId", "guestsCanInviteOthers", "guestsCanModify", "guestsCanSeeOtherGuests", "hangoutLink", "locked", "privateCopy"];
 export declare const entryMetadata: (metadata: Record<string, unknown> | null | undefined) => Record<string, unknown>;

package/dist/meetings/calendar-text.js

@@ -42,7 +42,6 @@ export const ENTRY_METADATA_KEYS = [
     "hangoutLink",
     "locked",
     "privateCopy",
-    "recurring_event_id",
 ];
 export const entryMetadata = (metadata) => {
     const kept = {};