@wirecat/cli-core 0.379.0 → 0.381.0

package/dist/search/russian-dictionary.js

@@ -0,0 +1,66 @@
+import { readFileSync } from "node:fs";
+let loaded;
+/**
+ * Hunspell's own check, an ending at a time, instead of nspell's: nspell expands the 146,269 entries into
+ * 1.44 million forms (1.4 s, 172 MB) where this loads in about 0.15 s and agrees on every word it knows.
+ */
+const dictionary = () => {
+    if (loaded)
+        return loaded;
+    const file = (name) => readFileSync(new URL(name, import.meta.resolve("dictionary-ru")), "utf8");
+    const stems = new Map();
+    for (const line of file("index.dic").split("\n").slice(1)) {
+        const [entry, flags = ""] = line.trim().split("/");
+        if (!entry)
+            continue;
+        // Names and abbreviations are capitalised in the dictionary; a transcript's word index is lower case.
+        const word = entry.toLowerCase();
+        stems.set(word, (stems.get(word) ?? "") + flags);
+    }
+    const suffixes = new Map();
+    let longest = 0;
+    for (const line of file("index.aff").split("\n")) {
+        const [kind, flag, strip, append, condition] = line.trim().split(/\s+/);
+        if (kind !== "SFX" || flag === undefined || strip === undefined || append === undefined || !condition)
+            continue;
+        const ending = append === "0" ? "" : append;
+        const rules = suffixes.get(ending) ?? [];
+        rules.push({
+            flag,
+            strip: strip === "0" ? "" : strip,
+            condition: new RegExp(`${condition === "." ? "" : condition}$`),
+        });
+        suffixes.set(ending, rules);
+        longest = Math.max(longest, ending.length);
+    }
+    loaded = { stems, suffixes, longest };
+    return loaded;
+};
+const spelled = (word) => {
+    const { stems, suffixes, longest } = dictionary();
+    if (stems.has(word))
+        return true;
+    for (let cut = 0; cut <= Math.min(word.length - 1, longest); cut++)
+        for (const rule of suffixes.get(word.slice(word.length - cut)) ?? []) {
+            const stem = word.slice(0, word.length - cut) + rule.strip;
+            if (stems.get(stem)?.includes(rule.flag) && rule.condition.test(stem))
+                return true;
+        }
+    return false;
+};
+/**
+ * Whether a word the index stores is a real Russian word. The index folds й into и and ё into е, so each is
+ * tried back one letter at a time.
+ */
+export const knownRussianWord = (word) => {
+    if (spelled(word))
+        return true;
+    for (const [folded, original] of [
+        ["и", "й"],
+        ["е", "ё"],
+    ])
+        for (let at = word.indexOf(folded); at >= 0; at = word.indexOf(folded, at + 1))
+            if (spelled(word.slice(0, at) + original + word.slice(at + 1)))
+                return true;
+    return false;
+};

package/dist/services/meeting-project-discovery.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { CliError } from "@wirecat/cli-base";
 import { normalizeVocabularyName } from "../domain/vocabulary.js";
-import { canonicalMeetingReference, parseMeetingReference, validateMeetingHitSearch, } from "../meetings/index.js";
+import { canonicalMeetingReference, meetingWordsQuery, parseMeetingReference, validateMeetingHitSearch, } from "../meetings/index.js";
 const scopeKeys = [
     "accountId",
     "meetingId",
@@ -134,7 +134,7 @@ export const readMeetingProjectDiscovery = async (ports, projectName, original)
     const previous = cursorOf(cursor, key, terms.length);
     const termIndex = previous?.term ?? 0;
     const term = terms[termIndex];
-    const result = await ports.search.searchHits(term.name, {
+    const result = await ports.search.searchHits(meetingWordsQuery(term.name), {
         ...input,
         ...(previous?.after ? { after: previous.after } : {}),
     });

package/dist/services/moment.d.ts

@@ -12,3 +12,24 @@ export declare const momentOf: (reference: string, flag?: string, now?: number,
  * is not a time; a caller that clears a date checks for it first.
  */
 export declare const aheadOf: (reference: string, flag: string, now?: number, at?: MomentZone) => number;
+export interface DateWindow {
+    since?: number;
+    until?: number;
+    /** What the answer says about it: the zone a value without one was read in, and the bounds in UTC. */
+    meta: {
+        timezone?: string;
+        window?: {
+            since?: string;
+            until?: string;
+        };
+    };
+}
+/** `--since-time` and `--until-time` together, as the filter and the `meta` an answer reports it by. */
+export declare const dateWindow: ({ sinceTime, untilTime, zone, now, names, }: {
+    sinceTime?: string;
+    untilTime?: string;
+    zone?: string;
+    now?: number;
+    /** How the caller spells the two, for the error: `since_time` over MCP. */
+    names?: [string, string];
+}) => DateWindow;

package/dist/services/moment.js

@@ -1,4 +1,5 @@
 import { CliError } from "@wirecat/cli-base";
+import { timezoneOf } from "@wirecat/cli-base/query";
 import { calendarMoment } from "../domain/moment.js";
 const AGO = /^(\d+)(m|h|d)$/;
 const AGO_MS = { m: 60_000, h: 3_600_000, d: 86_400_000 };
@@ -43,3 +44,21 @@ export const aheadOf = (reference, flag, now = Date.now(), at = {}) => {
     }
     return time;
 };
+/** `--since-time` and `--until-time` together, as the filter and the `meta` an answer reports it by. */
+export const dateWindow = ({ sinceTime, untilTime, zone, now = Date.now(), names = ["--since-time", "--until-time"], }) => {
+    const since = sinceTime === undefined ? undefined : momentOf(sinceTime, names[0], now, { zone });
+    const until = untilTime === undefined ? undefined : momentOf(untilTime, names[1], now, { zone, end: true });
+    const readInZone = [sinceTime, untilTime].some((value) => value !== undefined && DATE.test(value.trim()) && !/(?:Z|[+-]\d{2}:?\d{2})$/i.test(value.trim()));
+    const window = {
+        ...(since === undefined ? {} : { since: new Date(since).toISOString() }),
+        ...(until === undefined ? {} : { until: new Date(until).toISOString() }),
+    };
+    return {
+        ...(since === undefined ? {} : { since }),
+        ...(until === undefined ? {} : { until }),
+        meta: {
+            ...(readInZone ? { timezone: timezoneOf(zone) } : {}),
+            ...(since === undefined && until === undefined ? {} : { window }),
+        },
+    };
+};

package/dist/services/retention.js

@@ -13,16 +13,19 @@ export const observationDuration = (text, flag) => {
 export const retentionService = (deps) => ({
     report: async (chat, query = {}) => {
         const cutoff = Date.now();
+        const zone = timezoneOf(query.timezone);
         const options = {
-            since: query.sinceTime === undefined ? cutoff - 90 * 86_400_000 : momentOf(query.sinceTime, "--since-time"),
-            until: query.untilTime === undefined ? cutoff : momentOf(query.untilTime, "--until-time"),
+            since: query.sinceTime === undefined
+                ? cutoff - 90 * 86_400_000
+                : momentOf(query.sinceTime, "--since-time", cutoff, { zone }),
+            until: query.untilTime === undefined ? cutoff : momentOf(query.untilTime, "--until-time", cutoff, { zone, end: true }),
             cutoff,
             checkpoints: (query.checkpoints ?? "1d,7d,30d")
                 .split(",")
                 .map((one) => observationDuration(one.trim(), "--checkpoints")),
             within: observationDuration(query.within ?? "7d", "--within"),
             by: query.by ?? "week",
-            timezone: timezoneOf(query.timezone),
+            timezone: zone,
             limit: query.limit ?? 20,
         };
         const store = await deps.store(), account = await deps.account();

package/dist/store/messages.d.ts

@@ -1,5 +1,5 @@
 import type { CounterObservations } from "../domain/counters.js";
-import type { Id, Message, Page, PollVote, Reactions, WindowedMessage } from "../domain/models.js";
+import type { Id, Message, Page, PersonReaction, PollVote, Reactions, WindowedMessage } from "../domain/models.js";
 import { type DocumentLinkMessage } from "./sqlite/document-links.js";
 import type { StoreContext } from "./sqlite/open.js";
 import type { AccountKey, DeletionScope, IngestedVia, MessageFilter, SenderChatStats, StoredHit } from "./types.js";
@@ -10,7 +10,8 @@ export interface AccountMessages {
      * `seenAt` is when the messenger was asked: a message it still returned is not deleted, so a
      * tombstone older than that is lifted. A tombstone set after it stays — the deletion is newer.
      *
-     * `votes` and `stars` are saved after the messages in the same transaction, as `saveVote` and `saveStar` save each.
+     * `votes`, `reactions` and `stars` are saved after the messages in the same transaction, as `saveVote`,
+     * `saveReaction` and `saveStar` save each.
      *
      * `typedChatId` is the id the owner wrote to when the messenger answered `chatId`: a chat row made for `chatId`
      * takes the typed row's title, kind and privacy, and is never more visible than it.
@@ -22,6 +23,10 @@ export interface AccountMessages {
             messageId: Id;
             vote: PollVote;
         }[];
+        reactions?: {
+            messageId: Id;
+            reaction: PersonReaction;
+        }[];
         stars?: {
             messageId: Id;
             starred: boolean;
@@ -89,10 +94,18 @@ export interface AccountMessages {
         chatId?: Id;
         among?: DeletionScope;
     }): Promise<number>;
-    /** A message's reactions as they are now; answers whether the message is held at all. */
+    /**
+     * A message's reactions as they are now; answers whether the message is held at all. Ignored where the store holds
+     * people's own reactions to it (`saveReaction`): the totals come from those.
+     */
     saveReactions(key: AccountKey, chatId: Id, messageId: Id, reactions: Reactions, options?: {
         observation?: CounterObservations["reactions"];
     }): Promise<boolean>;
+    /**
+     * One person's reaction to a message, unless the store holds a newer one of theirs; a `null` reaction is a take-back.
+     * The message's `reactions` become the totals of every person's newest, whenever the message is held.
+     */
+    saveReaction(key: AccountKey, chatId: Id, messageId: Id, reaction: PersonReaction): Promise<void>;
     /** The owner's star on a message, or its removal; answers whether the message is held at all. */
     saveStar(key: AccountKey, chatId: Id, messageId: Id, starred: boolean): Promise<boolean>;
     /** One voter's vote in the poll a message carries, unless the store holds a newer one of theirs; no answers is a take-back. */

package/dist/store/messages.js

@@ -11,7 +11,7 @@ export const accountMessagesOver = (context) => {
     const { database } = context;
     const { accountPk, findAccountPk, findChatPk, chatKeyOf, chatPkFor, answeredChatPk, upsertMessage } = keysOver(context);
     return {
-        saveMessages: async (key, chatId, messages, { via, seenAt, votes = [], stars = [], typedChatId }) => write(database, () => {
+        saveMessages: async (key, chatId, messages, { via, seenAt, votes = [], reactions = [], stars = [], typedChatId }) => write(database, () => {
             const accountKey = accountPk(key);
             const chatKey = typedChatId === undefined ? chatPkFor(accountKey, chatId) : answeredChatPk(accountKey, chatId, typedChatId);
             for (const message of messages) {
@@ -20,6 +20,8 @@ export const accountMessagesOver = (context) => {
             }
             for (const { messageId, vote } of votes)
                 messageWrites.saveVote(context, accountKey, key.provider, chatKey, messageId, vote);
+            for (const { messageId, reaction } of reactions)
+                messageWrites.saveReaction(context, accountKey, key.provider, chatKey, messageId, reaction);
             for (const { messageId, starred } of stars)
                 messageWrites.saveStar(context, chatKey, messageId, starred);
         }),
@@ -83,6 +85,10 @@ export const accountMessagesOver = (context) => {
             });
             return saved;
         },
+        saveReaction: async (key, chatId, messageId, reaction) => write(database, () => {
+            const accountKey = accountPk(key);
+            messageWrites.saveReaction(context, accountKey, key.provider, chatPkFor(accountKey, chatId), messageId, reaction);
+        }),
         saveVote: async (key, chatId, messageId, vote) => write(database, () => {
             const accountKey = accountPk(key);
             messageWrites.saveVote(context, accountKey, key.provider, chatPkFor(accountKey, chatId), messageId, vote);

package/dist/store/sqlite/accounts.js

@@ -1,7 +1,7 @@
 import { CliError } from "@wirecat/cli-base";
 import { and, asc, eq, inArray, sql } from "./drizzle/core.js";
 import { pointerPairs } from "./entity-types.js";
-import { accountIdentities, accounts, aliases, botUpdates, chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageRevisions, messages, messageTranscripts, pollVotes, projects, syncCursors, syncRanges, syncs, } from "./schema.js";
+import { accountIdentities, accounts, aliases, botUpdates, chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageReactions, messageRevisions, messages, messageTranscripts, pollVotes, projects, syncCursors, syncRanges, syncs, } from "./schema.js";
 /** An account's row, made on first sight; a name only replaces what was known when there is one. */
 export const accountPk = ({ orm, now }, { provider, account, scope }, name = null) => Number(orm
     .insert(accounts)
@@ -67,6 +67,7 @@ export const purgeAccount = ({ orm, database }, accountKey) => {
     orm.delete(syncs).where(eq(syncs.accountId, accountKey)).run();
     orm.delete(messageTranscripts).where(inArray(messageTranscripts.chatId, chatsOf)).run();
     orm.delete(pollVotes).where(inArray(pollVotes.chatId, chatsOf)).run();
+    orm.delete(messageReactions).where(inArray(messageReactions.chatId, chatsOf)).run();
     orm
         .delete(chatEventPeople)
         .where(inArray(chatEventPeople.chatEventId, orm.select({ id: chatEvents.id }).from(chatEvents).where(inArray(chatEvents.chatId, chatsOf))))

package/dist/store/sqlite/chat-rekey.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { formatLocator } from "../../domain/locator.js";
 import { purgeChats, revisedBy, stricterPrivacy } from "./chats.js";
 import { pointerPairs } from "./entity-types.js";
-import { tombstone } from "./messages.js";
+import { tombstone, writeDerivedReactions } from "./messages.js";
 import { targetKey } from "./notes.js";
 import { write } from "./transaction.js";
 const chatRow = (context, accountKey, chatId) => context.database.prepare("SELECT * FROM chats WHERE account_id = ? AND external_id = ?").get(accountKey, chatId);
@@ -106,6 +106,9 @@ const absorb = (context, kept, gone) => {
     database
         .prepare("DELETE FROM poll_votes WHERE chat_id = ? AND EXISTS (SELECT 1 FROM poll_votes g WHERE g.chat_id = ? AND g.message_external_id = poll_votes.message_external_id AND g.identity_id = poll_votes.identity_id AND g.voted_at > poll_votes.voted_at)")
         .run(kept, gone);
+    database
+        .prepare("DELETE FROM message_reactions WHERE chat_id = ? AND EXISTS (SELECT 1 FROM message_reactions g WHERE g.chat_id = ? AND g.message_external_id = message_reactions.message_external_id AND g.identity_id = message_reactions.identity_id AND g.reacted_at > message_reactions.reacted_at)")
+        .run(kept, gone);
     // The absorbed copy of an event both chats hold is purged, so the people only it named move first.
     database
         .prepare("INSERT OR IGNORE INTO chat_event_people (chat_event_id, identity_id) SELECT k.id, p.identity_id FROM chat_events g JOIN chat_events k ON k.chat_id = ? AND k.source_id = g.source_id JOIN chat_event_people p ON p.chat_event_id = g.id WHERE g.chat_id = ?")
@@ -113,6 +116,7 @@ const absorb = (context, kept, gone) => {
     foldOpenStays(context, kept, gone);
     for (const table of [
         "poll_votes",
+        "message_reactions",
         "chat_revisions",
         "chat_events",
         "message_transcripts",
@@ -131,6 +135,10 @@ const absorb = (context, kept, gone) => {
     database
         .prepare("DELETE FROM message_transcripts WHERE chat_id = ? AND message_id IN (SELECT id FROM messages WHERE chat_id = ? AND deleted_at IS NOT NULL)")
         .run(kept, kept);
+    for (const { id } of database
+        .prepare("SELECT DISTINCT message_external_id AS id FROM message_reactions WHERE chat_id = ?")
+        .all(kept))
+        writeDerivedReactions(context, kept, id);
     database.prepare("UPDATE chats SET parent_chat_id = ? WHERE parent_chat_id = ?").run(kept, gone);
     pointerMover(context, "chat")(gone, kept);
     purgeChats(context, [gone]);

package/dist/store/sqlite/chats.js

@@ -2,7 +2,7 @@ import { CliError } from "@wirecat/cli-base";
 import { and, eq, inArray, or, sql } from "./drizzle/core.js";
 import { identityPk } from "./identities.js";
 import { bound } from "./query-filter.js";
-import { chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, identities, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageRevisions, messages, messageTranscripts, pollVotes, syncRanges, } from "./schema.js";
+import { chatEventPeople, chatEvents, chatMembers, chats, chunks, fetchLeases, identities, involvements, memberCounts, memberObservationMembers, memberObservations, memberStays, messageReactions, messageRevisions, messages, messageTranscripts, pollVotes, syncRanges, } from "./schema.js";
 import { ensureTag } from "./tags.js";
 import { parsed, present, toIso, toMs } from "./values.js";
 /** The chat's own id, when the store key is a chat of this account. */
@@ -262,6 +262,7 @@ export const purgeChats = ({ orm }, pks) => {
         .run();
     orm.delete(messageTranscripts).where(inArray(messageTranscripts.chatId, pks)).run();
     orm.delete(pollVotes).where(inArray(pollVotes.chatId, pks)).run();
+    orm.delete(messageReactions).where(inArray(messageReactions.chatId, pks)).run();
     orm
         .delete(chatEventPeople)
         .where(inArray(chatEventPeople.chatEventId, orm.select({ id: chatEvents.id }).from(chatEvents).where(inArray(chatEvents.chatId, pks))))

package/dist/store/sqlite/manifest.js

@@ -31,6 +31,7 @@ export const MANIFEST = [
     { name: "20261018063952_version-24-message-stars-index", version: 24, minCompatible: 1 },
     { name: "20261019115025_version-25-chat-revisions", version: 25, minCompatible: 1 },
     { name: "20261019115027_version-25-chat-revisions-triggers", version: 25, minCompatible: 1 },
+    { name: "20261021214318_version-26-message-reactions", version: 26, minCompatible: 1 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/meeting-hit-query.d.ts

@@ -0,0 +1,60 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
+import type { Stemmer } from "../../search/stem.js";
+import type { CacheDatabase, SqlValue } from "../driver.js";
+interface Word {
+    raw: string;
+    literal: string;
+    /** Matched as a whole word, not as a beginning: `exact:` and number words. */
+    whole: boolean;
+    stems: string[];
+    widened: string[];
+}
+type Leaf = {
+    kind: "words";
+    exact: boolean;
+    words: Word[];
+} | {
+    kind: "phrase";
+    exact: boolean;
+    words: Word[];
+}
+/** `"a b"~N`: every word within `lines` transcript lines of a line that holds one of them. */
+ | {
+    kind: "near";
+    exact: boolean;
+    words: Word[];
+    lines: number;
+} | {
+    kind: "speaker";
+    participants: number[];
+    names: string[];
+};
+export type Resolved = Leaf | {
+    kind: "boolean";
+    must: Resolved[];
+    should: Resolved[];
+    not: Resolved[];
+};
+interface State {
+    stemmer: Stemmer | null;
+    through: number;
+}
+/** The parsed query, its names resolved and its words stemmed and widened, before any text is read. */
+export declare const resolveMeetingQuery: (database: CacheDatabase, accountId: number, ast: QueryAst, state: State) => Resolved;
+/**
+ * A `(rid, tier)` select: tier 0 the typed form, 1 another form the stems found, 2 a garbled spelling. A passage
+ * all of a query's required parts reach takes the worst tier among them; one any optional part reaches, the best.
+ */
+export declare const meetingQuerySql: (tree: Resolved, state: State) => {
+    sql: string;
+    params: SqlValue[];
+};
+/**
+ * The tree checked again against a passage's current text — an index lags an edit — and the garbled spellings
+ * that let it match. A speaker cannot be read from the text, so it passes here.
+ */
+export declare const matchMeetingText: (tree: Resolved, text: string, stemmer: Stemmer | null) => {
+    from: string;
+    to: string[];
+}[] | null;
+export {};

package/dist/store/sqlite/meeting-hit-query.js

@@ -0,0 +1,262 @@
+import { CliError, singleLine } from "@wirecat/cli-base";
+import { isNumberWord, widenWords } from "../../search/garbled.js";
+import { knownRussianWord } from "../../search/russian-dictionary.js";
+import { fold, normalize } from "../normalize.js";
+import { meetingStemmableText } from "./meeting-stem-state.js";
+const WORD = /[\p{L}\p{N}\p{M}]+/gu;
+const MOST_WORDS = 128;
+const quote = (word) => `"${word.replaceAll('"', '""')}"`;
+/** The candidates `from:` picks among: a linked person with all their identities, else one identity or name. */
+const speakers = (database, accountId) => {
+    const found = new Map();
+    const add = (key, label, names, participant, raw) => {
+        const speaker = found.get(key) ?? { label, names: new Set(), participants: new Set(), raw: new Set() };
+        for (const name of names)
+            if (name?.trim())
+                speaker.names.add(fold(name.trim()));
+        if (participant !== null)
+            speaker.participants.add(participant);
+        if (raw)
+            speaker.raw.add(raw);
+        found.set(key, speaker);
+    };
+    const participants = database
+        .prepare(`SELECT p.id,p.identity_id,p.display_name,i.name AS identity_name,l.person_id,person.name AS person_name
+       FROM meeting_participants p JOIN meetings m ON m.id=p.meeting_id
+       LEFT JOIN identities i ON i.id=p.identity_id LEFT JOIN identity_links l ON l.identity_id=p.identity_id
+       LEFT JOIN persons person ON person.id=l.person_id WHERE m.account_id=? AND m.deleted_at IS NULL`)
+        .all(accountId);
+    const personNames = database.prepare("SELECT i.name FROM identity_links l JOIN identities i ON i.id=l.identity_id WHERE l.person_id=?");
+    for (const row of participants) {
+        const names = [row.display_name, row.identity_name, row.person_name].map((name) => name === null || name === undefined ? null : String(name));
+        const label = names.find((name) => name?.trim()) ?? "unnamed";
+        if (row.person_id !== null && row.person_id !== undefined) {
+            const others = personNames.all(Number(row.person_id)).map((one) => (one.name === null ? null : String(one.name)));
+            add(`person:${row.person_id}`, String(row.person_name ?? label), [...names, ...others], Number(row.id));
+        }
+        else if (row.identity_id !== null && row.identity_id !== undefined)
+            add(`identity:${row.identity_id}`, label, names, Number(row.id));
+        else
+            add(`name:${fold(label)}`, label, names, Number(row.id));
+    }
+    const unlinked = database
+        .prepare(`SELECT DISTINCT r.speaker_name AS name FROM meeting_transcript_rows r
+       JOIN meeting_transcripts t ON t.id=r.meeting_transcript_id JOIN meetings m ON m.id=t.meeting_id
+       WHERE m.account_id=? AND m.deleted_at IS NULL AND r.speaker_participant_id IS NULL AND r.speaker_name IS NOT NULL
+       UNION SELECT DISTINCT c.sender_name FROM meeting_chat_messages c JOIN meetings m ON m.id=c.meeting_id
+       WHERE m.account_id=? AND m.deleted_at IS NULL AND c.sender_participant_id IS NULL AND c.sender_name IS NOT NULL`)
+        .all(accountId, accountId);
+    for (const row of unlinked) {
+        const name = String(row.name);
+        if (!name.trim())
+            continue;
+        const same = [...found.values()].find((speaker) => speaker.names.has(fold(name.trim())));
+        if (same)
+            same.raw.add(name);
+        else
+            add(`name:${fold(name.trim())}`, name, [name], null, name);
+    }
+    return [...found.values()];
+};
+/**
+ * As `pickPerson` for messages: a name matched as a fragment, the exact name first, and an ambiguous one is an
+ * error with the candidates rather than a guess.
+ */
+const pickSpeaker = (database, accountId, reference) => {
+    const wanted = fold(reference.trim());
+    const everyone = speakers(database, accountId).sort((a, b) => a.label.localeCompare(b.label));
+    const exact = everyone.filter((speaker) => speaker.names.has(wanted));
+    const matches = exact.length
+        ? exact
+        : everyone.filter((speaker) => [...speaker.names].some((n) => n.includes(wanted)));
+    const [one] = matches;
+    if (matches.length === 1 && one)
+        return { kind: "speaker", participants: [...one.participants].sort((a, b) => a - b), names: [...one.raw].sort() };
+    if (matches.length === 0)
+        throw new CliError("not_found", `from:${reference} — nobody spoke as "${reference}"`);
+    throw new CliError("validation_error", `from:${reference} matches ${matches.length} speakers — write more of the name:\n${matches
+        .map((speaker) => `  ${singleLine(speaker.label)}`)
+        .join("\n")}`, { candidates: matches.map((speaker) => ({ name: speaker.label })) });
+};
+/** The parsed query, its names resolved and its words stemmed and widened, before any text is read. */
+export const resolveMeetingQuery = (database, accountId, ast, state) => {
+    const all = [];
+    const wordsOf = (value, exact) => {
+        const words = (value.match(WORD) ?? [])
+            .filter((raw) => normalize(raw))
+            .map((raw) => {
+            const literal = normalize(raw);
+            return {
+                raw,
+                literal,
+                whole: exact || isNumberWord(literal),
+                stems: state.stemmer && raw.length <= 1024 && !exact
+                    ? [...new Set(state.stemmer.explain(raw).map((word) => word.stem))]
+                    : [],
+                widened: [],
+            };
+        });
+        for (const term of words)
+            all.push(term);
+        if (all.length > MOST_WORDS)
+            throw new CliError("validation_error", "Meeting search supports at most 128 query words");
+        return words;
+    };
+    const resolve = (node) => {
+        if (node.kind === "boolean")
+            return {
+                kind: "boolean",
+                must: node.clauses.filter((c) => c.occur === "must").map((c) => resolve(c.node)),
+                should: node.clauses.filter((c) => c.occur === "should").map((c) => resolve(c.node)),
+                not: node.clauses.filter((c) => c.occur === "must_not").map((c) => resolve(c.node)),
+            };
+        if (node.field === "from")
+            return pickSpeaker(database, accountId, node.value);
+        const exact = node.field === "exact";
+        const words = wordsOf(node.value, exact);
+        if (node.operator === "phrase" && node.slop !== undefined && words.length > 1)
+            return { kind: "near", exact, words, lines: node.slop };
+        return { kind: node.operator === "phrase" && words.length > 1 ? "phrase" : "words", exact, words };
+    };
+    const tree = resolve(ast.root);
+    const stemmer = state.stemmer;
+    const widening = [];
+    const collect = (node) => {
+        if (node.kind === "boolean")
+            [...node.must, ...node.should, ...node.not].forEach(collect);
+        else if ((node.kind === "words" || node.kind === "near") && !node.exact)
+            for (const term of node.words)
+                widening.push(term);
+    };
+    collect(tree);
+    if (stemmer && state.through > 0 && widening.length) {
+        const widened = widenWords(widening, database
+            .prepare("SELECT term,doc FROM meeting_words_vocab WHERE col='normalized_text'")
+            .all()
+            .map((row) => ({ term: String(row.term), docs: Number(row.doc) })), (word) => [...new Set(stemmer.explain(word).map((part) => part.stem))], knownRussianWord);
+        widening.forEach((word, at) => {
+            word.widened = widened[at] ?? [];
+        });
+    }
+    return tree;
+};
+/**
+ * A `(rid, tier)` select: tier 0 the typed form, 1 another form the stems found, 2 a garbled spelling. A passage
+ * all of a query's required parts reach takes the worst tier among them; one any optional part reaches, the best.
+ */
+export const meetingQuerySql = (tree, state) => {
+    const params = [];
+    const stems = state.stemmer !== null && state.through > 0;
+    const word = (term) => {
+        params.push(`normalized_text : (${quote(term.literal)}${term.whole ? "" : "*"})`);
+        let select = "SELECT rowid AS rid,0 AS tier FROM meeting_words WHERE meeting_words MATCH ?";
+        if (stems && term.stems.length) {
+            params.push(`stems : (${term.stems.map(quote).join(" OR ")})`, state.through);
+            select += " UNION SELECT rowid,1 FROM meeting_stems WHERE meeting_stems MATCH ? AND rowid<=?";
+        }
+        if (term.widened.length) {
+            params.push(`normalized_text : (${term.widened.map(quote).join(" OR ")})`);
+            select += " UNION SELECT rowid,2 FROM meeting_words WHERE meeting_words MATCH ?";
+        }
+        return `SELECT rid,min(tier) AS tier FROM (${select}) GROUP BY rid`;
+    };
+    const all = (parts) => parts.length === 1
+        ? parts[0]
+        : `SELECT rid,max(tier) AS tier FROM (${parts.join(" UNION ALL ")}) GROUP BY rid HAVING count(*)=${parts.length}`;
+    const any = (parts) => parts.length === 1
+        ? parts[0]
+        : `SELECT rid,min(tier) AS tier FROM (${parts.join(" UNION ALL ")}) GROUP BY rid`;
+    const nothing = "SELECT NULL AS rid,0 AS tier WHERE 0";
+    const compile = (node) => {
+        if (node.kind === "words")
+            return node.words.length ? all(node.words.map(word)) : nothing;
+        if (node.kind === "near") {
+            const lines = node.words.map((term, i) => `w${i} AS MATERIALIZED (SELECT r.meeting_transcript_id AS t,r.position AS p,r.id,h.tier FROM (${word(term)}) h JOIN meeting_transcript_rows r ON h.rid%4=1 AND r.id=h.rid/4)`);
+            const nearest = node.words.map((_, i) => `(SELECT min(x.tier) FROM w${i} x WHERE x.t=c.t AND x.p BETWEEN c.p-${node.lines} AND c.p+${node.lines})`);
+            return `SELECT rid,tier FROM (WITH ${lines.join(",")}, c AS (${node.words
+                .map((_, i) => `SELECT t,p,id FROM w${i}`)
+                .join(" UNION ")}) SELECT c.id*4+1 AS rid,max(${nearest.join(",")}) AS tier FROM c) WHERE tier IS NOT NULL`;
+        }
+        if (node.kind === "phrase") {
+            params.push(`normalized_text : ${quote(node.words.map((term) => term.literal).join(" "))}`);
+            let select = "SELECT rowid AS rid,0 AS tier FROM meeting_words WHERE meeting_words MATCH ?";
+            const phrases = node.exact ? undefined : state.stemmer?.phrases(node.words.map((term) => term.raw).join(" "));
+            if (stems && phrases) {
+                params.push(`stems : (${phrases})`, state.through);
+                select += " UNION SELECT rowid,1 FROM meeting_stems WHERE meeting_stems MATCH ? AND rowid<=?";
+            }
+            return `SELECT rid,min(tier) AS tier FROM (${select}) GROUP BY rid`;
+        }
+        if (node.kind === "speaker") {
+            params.push(JSON.stringify(node.participants), JSON.stringify(node.names));
+            params.push(JSON.stringify(node.participants), JSON.stringify(node.names));
+            return `SELECT r.id*4+1 AS rid,0 AS tier FROM meeting_transcript_rows r
+        WHERE r.speaker_participant_id IN (SELECT value FROM json_each(?)) OR (r.speaker_participant_id IS NULL AND r.speaker_name IN (SELECT value FROM json_each(?)))
+        UNION ALL SELECT c.id*4+2,0 FROM meeting_chat_messages c
+        WHERE c.sender_participant_id IN (SELECT value FROM json_each(?)) OR (c.sender_participant_id IS NULL AND c.sender_name IN (SELECT value FROM json_each(?)))`;
+        }
+        // Lucene: optional clauses only count when nothing is required; a part that is only exclusions matches nothing.
+        const positive = node.must.length
+            ? all(node.must.map(compile))
+            : node.should.length
+                ? any(node.should.map(compile))
+                : nothing;
+        if (!node.not.length)
+            return positive;
+        return `SELECT rid,tier FROM (${positive}) WHERE rid NOT IN (${node.not.map((part) => `SELECT rid FROM (${compile(part)})`).join(" UNION ")})`;
+    };
+    return { sql: compile(tree), params };
+};
+/**
+ * The tree checked again against a passage's current text — an index lags an edit — and the garbled spellings
+ * that let it match. A speaker cannot be read from the text, so it passes here.
+ */
+export const matchMeetingText = (tree, text, stemmer) => {
+    const tokens = normalize(text).match(/[\p{L}\p{N}]+/gu) ?? [];
+    let stemTokens;
+    const stemsOf = () => (stemTokens ??= stemmer
+        ? new Set(stemmer.explain(meetingStemmableText(text)).map((word) => word.stem))
+        : new Set());
+    const word = (term) => {
+        if (term.whole ? tokens.includes(term.literal) : tokens.some((token) => token.startsWith(term.literal)))
+            return [];
+        if (term.stems.some((stem) => stemsOf().has(stem)))
+            return [];
+        const to = term.widened.filter((widened) => tokens.includes(widened));
+        return to.length ? [{ from: term.raw, to }] : null;
+    };
+    const check = (node) => {
+        if (node.kind === "speaker")
+            return [];
+        // The other words are on neighbouring lines, so only this line's garbled spellings are named.
+        if (node.kind === "near")
+            return node.words.flatMap((term) => word(term) ?? []);
+        if (node.kind === "words" || node.kind === "phrase") {
+            const found = [];
+            for (const term of node.words) {
+                const one = word(term);
+                if (!one)
+                    return null;
+                for (const fix of one)
+                    found.push(fix);
+            }
+            return found;
+        }
+        if (node.not.some((part) => check(part) !== null))
+            return null;
+        if (node.must.length) {
+            const found = [];
+            for (const part of node.must) {
+                const one = check(part);
+                if (!one)
+                    return null;
+                for (const fix of one)
+                    found.push(fix);
+            }
+            return found;
+        }
+        const matched = node.should.map(check).filter((one) => one !== null);
+        return matched.length ? matched.flat() : null;
+    };
+    return check(tree);
+};