@wirecat/cli-core 0.452.0 → 0.453.0

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;

package/dist/store/sqlite/event-search.js

@@ -0,0 +1,163 @@
+import { QUERY_LIMITS } from "../../search/lucene/types.js";
+import { eventOf } from "./events.js";
+import { CORPORA, corpusIndexState, drainCorpus, EVENT_LIVE, EVENT_TEXT, noteIndexText, searchableCopy, } from "./note-index.js";
+import { searchCorpus } from "./note-search.js";
+import { stemmerCache } from "./stems.js";
+import { read } from "./transaction.js";
+import { dot } from "./vectors.js";
+/** The fields an event has; a message or note field is refused rather than matching nothing. */
+export const EVENT_FIELDS = ["text", "exact", "body", "title", "date", "in"];
+/**
+ * Whether the event `event` (an SQL expression of its id) has a searchable copy in the accounts of the one parameter,
+ * a JSON list of stored account ids. Words and meaning both filter by it, so an event held in several accounts is
+ * found through each of them.
+ */
+const inEventAccounts = (event) => searchableCopy(event, "c.account_id IN (SELECT CAST(value AS INTEGER) FROM json_each(?))");
+const EVENT_CORPUS = {
+    type: "event",
+    noun: "event",
+    fields: EVENT_FIELDS,
+    view: `(SELECT e.id, NULL AS folder_id, NULL AS path, e.title, ${EVENT_TEXT} AS text, NULL AS metadata, ` +
+        `e.starts_at AS at, e.deleted_at, ${EVENT_LIVE} AS live FROM events e)`,
+    words: "event_words",
+    stems: "event_stems",
+    live: "n.live = 1",
+    inAccounts: (ids) => ({
+        sql: inEventAccounts("n.id"),
+        params: [ids],
+        exact: true,
+    }),
+};
+const SCAN_PAGE = 5_000;
+export const eventSearchOver = (context) => {
+    const { database } = context;
+    const stemmerFor = stemmerCache();
+    const drain = () => drainCorpus(database, CORPORA.event, stemmerFor);
+    /** The live event pieces with a searchable copy in these accounts, as SQL over chunks `k`. */
+    const live = (accountIds) => {
+        const sql = ` AND k.chunkable_type = 'event' AND EXISTS (SELECT 1 FROM events e WHERE e.id = k.chunkable_id AND ${EVENT_LIVE})`;
+        return accountIds?.length
+            ? { sql: `${sql} AND ${inEventAccounts("k.chunkable_id")}`, params: [JSON.stringify(accountIds)] }
+            : { sql, params: [] };
+    };
+    /** Events in rank order, as hits: one per series, at its occurrence nearest now that is not cancelled. */
+    const grouped = (rows, accountIds) => {
+        const facts = new Map(database
+            .prepare("SELECT id, event_series_id AS series, starts_at, status FROM events WHERE id IN (SELECT value FROM json_each(?))")
+            .all(JSON.stringify(rows.map(({ id }) => id)))
+            .map((row) => [Number(row.id), row]));
+        const groups = new Map();
+        for (const row of rows) {
+            const fact = facts.get(row.id);
+            if (!fact)
+                continue;
+            const key = fact.series == null ? `e${row.id}` : `s${fact.series}`;
+            const group = groups.get(key) ?? { first: row, members: [] };
+            group.members.push(fact);
+            groups.set(key, group);
+        }
+        const now = context.now();
+        const nearest = (members) => members.toSorted((a, b) => Number(a.status === "cancelled") - Number(b.status === "cancelled") ||
+            Math.abs(Number(a.starts_at ?? 0) - now) - Math.abs(Number(b.starts_at ?? 0) - now) ||
+            Number(a.id) - Number(b.id))[0];
+        const event = database.prepare(`SELECT e.*, ${EVENT_TEXT} AS text FROM events e WHERE e.id = ?`);
+        const place = database.prepare("SELECT a.provider, a.external_id AS account, ce.url FROM calendar_entries ce " +
+            "JOIN calendars c ON c.id = ce.calendar_id JOIN accounts a ON a.id = c.account_id " +
+            "WHERE ce.event_id = ? " +
+            "ORDER BY c.account_id NOT IN (SELECT CAST(value AS INTEGER) FROM json_each(?)), ce.deleted_at IS NOT NULL, ce.id LIMIT 1");
+        const chosen = JSON.stringify(accountIds ?? []);
+        return [...groups.values()].map(({ first, members }) => {
+            const id = Number(nearest(members).id);
+            const row = event.get(id);
+            const at = place.get(id, chosen);
+            return {
+                first,
+                hit: {
+                    ref: `event:${id}`,
+                    event: eventOf(row),
+                    text: String(row.text ?? ""),
+                    occurrences: members.length,
+                    account: at ? { provider: String(at.provider), account: String(at.account) } : null,
+                    url: at?.url == null ? null : String(at.url),
+                },
+            };
+        });
+    };
+    return {
+        search: async (query) => {
+            drain();
+            const offset = query.offset ?? 0;
+            const candidates = query.candidates ?? QUERY_LIMITS.candidates;
+            const matched = searchCorpus(context, { ...query, limit: candidates, offset: 0 }, EVENT_CORPUS);
+            const truncated = matched.length > candidates;
+            const rows = truncated ? matched.slice(0, candidates) : matched;
+            return read(database, () => {
+                const groups = grouped(rows, query.accountIds);
+                return {
+                    items: groups.slice(offset, offset + query.limit).map(({ first, hit }) => ({
+                        ...hit,
+                        relevance: first.relevance,
+                        ...(first.exact === undefined ? {} : { exact: first.exact }),
+                    })),
+                    hasMore: groups.length > offset + query.limit,
+                    truncated,
+                };
+            });
+        },
+        eventIndexState: async () => corpusIndexState(database, CORPORA.event),
+        chunksToEmbed: async (model, { after, limit }) => {
+            drain();
+            const scope = live(undefined);
+            const text = database.prepare(`SELECT e.title, ${EVENT_TEXT} AS body FROM events e WHERE e.id = ?`);
+            return database
+                .prepare(`SELECT k.content_hash AS hash, min(k.chunkable_id) AS owner, k.start_offset AS start, k.end_offset AS end
+             FROM chunks k
+            WHERE k.content_hash > ?${scope.sql}
+              AND NOT EXISTS (SELECT 1 FROM embeddings v WHERE v.model = ? AND v.content_hash = k.content_hash)
+            GROUP BY k.content_hash ORDER BY k.content_hash LIMIT ?`)
+                .all(after ?? "", ...scope.params, model, limit)
+                .flatMap((row) => {
+                const event = text.get(Number(row.owner));
+                if (!event)
+                    return [];
+                const whole = noteIndexText(event.title == null ? null : String(event.title), String(event.body));
+                return [{ hash: String(row.hash), text: whole.slice(Number(row.start), Number(row.end)) }];
+            });
+        },
+        embedded: async (model, { accountIds } = {}) => {
+            drain();
+            const scope = live(accountIds);
+            return (database
+                .prepare(`SELECT 1 FROM chunks k JOIN embeddings v ON v.model = ? AND v.content_hash = k.content_hash
+              WHERE 1 = 1${scope.sql} LIMIT 1`)
+                .get(model, ...scope.params) !== undefined);
+        },
+        nearest: async (model, query, { limit, accountIds }) => {
+            drain();
+            const scope = live(accountIds);
+            const page = database.prepare(`SELECT k.id, k.chunkable_id AS owner, v.vector
+           FROM chunks k JOIN embeddings v ON v.model = ? AND v.content_hash = k.content_hash
+          WHERE k.id > ?${scope.sql}
+          ORDER BY k.id LIMIT ?`);
+            const best = new Map();
+            let after = 0;
+            for (;;) {
+                const rows = page.all(model, after, ...scope.params, SCAN_PAGE);
+                for (const row of rows) {
+                    const score = dot(query, row.vector);
+                    const owner = Number(row.owner);
+                    if (score > (best.get(owner) ?? Number.NEGATIVE_INFINITY))
+                        best.set(owner, score);
+                }
+                const last = rows.at(-1);
+                if (!last || rows.length < SCAN_PAGE)
+                    break;
+                after = Number(last.id);
+            }
+            const ranked = [...best.entries()].map(([id, score]) => ({ id, score })).sort((a, b) => b.score - a.score);
+            return read(database, () => grouped(ranked, accountIds)
+                .slice(0, limit)
+                .map(({ first, hit }) => ({ ...hit, score: first.score })));
+        },
+    };
+};

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

@@ -15,6 +15,10 @@ interface Placed {
 export declare const logFileLink: (database: CacheDatabase, now: number, fileId: number, from: unknown, to: number | null, method?: string, author?: string) => {
     changes: number;
 };
+/** How an `attached` link names a Drive file it waits for: by its Drive id, since no row may hold it yet. */
+export declare const driveFileTarget: (fileId: string) => string;
+/** The document of the Drive file with this id; `null` when no Drive account holds it, or two do. */
+export declare const driveDocumentOf: (database: CacheDatabase, fileId: string) => number | null;
 /**
  * Writes the `files` row of one document from the document as it is now: the document's source record. A Drive
  * document (catalog metadata or Drive front matter) is keyed by its Drive file id and placed under its first parent;