@wirecat/cli-core 0.379.0 → 0.381.0

package/dist/meetings/hit-query.js

@@ -0,0 +1,58 @@
+import { defineQuery, parseLucene, queryError, validateQuery, } from "@wirecat/cli-base/query";
+const context = {
+    command: "search meetings",
+    guide: "https://github.com/WireCatLabs/cli-core/blob/main/docs/search/query-language.md#встречи",
+};
+const words = ["term", "phrase"];
+/** A transcript line holds a sentence or two; further than this is a different part of the meeting. */
+export const MOST_LINES_APART = 20;
+const near = (node) => {
+    if (node.slop !== undefined && node.slop > MOST_LINES_APART)
+        queryError("query.invalid-number", node.span, `words at most ${MOST_LINES_APART} lines apart: "a b"~${MOST_LINES_APART}`, context);
+};
+/** The messages query language over meeting text: the same fields, a narrower set of operators. */
+export const MEETING_HIT_QUERY = defineQuery({
+    entity: "meeting_hit",
+    backend: "sql",
+    fields: [
+        {
+            name: "text",
+            type: "txt",
+            operators: words,
+            example: "text:budget",
+            relation: "a passage with the word in any form, or a spelling speech recognition garbled",
+            validate: near,
+        },
+        {
+            name: "exact",
+            type: "txt",
+            operators: words,
+            example: "exact:budget",
+            relation: "a passage with the word as typed: no other forms, no garbled spellings",
+            validate: near,
+        },
+        {
+            name: "from",
+            type: "kw",
+            operators: words,
+            example: 'from:"Alice Synthetic"',
+            relation: "a line said or a chat message written by this person; attendance is --identity-id",
+        },
+    ],
+});
+/** What a person typed: the CLI, MCP and batch queries. */
+export const parseMeetingQuery = (query) => validateQuery(parseLucene(query, { defaultField: "text", proximity: true, ...context }), MEETING_HIT_QUERY, context);
+/**
+ * Words from a name or a note, never parsed: a project called «C++ (beta)» must not become syntax. Each word is
+ * required, in any form.
+ */
+export const meetingWordsQuery = (text) => {
+    const found = text.match(/[\p{L}\p{N}\p{M}]+/gu) ?? [];
+    const span = { start: 0, end: text.length };
+    const clauses = found.map((value) => ({
+        occur: "must",
+        node: { kind: "predicate", field: "text", operator: "term", value, span },
+    }));
+    const root = clauses.length === 1 && clauses[0] ? clauses[0].node : { kind: "boolean", clauses, span };
+    return { version: 1, language: "lucene-v1", root };
+};

package/dist/meetings/import.d.ts

@@ -5,6 +5,8 @@ export interface ImportFile {
     content: string;
     participants?: ParticipantInput[];
     source?: string;
+    /** `vtt` (the default) or `text`, the form `parseTranscriptText` reads. */
+    format?: "vtt" | "text";
 }
 /** The caller reads files and supplies provider-neutral occurrence metadata. */
 export declare const importFiles: (files: ImportFile[], store: MeetingStore, now?: number) => Promise<RunReport>;

package/dist/meetings/import.js

@@ -1,18 +1,21 @@
 import { linkEvent } from "./events.js";
 import { transcriptInput } from "./ingest.js";
+import { parseTranscriptText } from "./transcript-text.js";
 import { parseVtt } from "./vtt.js";
 /** The caller reads files and supplies provider-neutral occurrence metadata. */
 export const importFiles = async (files, store, now = Date.now()) => {
     const report = { meetings: 0, participants: 0, transcriptRows: 0, summaries: 0, warnings: [] };
     for (const file of files) {
         try {
-            const lines = parseVtt(file.content);
+            const format = file.format ?? "vtt";
+            const lines = format === "text" ? parseTranscriptText(file.content).lines : parseVtt(file.content);
             const participants = file.participants ?? [];
             const details = await store.saveMeeting({
                 meeting: file.meeting,
                 participants: file.participants,
-                transcripts: [await transcriptInput(lines, participants, file.source ?? "file", file.content, "vtt")],
+                transcripts: [await transcriptInput(lines, participants, file.source ?? "file", file.content, format)],
                 now,
+                fromFile: true,
             });
             await linkEvent(store, details, now);
             report.meetings++;
@@ -26,5 +29,9 @@ export const importFiles = async (files, store, now = Date.now()) => {
             });
         }
     }
+    const zones = new Set(files.map((file) => file.meeting.timezone).filter((zone) => zone !== null && zone !== undefined));
+    const [zone] = zones;
+    if (zones.size === 1 && zone)
+        report.timezone = zone;
     return report;
 };

package/dist/meetings/index.d.ts

@@ -6,6 +6,7 @@ export { linkEvent } from "./events.js";
 export { exportMeeting, type MeetingExport, type MeetingExportFormat, type MeetingExportOptions, serializeVtt, } from "./export.js";
 export { type FindingEvidence, type FindingOutcome, findingHash, MEETING_FINDINGS_KIND, type MeetingFactFinding, type MeetingFinding, type MeetingFindingsInput, type MeetingFindingsReceipt, type MeetingTaskFinding, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";
 export { type Finding, type FindingsInput, type FindingsReceipt, type FindingsRules, findingFingerprint, validateFindings, } from "./findings-rules.js";
+export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { type ImportFile, importFiles } from "./import.js";
 export { MEETING_QUERY, type MeetingItem, type MeetingOwner, meeting, meetingItem } from "./item.js";
 export { createMeetingContext, MEETING_FACT_TYPES, type MeetingContextAction, type MeetingContextChange, type MeetingContextOperation, type MeetingContextPorts, type MeetingContextReceipt, validateMeetingContextChange, } from "./meeting-context.js";
@@ -41,6 +42,7 @@ export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validat
 export type { MeetingSource, SourceParticipant } from "./source.js";
 export type { ChatInput, ContractCase, EventCandidateFilter, IdentityInput, MeetingDetails, MeetingFilter, MeetingHitSource, MeetingInput, MeetingSave, MeetingStore, NewRecord, ParticipantInput, SearchHit, TranscriptInput, TranscriptRowInput, } from "./store.js";
 export type { MeetingTranscriptReceiptStore, MeetingTranscriptStore, TranscriptAppend, TranscriptAppendReceipt, UnlinkedTranscriptInput, } from "./transcript-store.js";
+export { parseTranscriptText, TranscriptTextError, type TranscriptTextHeader } from "./transcript-text.js";
 export { type MeetingMediaDescriptor, type MeetingRecognitionSegment, type MeetingTranscriptionContext, type MeetingTranscriptionOptions, type MeetingTranscriptionReceipt, type MeetingTranscriptionSource, transcribeMeeting, } from "./transcription.js";
 export { createUpcomingMeetingReader } from "./upcoming.js";
 export type { MeetingOccurrence, MeetingOccurrencePort, MeetingOccurrenceRead, MeetingOccurrenceSchedule, UpcomingMeetingRequest, UpcomingMeetingResult, } from "./upcoming-types.js";

package/dist/meetings/index.js

@@ -4,6 +4,7 @@ export { linkEvent } from "./events.js";
 export { exportMeeting, serializeVtt, } from "./export.js";
 export { findingHash, MEETING_FINDINGS_KIND, meetingFindingFingerprint, validateMeetingFindings, } from "./findings.js";
 export { findingFingerprint, validateFindings, } from "./findings-rules.js";
+export { MEETING_HIT_QUERY, meetingWordsQuery, parseMeetingQuery } from "./hit-query.js";
 export { importFiles } from "./import.js";
 export { MEETING_QUERY, meeting, meetingItem } from "./item.js";
 export { createMeetingContext, MEETING_FACT_TYPES, validateMeetingContextChange, } from "./meeting-context.js";
@@ -27,6 +28,7 @@ export { validateMeetingHitSearch } from "./search-validation.js";
 export { validateMeetingSeriesHistory, } from "./series-history.js";
 export { createMeetingSeriesInventoryReader } from "./series-inventory.js";
 export { validateMeetingSeriesInventoryCursor } from "./series-inventory-validation.js";
+export { parseTranscriptText, TranscriptTextError } from "./transcript-text.js";
 export { transcribeMeeting, } from "./transcription.js";
 export { createUpcomingMeetingReader } from "./upcoming.js";
 export { parseVtt, VttError } from "./vtt.js";

package/dist/meetings/mcp/search.d.ts

@@ -15,6 +15,7 @@ export declare const meetingSearchTool: {
             query: {
                 type: string;
                 minLength: number;
+                description: string;
             };
             meeting_id: {
                 type: string;
@@ -138,6 +139,11 @@ export declare const callMeetingSearchTool: (search: MeetingHitSearch, input: un
         id: string;
         excerpt: string;
         offset_ms: number | null;
+        match?: "corrected" | "words" | undefined;
+        corrections?: {
+            from: string;
+            to: string[];
+        }[] | undefined;
         source?: {
             ref: string;
             title: string | null;

package/dist/meetings/mcp/search.js

@@ -11,7 +11,11 @@ export const meetingSearchTool = {
     inputSchema: {
         type: "object",
         properties: {
-            query: { type: "string", minLength: 1 },
+            query: {
+                type: "string",
+                minLength: 1,
+                description: 'The messages query language: words (all required), OR, (groups), NOT or -word, "a phrase", "a b"~N for words within N transcript lines (at most 20), exact:word, from:"Name" for who said the line',
+            },
             meeting_id: integer,
             identity_id: integer,
             person_id: integer,

package/dist/meetings/project-evidence-answer.d.ts

@@ -24,6 +24,11 @@ export declare const meetingProjectEvidence: v.StrictObjectSchema<{
         readonly id: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.MinLengthAction<string, 1, undefined>]>;
         readonly excerpt: v.StringSchema<undefined>;
         readonly offset_ms: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 0, undefined>]>, undefined>;
+        readonly match: v.OptionalSchema<v.PicklistSchema<["words", "corrected"], undefined>, undefined>;
+        readonly corrections: v.OptionalSchema<v.ArraySchema<v.StrictObjectSchema<{
+            readonly from: v.StringSchema<undefined>;
+            readonly to: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>, undefined>, undefined>;
         readonly source: v.OptionalSchema<v.StrictObjectSchema<{
             readonly ref: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.RegexAction<string, "a reference such as `note:42`">]>;
             readonly title: v.NullableSchema<v.StringSchema<undefined>, undefined>;

package/dist/meetings/pull.d.ts

@@ -9,6 +9,8 @@ export interface RunReport {
         externalId: string;
         message: string;
     }[];
+    /** An import whose files all read their start time in one zone names it; files carry no zone of their own. */
+    timezone?: string;
 }
 export interface PullOptions {
     accountId: number;

package/dist/meetings/recording-schedule.js

@@ -12,6 +12,8 @@ const clock = (now) => {
     return new Date(now);
 };
 const day = (instant) => instant.toISOString().slice(0, 10);
+/** The calendar day it is at `instant` in the schedule's own zone: the day the owner's daily run belongs to. */
+const localDay = (instant, timeZone) => new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).format(instant);
 const identity = (schedule) => createHash("sha256").update(JSON.stringify(schedule)).digest("hex");
 export const planRecordingArchiveSchedule = (input, options) => {
     const now = clock(options.now);
@@ -29,8 +31,8 @@ export const planRecordingArchiveSchedule = (input, options) => {
         fail("archive schedule requires a valid IANA time zone");
     }
     recordingWindows(input.from, input.from);
-    if (input.from <= day(now))
-        recordingWindows(input.from, day(now));
+    if (input.from <= localDay(now, input.timeZone))
+        recordingWindows(input.from, localDay(now, input.timeZone));
     const lookbackDays = input.lookbackDays ?? 7;
     const maxBytes = input.maxBytes ?? 20 * 1024 ** 3;
     if (!Number.isSafeInteger(lookbackDays) || lookbackDays < 0 || lookbackDays > 31)
@@ -76,11 +78,10 @@ export const parseRecordingArchiveSchedule = (value) => {
 export const recordingArchiveScheduleWindow = (value, options) => {
     const schedule = parseRecordingArchiveSchedule(value);
     const now = clock(options.now);
-    const through = day(now);
+    const through = localDay(now, schedule.timeZone);
     if (schedule.from > through)
         return null;
-    const floor = new Date(now);
-    floor.setUTCHours(0, 0, 0, 0);
+    const floor = new Date(`${through}T00:00:00Z`);
     // A running job ages beyond its original ten-year discovery interval; saved pending work survives separately.
     const month = floor.getUTCMonth();
     const date = floor.getUTCDate();

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

@@ -1,3 +1,4 @@
+import type { QueryAst } from "@wirecat/cli-base/query";
 import type { SearchHit } from "./store.js";
 export interface MeetingSearchOptions {
     accountId: number;
@@ -37,7 +38,8 @@ export interface MeetingSearchPage {
 }
 /** Optional bounded read capability; paging reaches inside a single large transcript. */
 export interface MeetingSearchStore {
-    searchHits(query: string, options: MeetingSearchOptions): Promise<MeetingSearchPage>;
+    /** A string is what a person typed, parsed as a query; text that must not become syntax comes as `meetingWordsQuery`. */
+    searchHits(query: string | QueryAst, options: MeetingSearchOptions): Promise<MeetingSearchPage>;
 }
 export interface MeetingSearchIndexInput {
     accountId: number;

package/dist/meetings/store.d.ts

@@ -36,6 +36,12 @@ export interface MeetingSave {
     summaries?: Omit<NewRecord<Summary>, "meetingId">[];
     attachments?: Omit<NewRecord<Attachment>, "attachableType" | "attachableId">[];
     now: number;
+    /**
+     * A copy of the occurrence read from a file, not from the provider. It joins the provider's record of the same
+     * occurrence — same series, start within 15 minutes — and only fills a missing transcript there; a provider
+     * record saved later takes over a record made from files. Transcripts from files have source `file`.
+     */
+    fromFile?: boolean;
 }
 export interface MeetingDetails {
     meeting: Meeting;
@@ -82,6 +88,13 @@ export interface SearchHit {
     id: number;
     text: string;
     startMs: number | null;
+    /** `corrected` when a query word matched only as a stored word recognition may have garbled. */
+    match?: "words" | "corrected";
+    /** For a `corrected` hit, the stored words each such query word matched in this passage. */
+    corrections?: {
+        from: string;
+        to: string[];
+    }[];
 }
 export interface ContractCase {
     name: string;

package/dist/meetings/transcript-text.d.ts

@@ -0,0 +1,20 @@
+import type { TranscriptLine } from "./model.js";
+export declare class TranscriptTextError extends Error {
+    name: string;
+}
+/** What the header of a text transcript says, as written; the caller reads the date in its zone. */
+export interface TranscriptTextHeader {
+    title: string | null;
+    date: string | null;
+    meetingId: string | null;
+    speakers: string[];
+}
+/**
+ * A transcript in the text form zoom-searcher wrote: a header (`Встреча:`, `Дата:`, `Zoom ID:`, `Говорят:`),
+ * a rule, then `[hh:mm:ss] Speaker: text` blocks apart by a blank line. A block may run over several lines.
+ * A line ends where the next begins: the file keeps start times only.
+ */
+export declare const parseTranscriptText: (input: string) => {
+    header: TranscriptTextHeader;
+    lines: TranscriptLine[];
+};

package/dist/meetings/transcript-text.js

@@ -0,0 +1,59 @@
+export class TranscriptTextError extends Error {
+    name = "TranscriptTextError";
+}
+const HEADER = {
+    "Встреча: ": "title",
+    "Дата: ": "date",
+    "Zoom ID: ": "meetingId",
+    "Говорят: ": "speakers",
+};
+const LINE = /^\[(\d{2,}):([0-5]\d):([0-5]\d)\]\s*(?:([^:\n]{1,60}):\s*)?([\s\S]*)$/;
+// Early files had no blank line after the rule, so the first line of speech is glued to it.
+const RULE = /^[—–-]{10,}[^\n]*(?:\n|$)/;
+const EMPTY = new Set(["", "—", "-"]);
+/**
+ * A transcript in the text form zoom-searcher wrote: a header (`Встреча:`, `Дата:`, `Zoom ID:`, `Говорят:`),
+ * a rule, then `[hh:mm:ss] Speaker: text` blocks apart by a blank line. A block may run over several lines.
+ * A line ends where the next begins: the file keeps start times only.
+ */
+export const parseTranscriptText = (input) => {
+    const text = input.replace(/^/, "").replace(/\r\n?/g, "\n");
+    const header = { title: null, date: null, meetingId: null, speakers: [] };
+    let sawHeader = false;
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            break;
+        for (const [prefix, key] of Object.entries(HEADER)) {
+            if (!line.startsWith(prefix))
+                continue;
+            sawHeader = true;
+            const value = line.slice(prefix.length).trim();
+            if (key === "speakers")
+                header.speakers = value
+                    .split(",")
+                    .map((name) => name.trim())
+                    .filter((name) => !EMPTY.has(name));
+            else
+                header[key] = EMPTY.has(value) ? null : value;
+        }
+    }
+    if (!sawHeader)
+        throw new TranscriptTextError('a text transcript starts with a header such as "Встреча: …"');
+    const found = [];
+    for (const block of text.split(/\n\s*\n/)) {
+        const match = LINE.exec(block.trim().replace(RULE, ""));
+        if (!match)
+            continue;
+        const [, hours = "0", minutes = "0", seconds = "0", speaker, said = ""] = match;
+        found.push({
+            startMs: ((Number(hours) * 60 + Number(minutes)) * 60 + Number(seconds)) * 1000,
+            speaker: speaker?.trim() || null,
+            text: said.trim(),
+        });
+    }
+    const lines = found.map((line, at) => ({
+        ...line,
+        endMs: Math.max(line.startMs, found[at + 1]?.startMs ?? line.startMs),
+    }));
+    return { header, lines };
+};

package/dist/ports/messenger.d.ts

@@ -3,7 +3,7 @@ import type { CounterField, CounterObservations } from "../domain/counters.js";
 import type { HtmlFormatting, MarkdownFormatting, TextSpan } from "../domain/formatting.js";
 import type { Markup } from "../domain/markdown.js";
 import type { MessagePermalink } from "../domain/message-link.js";
-import type { Account, AccountSession, AdminRight, Button, CallRecord, Chat, ChatCard, ChatEvent, ChatEvents, ChatUpdate, Discussion, Folder, FolderChange, FolderRules, GroupCard, GroupChange, GroupMember, Id, InviteLink, InviteLinkChange, JoinRequest, LinkTarget, MediaKind, Member, Message, MessageEvent, MessageHit, OfficialChatStats, Page, PersonCard, PhoneBookEntry, Poll, PollVote, PrivacySettings, ProfileFacts, ProviderMetadata, SenderIdentity, Sticker, StickerSet, Topic, TopicChange, WindowedMessage } from "../domain/models.js";
+import type { Account, AccountSession, AdminRight, Button, CallRecord, Chat, ChatCard, ChatEvent, ChatEvents, ChatUpdate, Discussion, Folder, FolderChange, FolderRules, GroupCard, GroupChange, GroupMember, Id, InviteLink, InviteLinkChange, JoinRequest, LinkTarget, MediaKind, Member, Message, MessageEvent, MessageHit, OfficialChatStats, Page, PersonCard, PersonReaction, PhoneBookEntry, Poll, PollVote, PrivacySettings, ProfileFacts, ProviderMetadata, SenderIdentity, Sticker, StickerSet, Topic, TopicChange, WindowedMessage } from "../domain/models.js";
 /** One attachment's bytes, fetched over the adapter's connection when `bytes` is read — so read it before the command closes. */
 export interface RemoteFile {
     kind: string;
@@ -331,6 +331,12 @@ export interface HistoryVote {
     messageId: Id;
     vote: PollVote;
 }
+/** One person's reaction to message `messageId` of `chatId`, as `PersonReactionEvent` has it. */
+export interface HistoryReaction {
+    chatId: Id;
+    messageId: Id;
+    reaction: PersonReaction;
+}
 /** One change to who is in chat `chatId`, or to its title, as `ChatEventNotice` has it. */
 export interface HistoryChatEvent {
     chatId: Id;
@@ -344,8 +350,8 @@ export interface HistoryStar {
 }
 /**
  * What a messenger pushed in one go: any of chats, the people in them, past messages of any chats, votes in
- * their polls, the owner's stars, and changes to who is in them. A vote or a star is saved with its chat's messages,
- * after them, so a message in the same batch is held before its votes and its star.
+ * their polls, each person's reactions, the owner's stars, and changes to who is in them. A vote, a reaction or a star
+ * is saved with its chat's messages, after them, so a message in the same batch is held before them.
  * `rekeys` are chats the messenger now names by another id; they apply first, so the batch's messages under the
  * new id join the chat already stored under the old one.
  */
@@ -358,6 +364,7 @@ export interface HistoryBatch {
     people?: Member[];
     messages?: Message[];
     votes?: HistoryVote[];
+    reactions?: HistoryReaction[];
     stars?: HistoryStar[];
     events?: HistoryChatEvent[];
 }

package/dist/render/markdown.js

@@ -8,11 +8,11 @@ import { singleLine, visibleControls } from "@wirecat/cli-base";
  * as often as in an editor, and a byte that rewrites the screen is nobody's text.
  */
 export const toMarkdown = (title, messages, timeZone) => {
-    const zone = timeZone ? { timeZone } : {};
+    const zone = { timeZone: timeZone ?? Intl.DateTimeFormat().resolvedOptions().timeZone };
     const day = new Intl.DateTimeFormat("sv-SE", { ...zone, year: "numeric", month: "2-digit", day: "2-digit" });
     const clock = new Intl.DateTimeFormat("en-GB", { ...zone, hour: "2-digit", minute: "2-digit", hourCycle: "h23" });
     const byId = new Map(messages.map((message) => [message.id, message]));
-    const lines = [`# ${literal(singleLine(title))}`];
+    const lines = [`# ${literal(singleLine(title))}`, "", `Times are in ${zone.timeZone}.`];
     let today = "";
     for (const message of messages) {
         const when = new Date(message.timestamp);

package/dist/resolve.d.ts

@@ -7,6 +7,12 @@ export interface PeopleLookup {
 }
 /** Shaped like a Telegram or MAX id. Another messenger's ids may be any string, so a miss here is not "not an id". */
 export declare const isId: (reference: string) => boolean;
+/**
+ * A name as matching compares it. A copied emoji often carries a presentation mark (U+FE0F, U+FE0E) or a joiner
+ * (U+200D) the typed one lacks, and a letter may come composed or as letter plus accent; none of that is a different
+ * name.
+ */
+export declare const foldName: (name: string) => string;
 /**
  * A name matched as a fragment — and **an ambiguous one is an error, not a guess**: sending to the
  * wrong conversation is not undoable, so the caller is shown the candidates and asked to be

package/dist/resolve.js

@@ -1,6 +1,15 @@
 import { CliError, singleLine } from "@wirecat/cli-base";
 /** Shaped like a Telegram or MAX id. Another messenger's ids may be any string, so a miss here is not "not an id". */
 export const isId = (reference) => /^-?\d+$/.test(reference.trim());
+/**
+ * A name as matching compares it. A copied emoji often carries a presentation mark (U+FE0F, U+FE0E) or a joiner
+ * (U+200D) the typed one lacks, and a letter may come composed or as letter plus accent; none of that is a different
+ * name.
+ */
+export const foldName = (name) => name
+    .normalize("NFC")
+    .replace(/[\uFE0E\uFE0F\u200D]/g, "")
+    .toLowerCase();
 /**
  * A name matched as a fragment — and **an ambiguous one is an error, not a guess**: sending to the
  * wrong conversation is not undoable, so the caller is shown the candidates and asked to be
@@ -8,8 +17,8 @@ export const isId = (reference) => /^-?\d+$/.test(reference.trim());
  * "Мама" must not quietly take a send meant for "Мама Иванова".
  */
 export const pickChat = (reference, chats) => {
-    const wanted = reference.trim().toLowerCase();
-    const matches = chats.filter((chat) => chat.title?.toLowerCase().includes(wanted));
+    const wanted = foldName(reference.trim());
+    const matches = chats.filter((chat) => chat.title !== null && foldName(chat.title).includes(wanted));
     if (matches.length === 1 && matches[0])
         return matches[0];
     if (matches.length === 0)
@@ -27,9 +36,9 @@ export const pickPerson = (reference, people) => {
         return known;
     if (isId(trimmed))
         throw new CliError("not_found", `no person ${trimmed} in what this account has seen`);
-    const wanted = trimmed.replace(/^@/, "").toLowerCase();
+    const wanted = foldName(trimmed.replace(/^@/, ""));
     const everyone = people.all().toSorted((a, b) => (a.name ?? "").localeCompare(b.name ?? ""));
-    const fields = (person) => [person.alias, person.name, person.username].filter(isPresent).map((one) => one.toLowerCase());
+    const fields = (person) => [person.alias, person.name, person.username].filter(isPresent).map(foldName);
     const exact = everyone.filter((person) => fields(person).includes(wanted));
     const matches = exact.length > 0 ? exact : everyone.filter((person) => fields(person).some((one) => one.includes(wanted)));
     if (matches.length === 1 && matches[0])

package/dist/search/garbled.d.ts

@@ -0,0 +1,30 @@
+/** A query word as speech search widens it: its folded form and the stems the store's stemmers give it. */
+export interface GarbledProbe {
+    literal: string;
+    stems: string[];
+}
+/** ztx's floor: a shorter word has too many neighbours to widen safely. */
+export declare const SHORTEST_GARBLED = 4;
+export declare const isNumberWord: (word: string) => boolean;
+/** What the index already finds for the word: its beginning or one of its stems. */
+export declare const plainMatch: (probe: GarbledProbe, word: string, stems: string[]) => boolean;
+/**
+ * How far a stored word is from a query word, or `null` when it is not a candidate. `0` is another form the
+ * stemmer cut differently: a stem one side extends counts only when the other side's word spells the extension
+ * out — «циана» (stem `циа`) reaches «цианом» (`циан`), «устав» (`уста`) does not reach «установить» (`установ`).
+ * `1` is a spelling recognition may have garbled, compared by stem: «рилторов» is three edits from «риелтор»
+ * as a word but one as a stem; or a word recognition cut off, of four letters or more, that begins the query word
+ * («може» for «может»), as ztx matched.
+ */
+export declare const garbledDistance: (probe: GarbledProbe, word: string, stems: string[]) => number | null;
+/**
+ * The stored words each probe widens to, nearest first and then the most used, from one pass over the
+ * vocabulary, whose terms are folded as the index folds them. `stem` is the store's stemmer, so a stored
+ * word's stem is the one its index holds. A spelling that `known` finds in a dictionary is a different real
+ * word, not a garbled one — «договор» is one stem edit from «поговорить» — so only unknown spellings widen;
+ * on real transcripts that kept 517 of 10,271 widened passages.
+ */
+export declare const widenWords: (probes: GarbledProbe[], vocabulary: Iterable<{
+    term: string;
+    docs: number;
+}>, stem: (word: string) => string[], known: (word: string) => boolean) => string[][];

package/dist/search/garbled.js

@@ -0,0 +1,130 @@
+import { editDistance } from "./correct.js";
+import { createStemmer } from "./stem.js";
+/** ztx's floor: a shorter word has too many neighbours to widen safely. */
+export const SHORTEST_GARBLED = 4;
+const MOST_WIDENED = 64;
+/** The index folds ё but keeps э, and recognition writes «риэлтор» as often as «риелтор». */
+const plain = (word) => word.replaceAll("э", "е");
+const russian = createStemmer({ cyrillic: "russian", latin: "none" }, { cacheLimit: 10_000 });
+/**
+ * Recognition swaps one number for another («восемь» and «шесть» for one spoken word), and «десять» is one edit
+ * from «девять»; a widened number would be a wrong fact, so number words only ever match their own forms.
+ */
+const NUMBER_STEMS = new Set(`ноль нуль один одна одно одного одной одному одним одном одну два две двух двум двумя три трех трем тремя
+  четыре четырех четырем четырьмя пять пяти пятью шесть шести шестью семь семи семью восемь восьми восемью
+  девять девяти девятью десять десяти десятью одиннадцать двенадцать тринадцать четырнадцать пятнадцать
+  шестнадцать семнадцать восемнадцать девятнадцать двадцать двадцати тридцать тридцати сорок сорока пятьдесят
+  пятидесяти шестьдесят шестидесяти семьдесят семидесяти восемьдесят восьмидесяти девяносто девяноста сто ста
+  двести двухсот триста трехсот четыреста четырехсот пятьсот пятисот шестьсот семьсот восемьсот девятьсот
+  тысяча тысячи тысяч миллион миллиона миллионов миллиард первый второй третий четвертый пятый шестой седьмой
+  восьмой девятый десятый сотый тысячный половина треть четверть`
+    .split(/\s+/)
+    .map((word) => russian.stemToken(word)));
+export const isNumberWord = (word) => /\d/.test(word) || NUMBER_STEMS.has(russian.stemToken(word));
+/**
+ * One edit between stems, tighter than typed-text correction (`maxEdits`), because a transcript always widens
+ * instead of only when nothing matched: two edits turn «проверка» into «провела», «работа» into «заботы».
+ * A stem shorter than this keeps its first letter; a longer one may gain one, as «дриелтора» does.
+ */
+const LOOSE_START = 7;
+/** What the index already finds for the word: its beginning or one of its stems. */
+export const plainMatch = (probe, word, stems) => word.startsWith(probe.literal) || stems.some((stem) => probe.stems.includes(stem));
+/**
+ * How far a stored word is from a query word, or `null` when it is not a candidate. `0` is another form the
+ * stemmer cut differently: a stem one side extends counts only when the other side's word spells the extension
+ * out — «циана» (stem `циа`) reaches «цианом» (`циан`), «устав» (`уста`) does not reach «установить» (`установ`).
+ * `1` is a spelling recognition may have garbled, compared by stem: «рилторов» is three edits from «риелтор»
+ * as a word but one as a stem; or a word recognition cut off, of four letters or more, that begins the query word
+ * («може» for «может»), as ztx matched.
+ */
+export const garbledDistance = (probe, word, stems) => {
+    if (probe.literal.length < SHORTEST_GARBLED || plainMatch(probe, word, stems))
+        return null;
+    if (isNumberWord(probe.literal) || isNumberWord(word))
+        return null;
+    const literal = plain(probe.literal);
+    const stored = plain(word);
+    let best = null;
+    for (const queryStem of probe.stems.map(plain))
+        for (const wordStem of stems.map(plain)) {
+            if (Math.min(queryStem.length, wordStem.length) < 3)
+                continue;
+            if ((wordStem.startsWith(queryStem) && literal.startsWith(wordStem)) ||
+                (queryStem.startsWith(wordStem) && stored.startsWith(queryStem)))
+                return 0;
+            if (queryStem.length < SHORTEST_GARBLED)
+                continue;
+            if (queryStem.length < LOOSE_START && queryStem[0] !== wordStem[0])
+                continue;
+            const distance = editDistance(queryStem, wordStem, 1);
+            if (distance <= 1)
+                best = distance;
+        }
+    if (best === null && stored.length >= SHORTEST_GARBLED && literal.startsWith(stored))
+        return 1;
+    return best;
+};
+/** `editDistance` from `stem` to the nearest beginning of `word`, or `max + 1` once every beginning is further. */
+const prefixDistance = (stem, word, max) => {
+    let before = new Int32Array(word.length + 1);
+    let previous = new Int32Array(word.length + 1);
+    let current = new Int32Array(word.length + 1);
+    for (let i = 1; i <= stem.length; i++) {
+        current[0] = i;
+        let lowest = i;
+        for (let j = 1; j <= word.length; j++) {
+            let value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + (stem[i - 1] === word[j - 1] ? 0 : 1));
+            if (i > 1 && j > 1 && stem[i - 1] === word[j - 2] && stem[i - 2] === word[j - 1])
+                value = Math.min(value, before[j - 2] + 1);
+            current[j] = value;
+            lowest = Math.min(lowest, value);
+        }
+        if (lowest > max)
+            return max + 1;
+        [before, previous, current] = [previous, current, before];
+    }
+    return previous.reduce((lowest, value) => Math.min(lowest, value), max + 1);
+};
+/**
+ * Whether a stored word can pass `garbledDistance`, checked without stemming it: a stem begins its word, so a
+ * near stem means a near beginning. Stemming every stored word in a fresh process costs half a second.
+ */
+const worthStemming = (probe, word) => {
+    const stored = plain(word);
+    if (stored.length >= SHORTEST_GARBLED && plain(probe.literal).startsWith(stored))
+        return true;
+    return probe.stems.some((raw) => {
+        const stem = plain(raw);
+        if (stem.length >= 3 && stored.startsWith(stem))
+            return true;
+        return stem.length >= SHORTEST_GARBLED && prefixDistance(stem, stored, 1) <= 1;
+    });
+};
+/**
+ * The stored words each probe widens to, nearest first and then the most used, from one pass over the
+ * vocabulary, whose terms are folded as the index folds them. `stem` is the store's stemmer, so a stored
+ * word's stem is the one its index holds. A spelling that `known` finds in a dictionary is a different real
+ * word, not a garbled one — «договор» is one stem edit from «поговорить» — so only unknown spellings widen;
+ * on real transcripts that kept 517 of 10,271 widened passages.
+ */
+export const widenWords = (probes, vocabulary, stem, known) => {
+    const found = probes.map(() => []);
+    const live = probes.map((probe) => probe.literal.length >= SHORTEST_GARBLED);
+    if (!live.some(Boolean))
+        return probes.map(() => []);
+    for (const { term: word, docs } of vocabulary) {
+        let stems;
+        probes.forEach((probe, at) => {
+            if (!live[at] || !worthStemming(probe, word))
+                return;
+            stems ??= stem(word);
+            const distance = garbledDistance(probe, word, stems);
+            if (distance === 0 || (distance === 1 && !known(word)))
+                found[at]?.push({ term: word, docs, distance });
+        });
+    }
+    return found.map((words) => words
+        .sort((a, b) => a.distance - b.distance || b.docs - a.docs || a.term.localeCompare(b.term))
+        .slice(0, MOST_WIDENED)
+        .map((word) => word.term));
+};

package/dist/search/russian-dictionary.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 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 declare const knownRussianWord: (word: string) => boolean;