@wirecat/cli-core 0.451.0 → 0.453.0

package/dist/services/person-context.js

@@ -44,6 +44,42 @@ const mailWith = async (store, key, address, limit, since) => {
     return { items, hasMore: emails.length > limit };
 };
 const newestFirst = (a, b) => Date.parse(b.timestamp) - Date.parse(a.timestamp);
+const iso = (at) => (at === null ? null : new Date(at).toISOString());
+const contextEvent = (event) => ({
+    ref: `event:${event.id}`,
+    title: event.title,
+    startsAt: iso(event.startsAt),
+    endsAt: iso(event.endsAt),
+    allDay: event.allDay === true,
+    location: event.location,
+    status: event.status ?? null,
+});
+const EVENT_PAGE = 100;
+/** A weekly meeting held for years is hundreds of occurrences; past this many rows the list stops, cut. */
+const EVENT_ROWS = 1000;
+/** Up to `limit` events of `filter`, in its order, the first occurrence of each series only and none cancelled. */
+const eventsOnce = async (store, filter, limit) => {
+    const items = [];
+    const series = new Set();
+    for (let offset = 0; offset < EVENT_ROWS; offset += EVENT_PAGE) {
+        const page = await store.calendar.events({ ...filter, limit: EVENT_PAGE, offset });
+        for (const event of page) {
+            if (event.status === "cancelled")
+                continue;
+            if (event.eventSeriesId !== null) {
+                if (series.has(event.eventSeriesId))
+                    continue;
+                series.add(event.eventSeriesId);
+            }
+            if (items.length === limit)
+                return { items, cut: true };
+            items.push(event);
+        }
+        if (page.length < EVENT_PAGE)
+            return { items, cut: false };
+    }
+    return { items, cut: true };
+};
 /**
  * The accounts each identity is read in: for the messenger asked, only the account asked about — a
  * second account of the same messenger is somebody else's view; for a linked messenger, every account
@@ -56,7 +92,7 @@ export const readsOf = (record, asked) => record.identities.flatMap((identity) =
  * What the store knows about one person, across every identity linked to them. Reads the store
  * only: nothing is fetched, nothing marked read. Identity is by id, never by name.
  */
-export const personContext = async (store, asked, reference, { messages = CONTEXT_MESSAGES, bytes = CONTEXT_BYTES, since } = {}) => {
+export const personContext = async (store, asked, reference, { messages = CONTEXT_MESSAGES, bytes = CONTEXT_BYTES, since, now = Date.now() } = {}) => {
     const found = pickPerson(reference, await store.people.people(asked.provider, { account: asked.account }));
     const record = await store.people.personOf({ provider: asked.provider, id: found.id });
     if (!record)
@@ -121,6 +157,11 @@ export const personContext = async (store, asked, reference, { messages = CONTEX
             .filter(recent));
         cut ||= named.hasMore;
     }
+    const personId = Number(record.uid);
+    const upcoming = await eventsOnce(store, { personId, from: now }, messages);
+    const upcomingIds = new Set(upcoming.items.map(({ id }) => id));
+    const past = await eventsOnce(store, { personId, to: now, newest: true, ...(since === undefined ? {} : { from: since }) }, messages);
+    cut ||= upcoming.cut || past.cut;
     direct.sort(newestFirst);
     const each = [...direct, ...beyond].sort(newestFirst);
     theirs.sort(newestFirst);
@@ -145,6 +186,10 @@ export const personContext = async (store, asked, reference, { messages = CONTEX
         },
         recent: { direct: kept.direct, groups: kept.groups },
         mentions: kept.mentions,
+        events: {
+            upcoming: upcoming.items.map(contextEvent),
+            recent: past.items.filter(({ id }) => !upcomingIds.has(id)).map(contextEvent),
+        },
         limits: { messages, bytes },
         hasMore: cut || kept.cut,
         complete: notRead.length === 0,

package/dist/services/search-all-meetings.d.ts

@@ -3,7 +3,7 @@ import type { AccountKey, MessageStore } from "../store/store.js";
 import type { SearchFound, SearchQuery } from "./messages.js";
 import type { MeaningLane } from "./messages-discovery.js";
 import { type SearchAllFound, type SearchAllItem, type SearchAllMessenger, type SearchAllRequest, type Skipped } from "./search-all.js";
-export declare const RESOURCES_SEARCHED_WITH_MEETINGS: readonly ["messages", "mail", "notes", "meetings"];
+export declare const RESOURCES_SEARCHED_WITH_MEETINGS: readonly ["messages", "mail", "notes", "events", "meetings"];
 export type ResourceWithMeetings = (typeof RESOURCES_SEARCHED_WITH_MEETINGS)[number];
 export interface MeetingSearchItem {
     kind: "meeting";

package/dist/services/search-all-meetings.js

@@ -131,7 +131,7 @@ export const searchAllIncludingMeetings = async (store, account, request, messen
     const only = request.only ?? RESOURCES_SEARCHED_WITH_MEETINGS;
     if (!only.length ||
         only.some((resource) => !RESOURCES_SEARCHED_WITH_MEETINGS.includes(resource)))
-        throw new CliError("validation_error", "only takes messages, mail, notes and meetings");
+        throw new CliError("validation_error", "only takes messages, mail, notes, events and meetings");
     if (request.meetingCursor) {
         if (only.length !== 1 || only[0] !== "meetings")
             throw new CliError("validation_error", "meeting cursor requires only: [meetings]");
@@ -261,7 +261,12 @@ const searchAllOfSource = async (store, account, source, request, messenger, sea
     const found = await searchAllIncludingMeetings(store, account, {
         ...request,
         only: read,
-        scope: { messages: named("messages"), mail: named("mail"), notes: named("notes") },
+        scope: {
+            messages: named("messages"),
+            mail: named("mail"),
+            notes: named("notes"),
+            events: named("events"),
+        },
         ...(meetings[0] ? { meetingAccount: meetings[0] } : {}),
     }, messenger, searchMessages, meaning);
     const unnamed = only

package/dist/services/search-all.d.ts

@@ -5,16 +5,16 @@ import type { AccountKey, MessageStore } from "../store/store.js";
 import type { SearchFound, SearchQuery } from "./messages.js";
 import { type MeaningLane, type MeaningSkipped } from "./messages-discovery.js";
 import type { Backend, ServerOptions, ServerSearched } from "./server-search.js";
-export declare const RESOURCES_SEARCHED: readonly ["messages", "mail", "notes"];
+export declare const RESOURCES_SEARCHED: readonly ["messages", "mail", "notes", "events"];
 export type SearchedResource = (typeof RESOURCES_SEARCHED)[number];
 export interface SearchAllItem {
-    kind: "message" | "mail" | "note" | "document";
-    /** `msg:…` for a message or a mail, `note:…` for a note. */
+    kind: "message" | "mail" | "note" | "document" | "event";
+    /** `msg:…` for a message or a mail, `note:…` for a note, `event:…` for a calendar event. */
     ref: string;
     provider: string;
     /** The account it was found in; a note's folder id, or `internal` for a note written in memo. */
     account: string;
-    /** The chat, the mail thread's subject or the note's title. */
+    /** The chat, the mail thread's subject, the note's or the event's title. */
     url?: string;
     title: string | null;
     timestamp: string;
@@ -63,6 +63,11 @@ export interface SearchAllFound {
         by: "words" | "words and meaning";
         meaningSkipped?: string;
     };
+    /** How calendar events were searched, when they were. */
+    events?: {
+        by: "words" | "words and meaning";
+        meaningSkipped?: string;
+    };
     /** How the messages were searched, when they were; never by meaning with `exact` or the server alone. */
     messages?: {
         by: "words" | "words and meaning";
@@ -79,7 +84,7 @@ export interface SearchAllRequest {
     only?: readonly SearchedResource[];
     exact?: boolean;
     timezone?: string;
-    /** For messages only; mail and notes are always the local store's. */
+    /** For messages only; mail, notes and events are always the local store's. */
     backend?: Backend;
     server?: ServerOptions;
     env?: NodeJS.ProcessEnv;
@@ -95,8 +100,8 @@ export type SearchAllMessenger = Partial<Pick<MessengerTraits, "savedChatId" | "
     hintCommand?: string | null;
 };
 /**
- * `search all`: messages, mail and notes from the local store — messages also from the messenger's
+ * `search all`: messages, mail, notes and calendar events from the local store — messages also from the messenger's
  * server, as `search messages` asks it — each list best first, merged by reciprocal rank so no
- * resource's own scores have to be compared with another's.
+ * resource's own scores have to be compared with another's. Events are read only when the store holds a calendar.
  */
 export declare const searchAll: (store: MessageStore, account: AccountKey, request: SearchAllRequest, messenger?: SearchAllMessenger, searchMessages?: (query: SearchQuery) => Promise<SearchFound>, meaning?: MeaningLane) => Promise<SearchAllFound>;

package/dist/services/search-all.js

@@ -6,11 +6,12 @@ import { runEmbedders } from "../embeddings/embed.js";
 import { DEFAULT_TEXT_MODEL } from "../embeddings/models.js";
 import { MESSAGE_PARSING } from "../search/lucene/types.js";
 import { planQuestion } from "../search/question-plan.js";
+import { calendarAccounts, searchEvents } from "./events-search.js";
 import { excerpt } from "./excerpt.js";
 import { MAX_SEARCH_OFFSET, searchStore } from "./messages-archive-search.js";
 import { nearEligible } from "./messages-discovery.js";
 import { notesScopeOf, RRF_K, searchNotes } from "./notes-search.js";
-export const RESOURCES_SEARCHED = ["messages", "mail", "notes"];
+export const RESOURCES_SEARCHED = ["messages", "mail", "notes", "events"];
 /** A query a resource cannot answer is skipped with its reason, never a failure of the whole search. */
 const skippable = (error) => error instanceof CliError && (error.code === "validation_error" || error.code === "not_found");
 /**
@@ -28,9 +29,9 @@ const filtersBeside = (text) => {
         : undefined;
 };
 /**
- * `search all`: messages, mail and notes from the local store — messages also from the messenger's
+ * `search all`: messages, mail, notes and calendar events from the local store — messages also from the messenger's
  * server, as `search messages` asks it — each list best first, merged by reciprocal rank so no
- * resource's own scores have to be compared with another's.
+ * resource's own scores have to be compared with another's. Events are read only when the store holds a calendar.
  */
 export const searchAll = async (store, account, request, messenger = {}, searchMessages = (query) => searchStore(store, account, query, messenger), meaning) => {
     if (!request.text.trim())
@@ -48,6 +49,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
     const skipped = [];
     let hasMore = false;
     let notes;
+    let events;
     let messagesBy;
     let server;
     const messagesOf = async (kind) => {
@@ -133,7 +135,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         });
         return [...fused.values()].sort((a, b) => b.score - a.score).map(({ item }) => item);
     };
-    // Messages and notes both look up by meaning with the same model: loading it costs most of a second.
+    // Messages, notes and events all look up by meaning with the same model: loading it costs most of a second.
     const embedders = runEmbedders();
     try {
         for (const resource of only) {
@@ -172,6 +174,38 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
                     ];
                     accounts.push(...read.map((account) => ({ resource, provider: "notes", account })));
                 }
+                else if (resource === "events") {
+                    const read = request.scope?.events ?? (await calendarAccounts(store));
+                    if (!read.length)
+                        continue;
+                    const found = await searchEvents(store, request.text, {
+                        limit: window,
+                        accounts: read,
+                        embedders,
+                        ...(command === undefined ? {} : { command }),
+                        ...(request.env === undefined ? {} : { env: request.env }),
+                        ...(request.exact ? { exact: true } : {}),
+                        ...(request.timezone === undefined ? {} : { timezone: request.timezone }),
+                        ...(request.signal === undefined ? {} : { signal: request.signal }),
+                    });
+                    hasMore ||= found.has_more;
+                    events = {
+                        by: found.by,
+                        ...(found.meaning_skipped === undefined ? {} : { meaningSkipped: found.meaning_skipped }),
+                    };
+                    lists.push(found.hits.map((hit) => ({
+                        kind: "event",
+                        ref: hit.ref,
+                        provider: hit.provider ?? "calendar",
+                        account: hit.account ?? "",
+                        ...(hit.url ? { url: hit.url } : {}),
+                        title: hit.title,
+                        timestamp: hit.starts_at ?? hit.updated_at,
+                        text: hit.excerpt,
+                        foundBy: hit.found_by,
+                    })));
+                    accounts.push(...read.map(({ provider, account }) => ({ resource, provider, account })));
+                }
                 else
                     lists.push(await messagesOf(resource));
                 searched.push(resource);
@@ -204,6 +238,7 @@ export const searchAll = async (store, account, request, messenger = {}, searchM
         accounts,
         skipped,
         ...(notes === undefined ? {} : { notes }),
+        ...(events === undefined ? {} : { events }),
         ...(messagesBy === undefined ? {} : { messages: messagesBy }),
         ...(server === undefined ? {} : { server }),
     };

package/dist/store/index.d.ts

@@ -30,6 +30,7 @@ export type { CatalogActor, CatalogEntry, CatalogInput, CatalogQuery, CatalogSto
 export { CATALOG_QUERY } from "./sqlite/catalog.js";
 export type { ChatMetadata } from "./sqlite/chats.js";
 export type { Email, EmailAddress, EmailAttachment, EmailFacts, EmailFilter, EmailInput, EmailInThread, EmailRecipient, EmailRef, EmailThread, EmailVectorHit, Mailbox, MailboxInput, MailFilter, MailStore, SenderScore, ThreadDetails, ThreadSave, } from "./sqlite/emails.js";
+export { EVENT_FIELDS, type EventChunkToEmbed, type EventHit, type EventQuery, type EventSearch, type NearestEvent, } from "./sqlite/event-search.js";
 export type { Fact, FactInput, FactsStore } from "./sqlite/facts.js";
 export type { FileListQuery, FilesStore, StoredFile } from "./sqlite/files.js";
 export { IMPORTED_DOCUMENT_QUERY, type ImportedDocuments } from "./sqlite/imported-documents.js";

package/dist/store/index.js

@@ -16,6 +16,7 @@ export { planProjectAnnotationSnapshot } from "./project-transfer/snapshot-plan.
 export { resetAttachmentWords } from "./sqlite/attachment-texts.js";
 export { backfillNormalized, pendingNormalization } from "./sqlite/backfill.js";
 export { CATALOG_QUERY } from "./sqlite/catalog.js";
+export { EVENT_FIELDS, } from "./sqlite/event-search.js";
 export { IMPORTED_DOCUMENT_QUERY } from "./sqlite/imported-documents.js";
 export { ORGANIZATION_KINDS, PROJECT_TYPES, SCOPES } from "./sqlite/knowledge.js";
 export { NOTE_FIELDS, } from "./sqlite/note-search.js";

package/dist/store/project-transfer/request.d.ts

@@ -22,7 +22,7 @@ export declare const projectAnnotationRequest: (request: ProjectAnnotationTarget
             ref: string;
             from: string;
             to: string | null;
-            kind: "about" | "answered-by" | "assigned-to" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
+            kind: "about" | "answered-by" | "assigned-to" | "attached" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
             origin: "file" | "message" | "owner" | "suggested";
             anchor: string | null;
             target_text: string | null;

package/dist/store/project-transfer/schema.d.ts

@@ -56,7 +56,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
         readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message"], undefined>;
         readonly anchor: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly target_text: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -71,7 +71,7 @@ export declare const projectAnnotationsSchema: v.StrictObjectSchema<{
         ref: string;
         from: string;
         to: string | null;
-        kind: "about" | "answered-by" | "assigned-to" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
+        kind: "about" | "answered-by" | "assigned-to" | "attached" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
         origin: "file" | "message" | "owner" | "suggested";
         anchor: string | null;
         target_text: string | null;

package/dist/store/project-transfer/snapshot-model.d.ts

@@ -37,7 +37,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly from: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>;
         readonly to: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
-        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"], undefined>;
+        readonly kind: v.PicklistSchema<readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"], undefined>;
         readonly origin: v.PicklistSchema<readonly ["file", "owner", "suggested", "message"], undefined>;
         readonly anchor: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
         readonly target_text: v.NullableSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>, v.MaxLengthAction<string, number, undefined>]>, undefined>;
@@ -52,7 +52,7 @@ export declare const projectAnnotationSnapshotSchema: v.StrictObjectSchema<{
         ref: string;
         from: string;
         to: string | null;
-        kind: "about" | "answered-by" | "assigned-to" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
+        kind: "about" | "answered-by" | "assigned-to" | "attached" | "blocked-by" | "created-from" | "duplicate-of" | "evidence" | "follow-up-of" | "labelled" | "links-to" | "member-of" | "related-to";
         origin: "file" | "message" | "owner" | "suggested";
         anchor: string | null;
         target_text: string | null;

package/dist/store/sqlite/calendar.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { calendarText, entryMetadata, joinKeyOf, joinUrlWithoutQuery, } from "../../meetings/index.js";
 import { bool, eventOf, fromJson, int, str, toJson } from "./events.js";
-import { logFileLink } from "./files.js";
+import { driveDocumentOf, driveFileTarget, logFileLink } from "./files.js";
 import { identityOf } from "./identities.js";
 import { reviewLink } from "./link-reviews.js";
 import { read, write } from "./transaction.js";
@@ -86,6 +86,12 @@ const reviewOf = (row) => ({
     decidedAt: int(row.decided_at),
     createdAt: Number(row.created_at),
 });
+const attachmentOf = (row) => ({
+    entryId: Number(row.from_id),
+    fileId: String(row.target_text).slice(driveFileTarget("").length),
+    title: str(fromJson(row.metadata)?.title),
+    documentId: int(row.to_id),
+});
 const TRACKED = ["title", "starts_at", "ends_at", "location", "status", "recurrence", "recurrence_ends_at"];
 const flag = (value) => (value ? 1 : 0);
 const addressOf = (email) => email.trim().toLowerCase();
@@ -204,17 +210,34 @@ export const eventStoreOver = (context) => {
             return;
         setEntity(entry, newEntity(entry, now), "new", "rules", now);
     };
-    /** The event's fields from its preferred entry: the owner's copy when the owner organizes, else the latest. */
+    /**
+     * The event's fields from its preferred entry: a copy with text before one without (a busy-only slot), then the
+     * owner's copy when the owner organizes, then the latest. With no live copy left, a past event stays as history
+     * and a future one is cancelled.
+     */
     const refreshEvent = (eventId, now) => {
+        // Search reads the event's status and its copies' visibility, which no index trigger watches.
+        database.prepare("INSERT OR IGNORE INTO event_index_pending (indexable_type, id) VALUES ('event', ?)").run(eventId);
         const entries = database
             .prepare(`SELECT ce.*, EXISTS (SELECT 1 FROM calendar_entry_participants p WHERE p.entry_id = ce.id AND p.self = 1
            AND p.organizer = 1) AS own FROM calendar_entries ce WHERE ce.event_id = ? AND ce.deleted_at IS NULL
-         ORDER BY own DESC, coalesce(ce.external_updated_at, ce.updated_at) DESC, ce.id DESC`)
+         ORDER BY trim(coalesce(ce.title, '') || coalesce(ce.description, '') || coalesce(ce.location, '')) <> '' DESC,
+           own DESC, coalesce(ce.external_updated_at, ce.updated_at) DESC, ce.id DESC`)
             .all(eventId);
         const preferred = entries[0];
-        if (!preferred)
-            return;
         const event = database.prepare("SELECT * FROM events WHERE id = ?").get(eventId);
+        if (!preferred) {
+            if (!event || !database.prepare("SELECT 1 FROM calendar_entries WHERE event_id = ?").get(eventId))
+                return;
+            const startsAt = int(event.starts_at);
+            if (startsAt !== null && startsAt < now)
+                database
+                    .prepare("UPDATE events SET source_deleted_at = coalesce(source_deleted_at, ?), updated_at = ? WHERE id = ?")
+                    .run(now, now, eventId);
+            else
+                database.prepare("UPDATE events SET status = 'cancelled', updated_at = ? WHERE id = ?").run(now, eventId);
+            return;
+        }
         const cancelled = entries.every((row) => row.status === "cancelled");
         const series = preferred.series_entry_id == null ? null : entryRow(Number(preferred.series_entry_id));
         const startsAt = int(preferred.starts_at) ?? int(event.starts_at);
@@ -259,6 +282,42 @@ export const eventStoreOver = (context) => {
         for (const email of stale)
             drop.run(entryId, email);
     };
+    /**
+     * The entry's Drive files as `attached` links: the list given replaces the one held. A link still waiting for its
+     * document tries again, since the file may have become one account's since.
+     */
+    const saveAttachments = (entryId, attachments, now) => {
+        const held = new Map(database
+            .prepare("SELECT id, target_text, to_id FROM links WHERE from_type = 'calendar_entry' AND from_id = ? AND kind = 'attached'")
+            .all(entryId)
+            .map((row) => [String(row.target_text), { id: Number(row.id), documentId: int(row.to_id) }]));
+        const insert = database.prepare(`INSERT INTO links (from_type, from_id, to_type, to_id, kind, source, target_text, metadata, confirmed, author,
+         created_at, updated_at) VALUES ('calendar_entry', ?, 'document', ?, 'attached', 'calendar', ?, ?, 1, 'rule', ?, ?)`);
+        const retitle = database.prepare("UPDATE links SET metadata = ?, updated_at = ? WHERE id = ? AND metadata IS NOT ?");
+        const resolve = database.prepare("UPDATE links SET to_id = ?, updated_at = ? WHERE id = ?");
+        const handled = new Set();
+        for (const { fileId, title } of attachments) {
+            const file = fileId.trim();
+            const target = driveFileTarget(file);
+            if (!file || handled.has(target))
+                continue;
+            handled.add(target);
+            const metadata = title ? JSON.stringify({ title }) : null;
+            const link = held.get(target);
+            if (link === undefined)
+                insert.run(entryId, driveDocumentOf(database, file), target, metadata, now, now);
+            else {
+                retitle.run(metadata, now, link.id, metadata);
+                const document = link.documentId === null ? driveDocumentOf(database, file) : null;
+                if (document !== null)
+                    resolve.run(document, now, link.id);
+            }
+            held.delete(target);
+        }
+        const drop = database.prepare("DELETE FROM links WHERE id = ?");
+        for (const { id } of held.values())
+            drop.run(id);
+    };
     /** Rules 1 and 2: the row this entry already is, if any. */
     const existingFor = (calendarId, input, seriesEntryId) => {
         const same = database
@@ -351,6 +410,8 @@ export const eventStoreOver = (context) => {
         }
         if (input.participants)
             saveParticipants(id, input.participants, now);
+        if (input.attachments)
+            saveAttachments(id, input.attachments, now);
         if (input.kind === "series")
             database
                 .prepare("UPDATE calendar_entries SET series_entry_id = ?, updated_at = ? WHERE calendar_id = ? AND kind = 'occurrence' " +
@@ -421,11 +482,18 @@ export const eventStoreOver = (context) => {
             }
             return entries.map((input) => entryOf(entryRow(ids.get(input))));
         }),
-        markUnseen: async (calendarId, seenBefore, window, now) => write(database, () => database
-            .prepare(`UPDATE calendar_entries SET deleted_at = ?, updated_at = ? WHERE calendar_id = ? AND deleted_at IS NULL
-                 AND (seen_at IS NULL OR seen_at < ?)
-                 AND (kind <> 'occurrence' OR exception = 1 OR (original_starts_at >= ? AND original_starts_at < ?))`)
-            .run(now, now, calendarId, seenBefore, window.from, window.to).changes),
+        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
+               AND (seen_at IS NULL OR seen_at < ?)
+               AND (kind <> 'occurrence' OR exception = 1 OR (original_starts_at >= ? AND original_starts_at < ?))
+             RETURNING event_id`)
+                .all(now, now, calendarId, seenBefore, window.from, window.to);
+            for (const eventId of new Set(marked.map((row) => int(row.event_id))))
+                if (eventId !== null)
+                    refreshEvent(eventId, now);
+            return marked.length;
+        }),
         events: async (filter = {}) => {
             const clauses = ["e.deleted_at IS NULL"];
             const params = [];
@@ -456,7 +524,7 @@ export const eventStoreOver = (context) => {
             if (!Number.isInteger(limit) || limit < 1 || limit > 1000 || !Number.isInteger(offset) || offset < 0)
                 throw new CliError("validation_error", "limit takes 1–1000 and offset 0 or more");
             return database
-                .prepare(`SELECT e.* FROM events e WHERE ${clauses.join(" AND ")} ORDER BY e.starts_at, e.id LIMIT ? OFFSET ?`)
+                .prepare(`SELECT e.* FROM events e WHERE ${clauses.join(" AND ")} ORDER BY ${filter.newest ? "e.starts_at DESC, e.id DESC" : "e.starts_at, e.id"} LIMIT ? OFFSET ?`)
                 .all(...params, limit, offset)
                 .map(eventOf);
         },
@@ -480,6 +548,12 @@ export const eventStoreOver = (context) => {
                     .prepare("SELECT * FROM calendar_entry_revisions WHERE entry_id IN (SELECT value FROM json_each(?)) ORDER BY created_at, id")
                     .all(ids)
                     .map(revisionOf),
+                attachments: database
+                    .prepare("SELECT l.from_id, l.target_text, CASE WHEN d.deleted_at IS NULL THEN l.to_id END AS to_id, l.metadata " +
+                    "FROM links l LEFT JOIN documents d ON d.id = l.to_id WHERE l.from_type = 'calendar_entry' " +
+                    "AND l.kind = 'attached' AND l.from_id IN (SELECT value FROM json_each(?)) ORDER BY l.from_id, l.id")
+                    .all(ids)
+                    .map(attachmentOf),
             };
         }),
         linkEntry: async (entryId, eventId, now) => write(database, () => {

package/dist/store/sqlite/event-search.d.ts

@@ -0,0 +1,66 @@
+import type { Event } from "../../meetings/index.js";
+import { type NoteIndexState } from "./note-index.js";
+import { type CorpusQuery } from "./note-search.js";
+import type { StoreContext } from "./open.js";
+/** The fields an event has; a message or note field is refused rather than matching nothing. */
+export declare const EVENT_FIELDS: readonly ["text", "exact", "body", "title", "date", "in"];
+/**
+ * `accountIds` are stored account ids; `limit` and `offset` count hits, one per series. `candidates` is how many
+ * matching events are read before they are grouped (50,000 by default).
+ */
+export type EventQuery = CorpusQuery & {
+    candidates?: number;
+};
+export interface EventHit {
+    /** `event:<id>`, of the occurrence shown. */
+    ref: string;
+    /** The occurrence shown: of a series' matches, the one nearest now that is not cancelled. */
+    event: Event;
+    /** What the words were matched in besides the title: description, place, attendees. */
+    text: string;
+    /** bm25 of the words or stems; lower is better. `null` when ranked by time. */
+    relevance: number | null;
+    exact?: boolean;
+    /** How many occurrences of its series matched; 1 for an event that does not repeat. */
+    occurrences: number;
+    /** The calendar account it is in, the first of several; `null` for an event no calendar holds (a Zoom one). */
+    account: {
+        provider: string;
+        account: string;
+    } | null;
+    /** The event's page at the calendar. */
+    url: string | null;
+}
+export interface EventChunkToEmbed {
+    hash: string;
+    text: string;
+}
+export interface NearestEvent extends Omit<EventHit, "relevance" | "exact"> {
+    /** Cosine of the best piece of its series; higher is nearer. */
+    score: number;
+}
+export interface EventSearch {
+    /** Indexes what was written since, then searches: the occurrences of one series are one hit. */
+    search(query: EventQuery): Promise<{
+        items: EventHit[];
+        hasMore: boolean;
+        /** More events matched than `candidates`: the ones past it were not read, so the last page may not be the end. */
+        truncated: boolean;
+    }>;
+    eventIndexState(): Promise<NoteIndexState>;
+    /** Live events' pieces with no vector of `model`, by hash from `after`, each with its text cut again. */
+    chunksToEmbed(model: string, options: {
+        after?: string;
+        limit: number;
+    }): Promise<EventChunkToEmbed[]>;
+    /** Whether any live event with a searchable copy in these accounts has a vector of `model`. */
+    embedded(model: string, options?: {
+        accountIds?: string[];
+    }): Promise<boolean>;
+    /** Events nearest in meaning to `query`, one hit per series, best first. Vectors are unit length. */
+    nearest(model: string, query: Float32Array, options: {
+        limit: number;
+        accountIds?: string[];
+    }): Promise<NearestEvent[]>;
+}
+export declare const eventSearchOver: (context: StoreContext) => EventSearch;