@wirecat/cli-core 0.547.0 → 0.548.0

package/CHANGELOG.md

@@ -7,6 +7,27 @@ shape of this file.
 
 ## Unreleased
 
+## 0.548.0 — 02.11.2026
+
+### Added
+
+- **A feed is asked whether it changed.** `sync` sends a feed the last answer's `ETag` / `Last-Modified` back as
+  `If-None-Match` / `If-Modified-Since`, and a `304` keeps every stored event without reading the feed again
+  (`feeds[].unchanged` in the answer). The validators are the feed calendar's sync token in the store, valid for one
+  window: the first sync of a new day, and `sync --rescan`, read the feed in full. `fetchFeedIfChanged` is exported;
+  a `fullListOnly` source now gets its last token in `changes()`, and a page may say `unchanged: true`.
+- **`calendars add` warns once on stderr for an `http://` feed**: the feed and any token in its address travel
+  unencrypted. It is still allowed; `webcal://` and `https://` do not warn.
+
+### Changed — may break callers
+
+- **`calendars remove` deletes a feed's events instead of cancelling them**, with the calendar row, its cursor, the
+  events and series only it held, their links, tags, search words and vectors, and people only it had seen. An event
+  another calendar also holds stays with that copy. The answer's `events` counts the events deleted. A new
+  `EventStore.forgetCalendar(calendarId, now)` does it: an `EventStore` written outside cli-core must add it
+  (`memoryEventStore` and the SQLite store have it, and `eventStoreContract` checks it). `calendars unsync` is
+  unchanged.
+
 ## 0.547.0 — 02.11.2026
 
 ### Added

package/dist/calendar/cli/answers.d.ts

@@ -24,7 +24,7 @@ export declare const calendarFeed: v.StrictObjectSchema<{
     readonly events: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
     readonly hint: v.StringSchema<undefined>;
 }, undefined>;
-/** `calendars remove`: the feed's calendar, no longer synced, and how many stored entries were marked deleted. */
+/** `calendars remove`: the feed's calendar, gone, how many stored entries were deleted, and how many events with them. */
 export declare const calendarFeedRemoval: v.StrictObjectSchema<{
     readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
     readonly external_id: v.StringSchema<undefined>;
@@ -35,6 +35,7 @@ export declare const calendarFeedRemoval: v.StrictObjectSchema<{
     readonly synced: v.BooleanSchema<undefined>;
     readonly seen_at: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>, undefined>;
     readonly removed: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+    readonly events: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
 }, undefined>;
 export declare const calendarBusy: v.StrictObjectSchema<{
     readonly start: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.IsoTimestampAction<string, "an ISO 8601 time in UTC">, v.EndsWithAction<string, "Z", "an ISO 8601 time in UTC, ending in `Z`">]>;
@@ -100,11 +101,15 @@ export declare const calendarSync: v.StrictObjectSchema<{
         readonly embedded: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly left: v.BooleanSchema<undefined>;
     }, undefined>, undefined>;
-    /** Each feed's events as read, and how many it could not take (`syncWithFeeds`). */
+    /**
+     * Each feed's events as read, and how many it could not take (`syncWithFeeds`); `unchanged` when the feed answered
+     * 304 and the counts are those of the read before.
+     */
     readonly feeds: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
         readonly calendar_id: v.NumberSchema<undefined>;
         readonly events: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
         readonly skipped: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>;
+        readonly unchanged: v.OptionalSchema<v.LiteralSchema<true, undefined>, undefined>;
     }, undefined>, undefined>, undefined>;
 }, undefined>;
 export declare const calendarSyncProgress: v.StrictObjectSchema<{

package/dist/calendar/cli/answers.js

@@ -21,8 +21,8 @@ export const calendar = v.strictObject({
 });
 /** `calendars add`: the feed's calendar, how many events the feed holds now, and the sync to run next. */
 export const calendarFeed = v.strictObject({ ...calendar.entries, events: count, hint: text });
-/** `calendars remove`: the feed's calendar, no longer synced, and how many stored entries were marked deleted. */
-export const calendarFeedRemoval = v.strictObject({ ...calendar.entries, removed: count });
+/** `calendars remove`: the feed's calendar, gone, how many stored entries were deleted, and how many events with them. */
+export const calendarFeedRemoval = v.strictObject({ ...calendar.entries, removed: count, events: count });
 const busyRow = v.strictObject({
     /** One of the account's calendars, by its id; or `person`, by the address asked. */
     calendar: v.optional(id),
@@ -72,8 +72,16 @@ export const calendarSync = v.strictObject({
     hint: v.optional(text),
     /** What `sync --embed` embedded: `embedEvents`' answer. */
     embeddings: v.optional(v.strictObject({ model: text, embedded: count, left: v.boolean() })),
-    /** Each feed's events as read, and how many it could not take (`syncWithFeeds`). */
-    feeds: v.optional(v.array(v.strictObject({ calendar_id: v.number(), events: count, skipped: count }))),
+    /**
+     * Each feed's events as read, and how many it could not take (`syncWithFeeds`); `unchanged` when the feed answered
+     * 304 and the counts are those of the read before.
+     */
+    feeds: v.optional(v.array(v.strictObject({
+        calendar_id: v.number(),
+        events: count,
+        skipped: count,
+        unchanged: v.optional(v.literal(true)),
+    }))),
 });
 export const calendarSyncProgress = v.strictObject({
     calendar_id: id,

package/dist/calendar/cli/index.js

@@ -3,7 +3,7 @@ import { annotate, sharedCommand } from "@wirecat/cli-base/commands";
 import { timezoneOf } from "@wirecat/cli-base/query";
 import { clockMeta } from "@wirecat/cli-base/standards";
 import { Argument, InvalidArgumentError, Option } from "commander";
-import { environmentOf, runBudgetOf } from "../../cli/context.js";
+import { environmentOf, outputFor, runBudgetOf } from "../../cli/context.js";
 import { honoursDryRun } from "../../cli/dry-run-guard.js";
 import { changesStore, ownerOnlyOption, writesFileOnlyWith } from "../../cli/effects.js";
 import { queryTerms, withQuery } from "../../cli/list-query.js";
@@ -14,7 +14,7 @@ import { searchEvents } from "../../services/events-search.js";
 import { dateWindow } from "../../services/moment.js";
 import { linkPeople } from "../../services/people.js";
 import { BUSY_QUERY, BUSY_QUERY_NOTE, busyAnswer, busyQuery, workingHoursOf } from "../busy.js";
-import { isFeedCalendar, syncWithFeeds } from "../feeds.js";
+import { isFeedCalendar, isPlainHttp, syncWithFeeds } from "../feeds.js";
 import { eventPreparation, nextMeeting, PREPARE_MESSAGES } from "../prepare.js";
 import { accountsMeta, CALENDAR_UNTRUSTED_FIELDS, calendarIn, calendarItem, EVENTS_QUERY, EVENTS_QUERY_NOTE, EXPORT_MAX, eventAnswer, eventIdOf, eventOf, eventsAnswer, eventsFilter, eventsIcs, peopleAnswer, resolveAnswer, reviewsAnswer, sourceAccounts, weekFilter, } from "../reads.js";
 import { REPEAT_HELP } from "../recurrence.js";
@@ -30,8 +30,6 @@ const REMOTE_READ = { remote: "read", local: "none" };
 const LOCAL_OR_REMOTE_READ = { remote: "read", local: "read" };
 const REMOTE_WRITE = { remote: "write", local: "write" };
 const GROUP = { remote: "none", local: "none" };
-/** Every time a store can hold, for marking all of a calendar's entries at once. */
-const EVERYWHERE = { from: -8.64e15, to: 8.64e15 };
 /** How many pieces one `sync --embed` embeds, as drive's. */
 const EMBED_MAX = 600;
 // A list's marker goes on each item: a host's list envelope is strict and `--jsonl` prints only the items.
@@ -130,6 +128,9 @@ const addCalendarCommandsDefinition = (program, deps) => {
             if (command.optsWithGlobals().offline)
                 throw new CliError("permission_error", "calendars add reads the feed; leave out --offline");
             const { calendar, events } = await feeds().add(url, opts.title === undefined ? {} : { title: opts.title });
+            if (isPlainHttp(url))
+                outputFor(command).renderer.warn("this feed's address starts with http://, so the feed and any token in its address travel unencrypted; " +
+                    "use https:// if the server offers it");
             const [saved] = await deps.store.saveCalendars(deps.accountId, [calendar], now());
             print({
                 ...calendarItem(saved),
@@ -138,7 +139,8 @@ const addCalendarCommandsDefinition = (program, deps) => {
             }, command);
         });
         example(annotate(calendars.command("remove"), { effects: LOCAL_WRITE, mcp: false })
-            .description("stop following a feed calendars add added: its address is forgotten and its stored events go")
+            .description("stop following a feed calendars add added: its address is forgotten and its stored events are deleted, " +
+            "not cancelled. Only a feed; calendars unsync stops a provider's calendar")
             .argument("<calendar>", "the feed calendar's id, its ics: id, or its title"), "calendars remove 7").action(async (reference, _opts, command) => {
             const calendar = await calendarIn(deps.store, deps.accountId, reference);
             if (!isFeedCalendar(calendar))
@@ -146,9 +148,8 @@ const addCalendarCommandsDefinition = (program, deps) => {
                     reason: "feed.not-a-feed",
                 });
             await feeds().remove(calendar.externalId);
-            await deps.store.setCalendarSynced(calendar.id, false, now());
-            const removed = await deps.store.markUnseen(calendar.id, now() + 1, EVERYWHERE, now());
-            print({ ...calendarItem({ ...calendar, synced: false }), removed }, command);
+            const { entries, events } = await deps.store.forgetCalendar(calendar.id, now());
+            print({ ...calendarItem({ ...calendar, synced: false }), removed: entries, events }, command);
         });
     }
     if (deps.freeBusy)

package/dist/calendar/feeds.d.ts

@@ -28,6 +28,8 @@ export interface FeedSyncStats {
     calendarId: number;
     events: number;
     skipped: number;
+    /** The feed answered 304: nothing was read again, and the counts are those of the read before. */
+    unchanged?: true;
 }
 /** The profile's iCalendar feeds: a source the engine expands locally, and how one is added and forgotten. */
 export interface CalendarFeeds {
@@ -47,6 +49,8 @@ export interface CalendarFeeds {
 }
 /** `webcal://` is `https://`: calendar apps write it so a click opens them, and the feed itself is served over https. */
 export declare const feedAddress: (text: string) => URL;
+/** An `http://` address: allowed, but the feed and any token in its address travel unencrypted. */
+export declare const isPlainHttp: (text: string) => boolean;
 export interface FetchFeedOptions {
     /** Names the feed in errors; the address never appears in one. */
     name: string;
@@ -54,11 +58,26 @@ export interface FetchFeedOptions {
     signal?: AbortSignal;
     limits?: FeedLimits;
 }
+/** The last answer's `ETag` and `Last-Modified`, sent back so the server can say the feed has not changed. */
+export interface FeedValidators {
+    etag: string | null;
+    lastModified: string | null;
+}
 /**
  * The feed's text: http or https, each redirect followed by hand and only to https, the body cut off at its limit and
  * the request at its time. Errors name the feed and the status, never the address, which may hold a token.
  */
 export declare const fetchFeed: (address: string, options: FetchFeedOptions) => Promise<string>;
+/**
+ * `fetchFeed` that sends `since` as `If-None-Match` and `If-Modified-Since`: `"unchanged"` when the server answers 304,
+ * otherwise the text and the validators to send next time.
+ */
+export declare const fetchFeedIfChanged: (address: string, options: FetchFeedOptions & {
+    since?: FeedValidators;
+}) => Promise<{
+    text: string;
+    validators: FeedValidators;
+} | "unchanged">;
 /** One feed event in the neutral words, its text cleaned as an invitation's is: feed text is somebody else's. */
 export declare const feedEntry: (event: IcsEvent, zone: string) => EntryInput;
 export interface FeedRead {

package/dist/calendar/feeds.js

@@ -26,6 +26,8 @@ export const feedAddress = (text) => {
         throw invalidAddress("must not hold a user name or a password");
     return url;
 };
+/** An `http://` address: allowed, but the feed and any token in its address travel unencrypted. */
+export const isPlainHttp = (text) => feedAddress(text).protocol === "http:";
 const sameAddress = (a, b) => feedAddress(a).href === feedAddress(b).href;
 const readBody = async (response, name, maxBytes) => {
     const reader = response.body?.getReader();
@@ -58,8 +60,17 @@ const STATUS_ERRORS = {
  * The feed's text: http or https, each redirect followed by hand and only to https, the body cut off at its limit and
  * the request at its time. Errors name the feed and the status, never the address, which may hold a token.
  */
-export const fetchFeed = async (address, options) => {
-    const { name, limits = FEED_LIMITS } = options;
+export const fetchFeed = async (address, options) => (await fetchFeedIfChanged(address, options)).text;
+/**
+ * `fetchFeed` that sends `since` as `If-None-Match` and `If-Modified-Since`: `"unchanged"` when the server answers 304,
+ * otherwise the text and the validators to send next time.
+ */
+export const fetchFeedIfChanged = async (address, options) => {
+    const { name, limits = FEED_LIMITS, since } = options;
+    const conditional = {
+        ...(since?.etag ? { "if-none-match": since.etag } : {}),
+        ...(since?.lastModified ? { "if-modified-since": since.lastModified } : {}),
+    };
     const run = options.fetch ?? fetch;
     const timeout = AbortSignal.timeout(limits.timeoutMs);
     const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
@@ -69,8 +80,12 @@ export const fetchFeed = async (address, options) => {
             const response = await run(url, {
                 redirect: "manual",
                 signal,
-                headers: { accept: "text/calendar, text/plain;q=0.5, */*;q=0.1" },
+                headers: { accept: "text/calendar, text/plain;q=0.5, */*;q=0.1", ...conditional },
             });
+            if (response.status === 304 && Object.keys(conditional).length) {
+                await response.body?.cancel();
+                return "unchanged";
+            }
             const location = response.headers.get("location");
             if (response.status >= 300 && response.status < 400 && location) {
                 await response.body?.cancel();
@@ -95,7 +110,11 @@ export const fetchFeed = async (address, options) => {
                     retryable: response.status >= 500 || response.status === 429,
                 });
             }
-            return await readBody(response, name, limits.maxBytes);
+            const text = await readBody(response, name, limits.maxBytes);
+            return {
+                text,
+                validators: { etag: response.headers.get("etag"), lastModified: response.headers.get("last-modified") },
+            };
         }
     }
     catch (error) {
@@ -213,6 +232,19 @@ export const readFeed = (text, zone, window) => {
         skipped,
     };
 };
+const lastRead = (token, window) => {
+    if (token === null)
+        return null;
+    try {
+        const held = JSON.parse(token);
+        if (held?.v !== 1 || held.window?.from !== window.from || held.window.to !== window.to || !held.validators)
+            return null;
+        return held;
+    }
+    catch {
+        return null;
+    }
+};
 const calendarOf = (feed, timezone = null) => ({
     externalId: `${FEED_PREFIX}${feed.id}`,
     title: feed.title,
@@ -236,8 +268,9 @@ export const icsFeeds = (options) => {
             });
         return feed;
     };
-    const read = (url, name) => fetchFeed(url, {
+    const read = (url, name, since) => fetchFeedIfChanged(url, {
         name,
+        ...(since ? { since } : {}),
         ...(options.fetch ? { fetch: options.fetch } : {}),
         ...(options.signal ? { signal: options.signal } : {}),
         ...(options.limits ? { limits: options.limits } : {}),
@@ -248,9 +281,16 @@ export const icsFeeds = (options) => {
         async calendars() {
             return (await options.registry.read()).map((feed) => calendarOf(feed));
         },
-        async changes(calendar, { window }) {
+        async changes(calendar, { cursor, window }) {
             const feed = await feedOf(calendar.externalId);
-            const text = await read(feed.url, `feed ${calendar.id}`);
+            const held = lastRead(cursor, window);
+            const got = await read(feed.url, `feed ${calendar.id}`, held?.validators);
+            if (got === "unchanged") {
+                const [events, skipped] = [held?.events ?? 0, held?.skipped ?? 0];
+                stats.set(calendar.id, { calendarId: calendar.id, events, skipped, unchanged: true });
+                return { entries: [], removed: [], cursor, unchanged: true };
+            }
+            const { text, validators } = got;
             const found = readFeed(text, calendar.timezone ?? options.zone, window);
             for (const entry of found.entries) {
                 const changed = found.overrides.get(entry.externalId);
@@ -258,7 +298,10 @@ export const icsFeeds = (options) => {
                     overridesOf.set(entry, changed);
             }
             stats.set(calendar.id, { calendarId: calendar.id, events: found.events, skipped: found.skipped });
-            return { entries: found.entries, removed: [], cursor: null };
+            const next = validators.etag || validators.lastModified
+                ? { v: 1, validators, window, events: found.events, skipped: found.skipped }
+                : null;
+            return { entries: found.entries, removed: [], cursor: next && JSON.stringify(next) };
         },
     };
     return {
@@ -271,7 +314,7 @@ export const icsFeeds = (options) => {
                 throw new CliError("validation_error", "this profile follows a feed at this address already", {
                     reason: "feed.duplicate",
                 });
-            const found = readFeed(await read(address, "the feed"), options.zone);
+            const found = readFeed((await read(address, "the feed")).text, options.zone);
             const feed = {
                 id: randomBytes(6).toString("hex"),
                 url: address,

package/dist/calendar/source.d.ts

@@ -13,7 +13,10 @@ export interface CalendarSourceTraits {
     expands: "on-request" | "in-changes" | "local";
     /** The cursor encodes the window (Graph delta): a new window means a new full round. */
     cursorHoldsWindow: boolean;
-    /** No incremental cursor: every run is a full list (an ICS feed). */
+    /**
+     * No incremental cursor: every run is a full list (an ICS feed). The token the last list gave still reaches
+     * `changes()`, so the source can ask whether anything changed since.
+     */
     fullListOnly: boolean;
 }
 export interface ChangePage {
@@ -27,6 +30,11 @@ export interface ChangePage {
     nextPage?: string;
     /** On the last page: the cursor for the next run; `null` when the source has none. */
     cursor?: string | null;
+    /**
+     * A full-list source's list is the one its token was given with (an ICS feed's 304): nothing was read, so nothing
+     * is saved and nothing stored is marked unseen. Only on a single page with no entries.
+     */
+    unchanged?: true;
 }
 /** `reset`: the cursor is dead (Google 410, Graph `syncStateNotFound`, CalDAV `valid-sync-token`). */
 export type ChangeResult = ChangePage | {
@@ -61,7 +69,7 @@ export interface CalendarSource {
     readonly provider: string;
     readonly traits: CalendarSourceTraits;
     calendars(): Promise<CalendarInput[]>;
-    /** `cursor: null` asks for a full list of the window. */
+    /** `cursor: null` asks for a full list of the window; a `fullListOnly` source lists in full whatever it is given. */
     changes(calendar: StoredCalendar, request: {
         cursor: string | null;
         page?: string;

package/dist/calendar/sync.d.ts

@@ -23,6 +23,8 @@ export interface PendingRound {
     series: string[];
     /** A full round asks every series it lists; otherwise only those that changed. Absent reads as true. */
     everySeries?: boolean;
+    /** The source said its list is unchanged since `from`: the round marks nothing unseen. */
+    unchanged?: true;
 }
 /** What the engine keeps in `EventStore.cursor`. Version 1 had no `round`, `updatedAt` or `done`. */
 export interface CalendarCursor {

package/dist/calendar/sync.js

@@ -29,7 +29,7 @@ const roundOf = (value) => {
         round.series.some((id) => typeof id !== "string") ||
         (round.everySeries !== undefined && typeof round.everySeries !== "boolean"))
         return undefined;
-    const { full, from, window, startedAt, reset, page, listed, next, series, everySeries } = round;
+    const { full, from, window, startedAt, reset, page, listed, next, series, everySeries, unchanged } = round;
     return {
         full,
         from,
@@ -41,6 +41,7 @@ const roundOf = (value) => {
         next,
         series,
         ...(everySeries === false ? { everySeries } : {}),
+        ...(unchanged === true ? { unchanged } : {}),
     };
 };
 export const parseCalendarCursor = (value) => {
@@ -87,9 +88,9 @@ export const calendarSyncWindow = (now) => {
     return { from: Date.UTC(year - 1, month, date), to: Date.UTC(year, month + 3, date) };
 };
 const CONTINUE = "run sync again to continue";
-const freshRound = (full, from, window, now, reset = false, everySeries = true) => ({
+const freshRound = (full, from, window, now, reset = false, everySeries = true, keepToken = false) => ({
     full,
-    from: full ? null : from,
+    from: full && !keepToken ? null : from,
     window,
     startedAt: now,
     reset,
@@ -112,7 +113,7 @@ const roundFor = (source, stored, { window, now }) => {
     // The daily full round asks only the series that changed, and every series once the window's end moved on far
     // enough that their new slots matter (foundation §6.2 step 7).
     const everySeries = !full || stored?.slotsTo === undefined || window.to - stored.slotsTo >= SLOTS_EVERY;
-    return freshRound(full, stored?.token ?? null, window, now, false, everySeries);
+    return freshRound(full, stored?.token ?? null, window, now, false, everySeries, source.traits.fullListOnly);
 };
 const deadList = (provider) => new CliError("invalid_response", `${provider} refused a full list as a dead cursor`);
 /**
@@ -218,7 +219,9 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
         }
         if (page.removed.length)
             result.removed += await store.removeEntries(calendar.id, page.removed, now);
-        if (page.nextPage === undefined)
+        if (page.unchanged && source.traits.fullListOnly && page.entries.length === 0 && page.nextPage === undefined)
+            round = { ...round, page: null, listed: true, next: page.cursor ?? null, unchanged: true };
+        else if (page.nextPage === undefined)
             round = { ...round, page: null, listed: true, next: page.cursor ?? null };
         else {
             if (seen.has(page.nextPage))
@@ -260,7 +263,8 @@ const syncOne = async ({ source, store, calendar, window, now, expand, budget, s
     }
     if (signal?.aborted)
         return "cancelled";
-    result.unseen = round.full ? await store.markUnseen(calendar.id, round.startedAt, round.window, now) : 0;
+    result.unseen =
+        round.full && !round.unchanged ? await store.markUnseen(calendar.id, round.startedAt, round.window, now) : 0;
     await save({
         token: round.next,
         window: round.window,

package/dist/calendar/testing/memory.js

@@ -343,6 +343,45 @@ export const memoryEventStore = () => {
         async setCalendarSynced(calendarId, synced) {
             calendarOf(calendarId).synced = synced;
         },
+        async forgetCalendar(calendarId, now) {
+            const calendar = calendarOf(calendarId);
+            const mine = entries.filter((one) => one.calendarId === calendarId);
+            const ids = new Set(mine.map(({ id }) => id));
+            const eventIds = new Set(mine.flatMap(({ eventId }) => (eventId === null ? [] : [eventId])));
+            const seriesIds = new Set(mine.flatMap(({ eventSeriesId }) => (eventSeriesId === null ? [] : [eventSeriesId])));
+            for (let at = entries.length - 1; at >= 0; at--)
+                if (ids.has(entries[at].id))
+                    entries.splice(at, 1);
+            for (let at = revisions.length - 1; at >= 0; at--)
+                if (ids.has(revisions[at].entryId))
+                    revisions.splice(at, 1);
+            for (let at = reviews.length - 1; at >= 0; at--)
+                if (reviews[at].linkableType === "calendar_entry" &&
+                    ids.has(reviews[at].linkableId))
+                    reviews.splice(at, 1);
+            participants = participants.filter((one) => !ids.has(one.entryId));
+            attachments = attachments.filter((one) => !ids.has(one.entryId));
+            for (const id of ids)
+                unlinked.delete(id);
+            let gone = 0;
+            for (const id of eventIds)
+                if (entries.some((one) => one.eventId === id))
+                    refreshEvent(id, now);
+                else if (events.delete(id))
+                    gone++;
+            for (const id of seriesIds)
+                if (entries.some((one) => one.eventSeriesId === id))
+                    refreshSeries(id);
+                else {
+                    series.delete(id);
+                    for (const event of events.values())
+                        if (event.eventSeriesId === id)
+                            event.eventSeriesId = null;
+                }
+            cursors.delete(calendarId);
+            calendars.splice(calendars.indexOf(calendar), 1);
+            return { entries: ids.size, events: gone };
+        },
         async saveEntries(calendarId, list, now) {
             calendarOf(calendarId);
             for (const input of list)

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

@@ -253,6 +253,16 @@ export interface EventStore {
     saveCalendars(accountId: number, calendars: CalendarInput[], now: number): Promise<StoredCalendar[]>;
     calendars(accountId: number): Promise<StoredCalendar[]>;
     setCalendarSynced(calendarId: number, synced: boolean, now: number): Promise<void>;
+    /**
+     * The calendar and everything stored from it go, for a calendar that is not the owner's data (a followed feed): its
+     * entries, the events and series only it held, what was built from them (links, tags, search pieces, people seen
+     * only there) and its cursor. An event another calendar also holds stays, with that copy's fields; a meeting linked
+     * to a gone event stays, unlinked. Notes the owner wrote stay.
+     */
+    forgetCalendar(calendarId: number, now: number): Promise<{
+        entries: number;
+        events: number;
+    }>;
     /** One sync page, matched by rules 1–5, in one transaction. */
     saveEntries(calendarId: number, entries: EntryInput[], now: number): Promise<StoredEntry[]>;
     /**

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

@@ -192,6 +192,42 @@ export const eventStoreContract = (make) => {
             assert.equal(occurrence?.entries[0]?.deletedAt, null);
             assert.equal(await store.removeEntries(calendar, ["p"], CONTRACT_NOW + 1), 0);
         }),
+        test("a forgotten calendar goes with its entries and the events only it held; a shared event keeps the other copy", async (fixture) => {
+            const { store, calendar, accountId } = fixture;
+            const feed = await second(fixture, "ics:example");
+            await store.saveEntries(calendar, [single("w1", later, { icalUid: "shared@example.com", title: "Mine" })], 2);
+            const series = {
+                ...single("weekly", later, { title: "Weekly" }),
+                kind: "series",
+                recurrence: ["RRULE:FREQ=WEEKLY"],
+            };
+            await store.saveEntries(feed, [
+                single("f1", later, { icalUid: "shared@example.com", title: "Theirs", description: "longer text" }),
+                single("f2", later + HOUR, { title: "Only in the feed", participants: [{ email: "guest@example.com" }] }),
+                series,
+            ], 3);
+            await store.saveSlots(feed, [
+                {
+                    series: "weekly",
+                    slots: [
+                        {
+                            ...single("weekly@1", later + 2 * HOUR),
+                            kind: "occurrence",
+                            seriesExternalId: "weekly",
+                            originalStartsAt: later + 2 * HOUR,
+                        },
+                    ],
+                },
+            ], { from: earlier, to: later + 7 * 24 * HOUR }, "cursor", 3);
+            await store.setCursor(feed, "cursor", 3);
+            const forgotten = await store.forgetCalendar(feed, 4);
+            assert.deepEqual(forgotten, { entries: 4, events: 2 });
+            assert.deepEqual((await store.calendars(accountId)).map(({ externalId }) => externalId), ["primary"]);
+            const left = await store.events({ accountId });
+            assert.deepEqual(left.map(({ title, status }) => [title, status]), [["Mine", "confirmed"]]);
+            assert.equal((await store.event(left[0]?.id))?.entries.length, 1);
+            assert.equal(await store.entry(feed, "weekly"), null);
+        }),
         test("a calendar's cursor is its own, and null forgets it", async (fixture) => {
             const { store, calendar } = fixture;
             const other = await second(fixture);

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

@@ -1,3 +1,4 @@
+import type { CacheDatabase } from "../driver.js";
 import type { AccountKey, StoredAccount } from "../types.js";
 import type { StoreContext } from "./open.js";
 /** An account's row, made on first sight; a name only replaces what was known when there is one. */
@@ -10,3 +11,10 @@ export declare const storedAccounts: ({ orm }: StoreContext) => StoredAccount[];
 export declare const storedAccount: ({ orm }: StoreContext, { provider, account }: AccountKey) => StoredAccount;
 /** Everything the account holds, children before parents: the foreign keys are enforced. */
 export declare const purgeAccount: ({ orm, database }: StoreContext, accountKey: number) => void;
+export declare const unreferenced: (database: CacheDatabase, table: "identities") => Set<number>;
+/**
+ * People only the purged account had seen go with it. An identity stays while anything else points at it
+ * (another account, a tag, a note, a link), or while its person is kept: the owner, a person something
+ * points at, or one linked to an identity that stays.
+ */
+export declare const dropOrphanPeople: (database: CacheDatabase, unseenBefore: Set<number>) => void;

package/dist/store/sqlite/accounts.js

@@ -132,7 +132,7 @@ const referencesTo = (database, table, skip) => {
     const pointers = pointerPairs(database).map(({ table: tbl, pointer }) => `SELECT ${pointer}_id AS id FROM "${tbl}" WHERE ${pointer}_type = '${type}'`);
     return [...keys, ...pointers].join(" UNION ");
 };
-const unreferenced = (database, table) => new Set(database
+export const unreferenced = (database, table) => new Set(database
     .prepare(`SELECT id FROM ${table} WHERE id NOT IN (SELECT id FROM (${referencesTo(database, table, OWN)}) WHERE id IS NOT NULL)`)
     .all()
     .map(({ id }) => Number(id)));
@@ -141,7 +141,7 @@ const unreferenced = (database, table) => new Set(database
  * (another account, a tag, a note, a link), or while its person is kept: the owner, a person something
  * points at, or one linked to an identity that stays.
  */
-const dropOrphanPeople = (database, unseenBefore) => {
+export const dropOrphanPeople = (database, unseenBefore) => {
     const orphans = [...unreferenced(database, "identities")].filter((id) => !unseenBefore.has(id));
     if (orphans.length === 0)
         return;

package/dist/store/sqlite/calendar-forget.d.ts

@@ -0,0 +1,17 @@
+import type { CacheDatabase } from "../driver.js";
+/**
+ * `EventStore.forgetCalendar` inside its transaction: children before parents, since the foreign keys are enforced.
+ * `refresh` gives a kept event or series its fields again from the copies left.
+ */
+export declare const forgetCalendarRows: (database: CacheDatabase, { calendarId, accountId, cursorKey, now }: {
+    calendarId: number;
+    accountId: number;
+    cursorKey: string;
+    now: number;
+}, refresh: {
+    event: (id: number, now: number) => void;
+    series: (id: number, now: number) => void;
+}) => {
+    entries: number;
+    events: number;
+};

package/dist/store/sqlite/calendar-forget.js

@@ -0,0 +1,68 @@
+import { dropOrphanPeople, unreferenced } from "./accounts.js";
+import { dropUnusedVectors } from "./vector-index.js";
+const distinctIds = (rows) => [...new Set(rows.map((row) => Number(row.id)))];
+/**
+ * `EventStore.forgetCalendar` inside its transaction: children before parents, since the foreign keys are enforced.
+ * `refresh` gives a kept event or series its fields again from the copies left.
+ */
+export const forgetCalendarRows = (database, { calendarId, accountId, cursorKey, now }, refresh) => {
+    const unseenBefore = unreferenced(database, "identities");
+    const ids = (sql) => distinctIds(database.prepare(sql).all(calendarId));
+    const entryIds = ids("SELECT id FROM calendar_entries WHERE calendar_id = ?");
+    const eventIds = ids("SELECT event_id AS id FROM calendar_entries WHERE calendar_id = ? AND event_id IS NOT NULL");
+    const seriesIds = ids("SELECT event_series_id AS id FROM calendar_entries WHERE calendar_id = ? AND event_series_id IS NOT NULL");
+    const hashes = [];
+    const dropAround = (type, list) => {
+        const json = JSON.stringify(list);
+        const inList = "IN (SELECT value FROM json_each(?))";
+        for (const row of database
+            .prepare(`SELECT DISTINCT content_hash FROM chunks WHERE chunkable_type = ? AND chunkable_id ${inList}`)
+            .all(type, json))
+            hashes.push(String(row.content_hash));
+        database.prepare(`DELETE FROM chunks WHERE chunkable_type = ? AND chunkable_id ${inList}`).run(type, json);
+        database
+            .prepare(`DELETE FROM links WHERE (from_type = ? AND from_id ${inList}) OR (to_type = ? AND to_id ${inList})`)
+            .run(type, json, type, json);
+        for (const [table, pointer] of [
+            ["taggings", "taggable"],
+            ["aliases", "aliasable"],
+            ["attachments", "attachable"],
+            ["link_reviews", "linkable"],
+            ["entity_link_events", "linkable"],
+        ])
+            database.prepare(`DELETE FROM ${table} WHERE ${pointer}_type = ? AND ${pointer}_id ${inList}`).run(type, json);
+    };
+    const entries = JSON.stringify(entryIds);
+    for (const table of ["calendar_entry_participants", "calendar_entry_revisions"])
+        database.prepare(`DELETE FROM ${table} WHERE entry_id IN (SELECT value FROM json_each(?))`).run(entries);
+    dropAround("calendar_entry", entryIds);
+    // Occurrences point at their series in the same table: the pointers go first, so the order of rows is free.
+    database.prepare("UPDATE calendar_entries SET series_entry_id = NULL WHERE calendar_id = ?").run(calendarId);
+    database.prepare("DELETE FROM calendar_entries WHERE calendar_id = ?").run(calendarId);
+    const held = (column, id) => database.prepare(`SELECT 1 FROM calendar_entries WHERE ${column} = ? LIMIT 1`).get(id) !== undefined;
+    const goneSeries = seriesIds.filter((id) => !held("event_series_id", id));
+    const goneEvents = eventIds.filter((id) => !held("event_id", id));
+    const gone = (list) => JSON.stringify(list);
+    database
+        .prepare("UPDATE meetings SET event_id = NULL, updated_at = ? WHERE event_id IN (SELECT value FROM json_each(?))")
+        .run(now, gone(goneEvents));
+    dropAround("event", goneEvents);
+    database.prepare("DELETE FROM events WHERE id IN (SELECT value FROM json_each(?))").run(gone(goneEvents));
+    for (const table of ["meeting_series", "events"])
+        database
+            .prepare(`UPDATE ${table} SET event_series_id = NULL, updated_at = ? WHERE event_series_id IN (SELECT value FROM json_each(?))`)
+            .run(now, gone(goneSeries));
+    dropAround("event_series", goneSeries);
+    database.prepare("DELETE FROM event_series WHERE id IN (SELECT value FROM json_each(?))").run(gone(goneSeries));
+    for (const id of seriesIds)
+        if (!goneSeries.includes(id))
+            refresh.series(id, now);
+    for (const id of eventIds)
+        if (!goneEvents.includes(id))
+            refresh.event(id, now);
+    database.prepare("DELETE FROM sync_cursors WHERE account_id = ? AND key = ?").run(accountId, cursorKey);
+    database.prepare("DELETE FROM calendars WHERE id = ?").run(calendarId);
+    dropOrphanPeople(database, unseenBefore);
+    dropUnusedVectors(database, hashes);
+    return { entries: entryIds.length, events: goneEvents.length };
+};

package/dist/store/sqlite/calendar.js

@@ -1,6 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { calendarText, entryInWindow, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
 import { listEvents } from "./calendar-events.js";
+import { forgetCalendarRows } from "./calendar-forget.js";
 import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
 import { driveDocumentOf, driveFileTarget, logFileLink } from "./files.js";
 import { identityOf } from "./identities.js";
@@ -524,6 +525,13 @@ export const eventStoreOver = (context) => {
                 .prepare("UPDATE calendars SET synced = ?, updated_at = ? WHERE id = ?")
                 .run(flag(synced), now, calendarId);
         }),
+        forgetCalendar: async (calendarId, now) => write(database, () => {
+            const accountId = Number(calendarRow(calendarId).account_id);
+            return forgetCalendarRows(database, { calendarId, accountId, cursorKey: cursorKey(calendarId), now }, {
+                event: refreshEvent,
+                series: refreshSeries,
+            });
+        }),
         saveEntries: async (calendarId, entries, now) => write(database, () => saveAll(calendarId, entries, now)),
         removeEntries: async (calendarId, externalIds, now) => write(database, () => removeAll(calendarId, externalIds, now)),
         markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.547.0",
+  "version": "0.548.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",