@wirecat/cli-core 0.452.0 → 0.454.0

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;

package/dist/store/sqlite/files.js

@@ -48,6 +48,30 @@ export const logFileLink = (database, now, fileId, from, to, method = "import",
     .prepare("INSERT INTO entity_link_events (linkable_type, linkable_id, entity_type, from_entity_id, to_entity_id, method, " +
     "confidence, author, created_at) VALUES ('file', ?, 'document', ?, ?, ?, 1, ?, ?)")
     .run(fileId, from == null ? null : Number(from), to, method, author, now);
+/** How an `attached` link names a Drive file it waits for: by its Drive id, since no row may hold it yet. */
+export const driveFileTarget = (fileId) => `google-drive:${fileId}`;
+/** The document of the Drive file with this id; `null` when no Drive account holds it, or two do. */
+export const driveDocumentOf = (database, fileId) => {
+    const rows = database
+        .prepare("SELECT DISTINCT f.document_id AS id FROM files f JOIN accounts a ON a.id = f.account_id WHERE a.provider = 'google-drive' " +
+        "AND f.external_id = ? AND f.deleted_at IS NULL AND f.document_id IS NOT NULL LIMIT 2")
+        .all(fileId);
+    return rows.length === 1 ? Number(rows[0]?.id) : null;
+};
+/** Calendar entries that named this Drive file before Drive stored it now link its document. */
+const linkAttached = (database, now, fileId) => {
+    const target = driveFileTarget(fileId);
+    if (!database
+        .prepare("SELECT 1 FROM links WHERE to_type = 'document' AND to_id IS NULL AND target_text = ? AND kind = 'attached'")
+        .get(target))
+        return;
+    const document = driveDocumentOf(database, fileId);
+    if (document !== null)
+        database
+            .prepare("UPDATE links SET to_id = ?, updated_at = ? WHERE to_type = 'document' AND to_id IS NULL AND target_text = ? " +
+            "AND kind = 'attached'")
+            .run(document, now, target);
+};
 /** Moves the rows under a folder whose path changed, in one statement over the old prefix. */
 const movePaths = (database, accountId, from, to) => {
     database
@@ -136,6 +160,8 @@ export const syncFile = (database, now, documentId, { seen = true, depth = 0, pl
             .get(...Object.values(values), Number(doc.created_at), now);
         const placed = { id: Number(row?.id), path };
         logFileLink(database, now, placed.id, null, documentId, method);
+        if (remote)
+            linkAttached(database, now, externalId);
         if (remote && kind === "folder")
             placeChildren(database, now, accountId, String(doc.external_id), depth);
         return placed;
@@ -152,6 +178,8 @@ export const syncFile = (database, now, documentId, { seen = true, depth = 0, pl
             .run(...Object.values(values), changed ? now : Number(existing.updated_at), id);
         if (kind === "folder" && existing.path !== path)
             movePaths(database, accountId, String(existing.path), path);
+        if (remote && changed)
+            linkAttached(database, now, externalId);
     }
     return { id, path };
 };

package/dist/store/sqlite/link-kinds.d.ts

@@ -2,8 +2,12 @@
  * Every kind a `links` row may have. The schema doc's description of `links` names exactly these
  * (`schema.test.ts` checks it); a writer that needs a new kind adds it here first.
  */
-export declare const LINK_KINDS: readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to"];
+export declare const LINK_KINDS: readonly ["links-to", "blocked-by", "follow-up-of", "about", "member-of", "labelled", "answered-by", "evidence", "created-from", "duplicate-of", "related-to", "assigned-to", "attached"];
 export type LinkKind = (typeof LINK_KINDS)[number];
+/** Where a caller may say a link came from. */
+export declare const LINK_ORIGINS: readonly ["file", "owner", "suggested", "message"];
+/** Where a stored link came from: an origin a caller gives, or `calendar`, which only the store writes. */
+export declare const LINK_SOURCES: readonly ["file", "owner", "suggested", "message", "calendar"];
 /** The kinds `knowledge.relate` makes between people, organizations and projects. */
 export declare const RELATION_KINDS: readonly ["member-of", "related-to"];
 /** A kind as an SQL literal, so a kind written into a query is checked against the list. */

package/dist/store/sqlite/link-kinds.js

@@ -15,7 +15,12 @@ export const LINK_KINDS = [
     "duplicate-of",
     "related-to",
     "assigned-to",
+    "attached",
 ];
+/** Where a caller may say a link came from. */
+export const LINK_ORIGINS = ["file", "owner", "suggested", "message"];
+/** Where a stored link came from: an origin a caller gives, or `calendar`, which only the store writes. */
+export const LINK_SOURCES = [...LINK_ORIGINS, "calendar"];
 /** The kinds `knowledge.relate` makes between people, organizations and projects. */
 export const RELATION_KINDS = ["member-of", "related-to"];
 /** A kind as an SQL literal, so a kind written into a query is checked against the list. */

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

@@ -31,6 +31,23 @@ export interface Corpus {
         stems: string;
     };
 }
+/** What an event `e` is searched by besides its title: the cleaned description, the place and the attendees' names. */
+export declare const EVENT_TEXT: string;
+/** Calendar entry types that are listed, never searched (requirements 3.4). */
+export declare const UNSEARCHED_EVENT_TYPES: readonly ["workingLocation", "focusTime", "outOfOffice", "birthday"];
+/** Visibilities whose entry, when it carries no text, is a busy-only slot: stored, never searched (requirements 3.4). */
+export declare const BUSY_ONLY_VISIBILITIES: readonly ["private", "confidential"];
+/**
+ * Whether the event `event` (an SQL expression of its id) has a searchable calendar copy, and with `account` one in
+ * those accounts (an SQL condition over `c.account_id`). Only live copies count, unless none is: an event its
+ * calendars deleted keeps its past copies as history.
+ */
+export declare const searchableCopy: (event: string, account?: string) => string;
+/**
+ * Whether an event `e` is searched at all: by words, by meaning and in `search all`. The one place that names what
+ * is left out. An event no calendar holds (a Zoom meeting's own) is searched; a cancelled one is not.
+ */
+export declare const EVENT_LIVE: string;
 export declare const CORPORA: {
     readonly document: {
         readonly type: "document";
@@ -81,7 +98,6 @@ export declare const CORPORA: {
         readonly index: "event_index";
         readonly table: "events";
         readonly read: string;
-        readonly pieces: false;
     };
 };
 /** What a row is indexed as: its title, then its text. Chunk offsets point into this. */

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

@@ -9,6 +9,34 @@ import { speech } from "./lucene-fields.js";
 import { savedStemmers } from "./stems.js";
 import { write } from "./transaction.js";
 import { dropUnusedVectors } from "./vector-index.js";
+/** What an event `e` is searched by besides its title: the cleaned description, the place and the attendees' names. */
+export const EVENT_TEXT = "trim(coalesce(e.description, '') || ' ' || coalesce(e.location, '') || ' ' || coalesce((" +
+    "SELECT group_concat(p.name, ' ') FROM calendar_entries ce JOIN calendar_entry_participants p ON p.entry_id = ce.id " +
+    "WHERE ce.event_id = e.id AND ce.deleted_at IS NULL AND p.resource = 0 AND p.name IS NOT NULL), ''))";
+/** Calendar entry types that are listed, never searched (requirements 3.4). */
+export const UNSEARCHED_EVENT_TYPES = ["workingLocation", "focusTime", "outOfOffice", "birthday"];
+/** Visibilities whose entry, when it carries no text, is a busy-only slot: stored, never searched (requirements 3.4). */
+export const BUSY_ONLY_VISIBILITIES = ["private", "confidential"];
+const sqlList = (values) => values.map((value) => `'${value}'`).join(", ");
+/** A calendar copy `ce` that may be searched: of a searchable type, and not a busy-only slot. */
+const SEARCHABLE_COPY = `(ce.event_type IS NULL OR ce.event_type NOT IN (${sqlList(UNSEARCHED_EVENT_TYPES)})) ` +
+    `AND NOT (coalesce(ce.visibility, '') IN (${sqlList(BUSY_ONLY_VISIBILITIES)}) AND trim(coalesce(ce.title, '')) = '' ` +
+    "AND trim(coalesce(ce.description, '')) = '' AND trim(coalesce(ce.location, '')) = '')";
+/**
+ * Whether the event `event` (an SQL expression of its id) has a searchable calendar copy, and with `account` one in
+ * those accounts (an SQL condition over `c.account_id`). Only live copies count, unless none is: an event its
+ * calendars deleted keeps its past copies as history.
+ */
+export const searchableCopy = (event, account) => `EXISTS (SELECT 1 FROM calendar_entries ce${account ? " JOIN calendars c ON c.id = ce.calendar_id" : ""} ` +
+    `WHERE ce.event_id = ${event} AND ${SEARCHABLE_COPY}${account ? ` AND ${account}` : ""} ` +
+    `AND (ce.deleted_at IS NULL OR NOT EXISTS (SELECT 1 FROM calendar_entries l WHERE l.event_id = ${event} ` +
+    "AND l.deleted_at IS NULL)))";
+/**
+ * Whether an event `e` is searched at all: by words, by meaning and in `search all`. The one place that names what
+ * is left out. An event no calendar holds (a Zoom meeting's own) is searched; a cancelled one is not.
+ */
+export const EVENT_LIVE = "(e.deleted_at IS NULL AND coalesce(e.status, '') <> 'cancelled' AND " +
+    `(NOT EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id) OR ${searchableCopy("e.id")}))`;
 export const CORPORA = {
     document: {
         type: "document",
@@ -60,15 +88,11 @@ export const CORPORA = {
         type: "event",
         index: "event_index",
         table: "events",
-        // Working location, focus time, out of office and birthdays are listed, never searched (requirements 3.4).
-        read: "SELECT e.title, trim(coalesce(e.description, '') || ' ' || coalesce(e.location, '') || ' ' || coalesce((" +
-            "SELECT group_concat(p.name, ' ') FROM calendar_entries ce JOIN calendar_entry_participants p ON p.entry_id = ce.id " +
-            "WHERE ce.event_id = e.id AND ce.deleted_at IS NULL AND p.resource = 0 AND p.name IS NOT NULL), '')) AS body, " +
-            "e.deleted_at IS NULL AND NOT EXISTS (SELECT 1 FROM calendar_entries ce WHERE ce.event_id = e.id " +
-            "AND ce.deleted_at IS NULL AND ce.event_type IN ('workingLocation', 'focusTime', 'outOfOffice', 'birthday')) AS live, " +
+        read: `SELECT e.title, ${EVENT_TEXT} AS body, ${EVENT_LIVE} AS live, ` +
             "coalesce((SELECT a.scope 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 = e.id LIMIT 1), 'personal') AS scope FROM events e WHERE e.id = ?",
-        pieces: false,
+            "JOIN accounts a ON a.id = c.account_id WHERE ce.event_id = e.id LIMIT 1), 'personal') AS scope, " +
+            "(SELECT c.account_id FROM calendar_entries ce JOIN calendars c ON c.id = ce.calendar_id " +
+            "WHERE ce.event_id = e.id AND ce.deleted_at IS NULL ORDER BY ce.id LIMIT 1) AS account_id FROM events e WHERE e.id = ?",
     },
 };
 /** What a row is indexed as: its title, then its text. Chunk offsets point into this. */