@wirecat/cli-core 0.395.0 → 0.397.0

package/dist/services/media-archive-move.d.ts

@@ -0,0 +1,21 @@
+export interface MoveMediaArchiveOptions {
+    directory: string;
+    archiveDirectory: string;
+    beforeTime: string;
+    dryRun?: boolean;
+    signal?: AbortSignal;
+}
+/** The destination is durable before a source relocation record is published, then the verified local copy is removed. */
+export declare const moveMediaArchive: (options: MoveMediaArchiveOptions) => Promise<{
+    directory: string;
+    archiveDirectory: string;
+    beforeTime: string;
+    selected: number;
+    selectedBytes: number;
+    moved: number;
+    movedBytes: number;
+    alreadyArchived: number;
+    undated: number;
+    complete: boolean;
+    dryRun: boolean;
+}>;

package/dist/services/media-archive-move.js

@@ -0,0 +1,163 @@
+import { realpath, unlink } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { CliError } from "@wirecat/cli-base";
+import { openOrdinaryFile, sameOrdinaryFile, syncDirectory, writeFileAtomic } from "../files/index.js";
+import { validateMediaSince } from "./media-archive.js";
+import { archiveMediaFile } from "./media-archive-files.js";
+import { withMediaArchiveLocks } from "./media-archive-locks.js";
+import { mediaFingerprint, mediaKey, mediaManifestName, missingMediaFile, parseMediaEntry, readMediaManifests, sameMediaCopy, verifyMediaEntry, } from "./media-archive-manifest.js";
+const canonicalDestination = async (directory) => {
+    const path = resolve(directory);
+    try {
+        return await realpath(path);
+    }
+    catch (error) {
+        if (!missingMediaFile(error) || dirname(path) === path)
+            throw error;
+        return join(await canonicalDestination(dirname(path)), basename(path));
+    }
+};
+const image = (entry) => ["photo", "image"].includes(entry.kind) || entry.mime?.startsWith("image/");
+const removeLocalCopy = async (root, entry, beforeWrite, signal) => {
+    const path = join(root, entry.path);
+    let file;
+    try {
+        file = await openOrdinaryFile(path);
+    }
+    catch (error) {
+        if (missingMediaFile(error))
+            return;
+        throw error;
+    }
+    try {
+        const identity = await file.stat({ bigint: true });
+        const proof = await mediaFingerprint(path, signal);
+        if (proof.size !== entry.size || proof.sha256 !== entry.sha256 || !(await sameOrdinaryFile(path, identity)))
+            throw new CliError("validation_error", "local image changed during rotation; it was preserved");
+        if (!(await verifyMediaEntry(root, entry, signal)))
+            throw new CliError("validation_error", "rotated image checksum mismatch; the local copy was preserved");
+        await beforeWrite();
+        if (!(await sameOrdinaryFile(path, identity)))
+            throw new CliError("validation_error", "local image was replaced; it was preserved");
+        await unlink(path);
+        await syncDirectory(root);
+    }
+    finally {
+        await file.close();
+    }
+};
+/** The destination is durable before a source relocation record is published, then the verified local copy is removed. */
+export const moveMediaArchive = async (options) => {
+    const cutoff = validateMediaSince(options.beforeTime, "--before-time");
+    if (cutoff === undefined)
+        throw new CliError("validation_error", "--before-time is required");
+    const target = await canonicalDestination(options.archiveDirectory);
+    const source = await realpath(options.directory);
+    if (source === target)
+        throw new CliError("validation_error", "choose a different archive destination");
+    return withMediaArchiveLocks(source, options.signal, async (root, beforeWrite) => {
+        const entries = await readMediaManifests(root, options.signal);
+        if (!entries.length)
+            throw new CliError("not_found", "no media archive manifests in this directory");
+        const targetEntries = await readMediaManifests(target, options.signal).catch((error) => {
+            if (options.dryRun && missingMediaFile(error))
+                return [];
+            throw error;
+        });
+        for (const [folder, manifests] of [
+            [root, entries],
+            [target, targetEntries],
+        ])
+            for (const entry of manifests) {
+                let valid = false;
+                try {
+                    valid = await verifyMediaEntry(folder, entry, options.signal);
+                }
+                catch {
+                    options.signal?.throwIfAborted();
+                }
+                if (!valid)
+                    throw new CliError("validation_error", "archive checksum mismatch or missing file; no images were moved");
+            }
+        const known = new Map(targetEntries.map((entry) => [mediaKey(entry), entry]));
+        let selected = 0, moved = 0, movedBytes = 0, selectedBytes = 0, undated = 0, alreadyArchived = 0;
+        const candidates = [];
+        for (const entry of entries) {
+            if (!image(entry))
+                continue;
+            if (!entry.messageTime) {
+                undated++;
+                continue;
+            }
+            if (Date.parse(entry.messageTime) >= cutoff)
+                continue;
+            if (entry.relocatedTo) {
+                alreadyArchived++;
+                if (!options.dryRun)
+                    await removeLocalCopy(root, entry, beforeWrite, options.signal);
+                continue;
+            }
+            const existing = known.get(mediaKey(entry));
+            if (existing?.relocatedTo)
+                throw new CliError("validation_error", "destination image is already relocated; choose its current archive directory");
+            if (existing && !sameMediaCopy(entry, existing))
+                throw new CliError("validation_error", "destination has a different copy of this image; choose a new destination");
+            candidates.push(entry);
+            selected++;
+            selectedBytes += entry.size;
+        }
+        if (!options.dryRun)
+            for (const entry of candidates) {
+                await beforeWrite();
+                if (!known.has(mediaKey(entry))) {
+                    const file = await openOrdinaryFile(join(root, entry.path));
+                    try {
+                        const identity = {
+                            provider: entry.provider,
+                            account: entry.account,
+                            chat: entry.chat,
+                            message: entry.message,
+                            position: entry.position,
+                        };
+                        const copied = await archiveMediaFile(target, identity, entry.kind, async () => ({
+                            kind: entry.kind,
+                            size: entry.size,
+                            bytes: () => file.createReadStream({ autoClose: false, ...(options.signal ? { signal: options.signal } : {}) }),
+                        }), beforeWrite, options.signal, {
+                            messageTime: entry.messageTime,
+                            mime: entry.mime,
+                            expected: { size: entry.size, sha256: entry.sha256 },
+                        });
+                        known.set(mediaKey(entry), copied);
+                    }
+                    finally {
+                        await file.close();
+                    }
+                }
+                const receipt = parseMediaEntry({ ...entry, relocatedTo: target });
+                if (!(await verifyMediaEntry(root, receipt, options.signal)))
+                    throw new CliError("validation_error", "archive destination changed before rotation; the original was preserved");
+                await beforeWrite();
+                await writeFileAtomic(join(root, mediaManifestName(entry)), JSON.stringify(receipt), {
+                    beforePublish: beforeWrite,
+                    signal: options.signal,
+                });
+                await removeLocalCopy(root, receipt, beforeWrite, options.signal);
+                moved++;
+                movedBytes += entry.size;
+            }
+        return {
+            directory: root,
+            archiveDirectory: target,
+            beforeTime: new Date(cutoff).toISOString(),
+            selected,
+            selectedBytes,
+            moved,
+            movedBytes,
+            alreadyArchived,
+            undated,
+            complete: undated === 0,
+            dryRun: options.dryRun === true,
+        };
+    }, { additional: [target], createAdditional: !options.dryRun });
+};

package/dist/services/media-archive.d.ts

@@ -0,0 +1,34 @@
+import type { ChatsService } from "./chats.js";
+import { type MediaArchiveEntry } from "./media-archive-manifest.js";
+import type { MessagesService } from "./messages.js";
+export interface MediaArchivePorts {
+    chats: Pick<ChatsService, "list" | "account" | "show">;
+    messages: Pick<MessagesService, "list" | "download">;
+}
+export interface MediaArchiveOptions {
+    directory: string;
+    chats?: readonly string[];
+    sinceTime?: string;
+    orderByTime?: boolean;
+    pageSize?: number;
+    pauseMs?: number;
+    signal?: AbortSignal;
+    onSaved?: (entry: MediaArchiveEntry) => void;
+}
+export declare const validateMediaSince: (value?: string, flag?: string) => number | undefined;
+export declare const checkMediaArchive: (directory: string, signal?: AbortSignal) => Promise<{
+    valid: boolean;
+    checked: number;
+    files: {
+        path: string;
+        valid: boolean;
+        archiveDirectory?: string;
+    }[];
+}>;
+export declare const archiveMedia: (ports: MediaArchivePorts, options: MediaArchiveOptions) => Promise<{
+    directory: string;
+    chats: number;
+    saved: number;
+    existing: number;
+    complete: boolean;
+}>;

package/dist/services/media-archive.js

@@ -0,0 +1,165 @@
+import { setTimeout as sleep } from "node:timers/promises";
+import { CliError } from "@wirecat/cli-base";
+import { matchDownloads, NOT_FILES } from "../domain/attachments.js";
+import { archiveMediaFile } from "./media-archive-files.js";
+import { withMediaArchiveLocks } from "./media-archive-locks.js";
+import { mediaKey, readMediaManifests, verifyMediaEntry } from "./media-archive-manifest.js";
+export const validateMediaSince = (value, flag = "--since-time") => {
+    if (value === undefined)
+        return undefined;
+    if (!/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.\d{1,3})?(?:Z|[+-]\d\d:\d\d)$/.test(value) ||
+        !Number.isFinite(Date.parse(value)))
+        throw new CliError("validation_error", `${flag} needs an ISO timestamp with a time zone`);
+    const date = value.slice(0, 10);
+    if (new Date(`${date}T00:00:00Z`).toISOString().slice(0, 10) !== date)
+        throw new CliError("validation_error", `${flag} has an invalid calendar date`);
+    return Date.parse(value);
+};
+export const checkMediaArchive = (directory, signal) => withMediaArchiveLocks(directory, signal, async (root) => {
+    const entries = await readMediaManifests(root, signal);
+    if (!entries.length)
+        throw new CliError("not_found", "no media archive manifests in this directory");
+    const files = [];
+    for (const entry of entries) {
+        let valid = false;
+        try {
+            valid = await verifyMediaEntry(root, entry, signal);
+        }
+        catch {
+            signal?.throwIfAborted();
+        }
+        files.push({ path: entry.path, valid, ...(entry.relocatedTo ? { archiveDirectory: entry.relocatedTo } : {}) });
+    }
+    return { valid: files.every((one) => one.valid), checked: files.length, files };
+});
+const saveMessage = async (root, account, message, ports, known, beforeWrite, options) => {
+    let download;
+    let saved = 0;
+    let existing = 0;
+    for (const [position, attachment] of message.attachments.entries()) {
+        if (NOT_FILES.has(attachment.kind))
+            continue;
+        await beforeWrite();
+        const identity = { ...account, chat: message.chatId, message: message.id, position };
+        const key = mediaKey(identity);
+        if (known.has(key)) {
+            existing++;
+            continue;
+        }
+        const entry = await archiveMediaFile(root, identity, attachment.kind, async () => {
+            download ??= await ports.messages.download(message.chatId, message.id);
+            const positions = matchDownloads(message.attachments.map((one, index) => ({
+                position: index,
+                kind: one.kind,
+                name: one.name ?? null,
+            })), download.files);
+            const index = positions.indexOf(position);
+            const file = download.files[index];
+            if (!file)
+                throw new CliError("invalid_response", "the messenger did not return an identifiable attachment");
+            return file;
+        }, beforeWrite, options.signal, { messageTime: new Date(message.timestamp).toISOString(), ...(attachment.mime ? { mime: attachment.mime } : {}) });
+        known.set(key, entry);
+        saved++;
+        options.onSaved?.(entry);
+    }
+    return { saved, existing };
+};
+export const archiveMedia = async (ports, options) => {
+    const since = validateMediaSince(options.sinceTime);
+    const pageSize = options.pageSize ?? 100;
+    const pauseMs = options.pauseMs ?? 1000;
+    if (!Number.isSafeInteger(pageSize) ||
+        pageSize < 1 ||
+        pageSize > 1000 ||
+        !Number.isSafeInteger(pauseMs) ||
+        pauseMs < 0)
+        throw new CliError("validation_error", "invalid media archive page size or pause");
+    return withMediaArchiveLocks(options.directory, options.signal, async (root, beforeWrite) => {
+        const known = new Map();
+        for (const entry of await readMediaManifests(root, options.signal)) {
+            let valid = false;
+            try {
+                valid = await verifyMediaEntry(root, entry, options.signal);
+            }
+            catch {
+                options.signal?.throwIfAborted();
+            }
+            if (!valid)
+                throw new CliError("validation_error", "archive checksum mismatch or missing file; choose a new destination");
+            known.set(mediaKey(entry), entry);
+        }
+        const account = await ports.chats.account();
+        let saved = 0, existing = 0, chats = 0;
+        const walk = async (chat) => {
+            const seen = new Set();
+            let before;
+            for (;;) {
+                await beforeWrite();
+                const page = await ports.messages.list(chat, { limit: pageSize, ...(before ? { before } : {}) });
+                let fresh = 0;
+                let reachedSince = false;
+                let oldest;
+                for (const message of page.items) {
+                    const timestamp = Date.parse(message.timestamp);
+                    if (!Number.isFinite(timestamp))
+                        throw new CliError("invalid_response", "media history has an invalid timestamp");
+                    if (!oldest || timestamp < Date.parse(oldest.timestamp))
+                        oldest = message;
+                    if (since !== undefined && timestamp < since) {
+                        reachedSince = true;
+                        continue;
+                    }
+                    if (seen.has(message.id))
+                        continue;
+                    seen.add(message.id);
+                    fresh++;
+                    const one = await saveMessage(root, account, message, ports, known, beforeWrite, options);
+                    saved += one.saved;
+                    existing += one.existing;
+                }
+                if (!page.hasMore || reachedSince)
+                    break;
+                if (!oldest || !fresh)
+                    throw new CliError("invalid_response", "media history pagination did not advance; archive is incomplete");
+                before = options.orderByTime ? new Date(Date.parse(oldest.timestamp) + 1).toISOString() : page.items[0]?.id;
+                if (pauseMs)
+                    await sleep(pauseMs, undefined, { signal: options.signal });
+            }
+            chats++;
+        };
+        if (options.chats?.length) {
+            const ids = new Set();
+            for (const chat of options.chats) {
+                const found = await ports.chats.show(chat);
+                if (!ids.has(found.id)) {
+                    ids.add(found.id);
+                    await walk(found.id);
+                }
+            }
+        }
+        else {
+            const seen = new Set();
+            let offset = 0;
+            for (;;) {
+                await beforeWrite();
+                const page = await ports.chats.list({ offset, limit: 100 });
+                let fresh = 0;
+                for (const chat of page.items)
+                    if (!seen.has(chat.id)) {
+                        seen.add(chat.id);
+                        fresh++;
+                        await walk(chat.id);
+                    }
+                if (!page.hasMore)
+                    break;
+                if (!fresh)
+                    throw new CliError("invalid_response", "chat pagination did not advance; archive is incomplete");
+                offset += page.items.length;
+                if (pauseMs)
+                    await sleep(pauseMs, undefined, { signal: options.signal });
+            }
+        }
+        return { directory: root, chats, saved, existing, complete: true };
+    }, { create: true });
+};

package/dist/services/messages-search.js

@@ -331,7 +331,9 @@ export const searchLucene = async (store, account, request, messenger = {}) => {
     // Coverage counts messenger chats fetched from a server; mail is imported whole, so for mail it says nothing.
     const { completeness, coverage } = request.kind === "mail" ? { completeness: [], coverage: undefined } : await coverageOf(store, prepared, messenger);
     const items = await Promise.all(found.items.map(async (item) => {
-        const hit = withExcerpt(item, request.text ?? "");
+        // A garbled spelling is not among the typed words, so the excerpt looks for it too.
+        const garbled = item.corrections?.flatMap(({ to }) => to) ?? [];
+        const hit = withExcerpt(item, [request.text ?? "", ...garbled].join(" "));
         if (!request.context)
             return hit;
         const locator = parseLocator(hit.locator);
@@ -347,7 +349,7 @@ export const searchLucene = async (store, account, request, messenger = {}) => {
     return {
         ...found,
         items,
-        corrections: [],
+        corrections: correctionsOf(found.items),
         wordsReady: prepared.wordsReady,
         stemsReady: prepared.stemsReady,
         completeness,
@@ -359,6 +361,15 @@ export const searchLucene = async (store, account, request, messenger = {}) => {
             : {}),
     };
 };
+/** The garbled spellings voice-note hits were found through, one entry per query word. */
+const correctionsOf = (items) => {
+    const found = new Map();
+    for (const { corrections = [] } of items)
+        for (const { from, to } of corrections)
+            for (const word of to)
+                found.set(from, (found.get(from) ?? new Set()).add(word));
+    return [...found].map(([from, to]) => ({ from, to: [...to] }));
+};
 const QUERY_PAGE_LIMIT = 1000;
 const oldestFetch = (chats) => chats.length === 0 || chats.some(({ fetchedAt }) => fetchedAt === null)
     ? null

package/dist/services/messages.d.ts

@@ -81,6 +81,11 @@ export type FoundMessage = StoredHit & {
         parent?: string;
     };
     match?: "words" | "beginnings" | "corrected";
+    /** The garbled spellings a `corrected` hit's transcript holds, per query word. */
+    corrections?: {
+        from: string;
+        to: string[];
+    }[];
     /** Where the words were: the text, a voice note's transcript, a file's name or a file's text. */
     matchedIn?: MatchPlace;
     score?: number | null;

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

@@ -24,7 +24,10 @@ export interface SearchIndexStore {
     }): Promise<SearchIndexFill>;
     /** How far the stems are built, and by which stemmer choices; `undefined` on a file before they existed. */
     stemsState(): Promise<StemsState | undefined>;
-    /** Builds the stems towards "ready" in short batches until done or `until` says stop; never rebuilds. */
+    /**
+     * Builds the stems towards "ready" in short batches until done or `until` says stop; never rebuilds. Then the
+     * voice-note transcripts written since, which are few, so they keep up with any stemmer choice.
+     */
     fillStems(options?: {
         until?: () => boolean;
     }): Promise<StemsFill>;

package/dist/store/search-index.js

@@ -1,3 +1,4 @@
+import { CORPORA, corpusIndexState, drainCorpus } from "./sqlite/note-index.js";
 import * as searchIndex from "./sqlite/search-index.js";
 import * as stems from "./sqlite/stems.js";
 import { fillStems } from "./sqlite/stems-fill.js";
@@ -5,13 +6,21 @@ import { write } from "./sqlite/transaction.js";
 import * as words from "./sqlite/words.js";
 export const searchIndexStoreOver = (context) => {
     const { database } = context;
+    const stemmerFor = stems.stemmerCache();
     return {
         knownTerms: async (terms) => words.knownTerms(context, terms),
         termCandidates: async (trigrams, lengths) => words.termCandidates(context, trigrams, lengths),
         searchIndexState: async () => searchIndex.searchIndexState(database),
         fillSearchIndex: async ({ until } = {}) => searchIndex.fillSearchIndex(database, { now: context.now, ...(until ? { until } : {}) }),
         stemsState: async () => stems.stemsState(database),
-        fillStems: async ({ until } = {}) => fillStems(database, { now: context.now, ...(until ? { until } : {}) }),
+        fillStems: async ({ until } = {}) => {
+            const filled = fillStems(database, { now: context.now, ...(until ? { until } : {}) });
+            // Read first: every search asks, and an idle drain must not take the write lock.
+            const transcripts = corpusIndexState(database, CORPORA.transcript);
+            if (transcripts.wanted !== null && (transcripts.pending > 0 || transcripts.built !== transcripts.wanted))
+                drainCorpus(database, CORPORA.transcript, stemmerFor, until ? { until } : {});
+            return filled;
+        },
         stemmers: async () => stems.savedStemmers(database),
         saveStemmers: async (stemmers) => write(database, () => stems.saveStoreStemmers(database, stemmers, context.now())),
     };

package/dist/store/sqlite/hit-places.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedPredicate } from "../../search/lucene/resolved.js";
+import type { CacheDatabase } from "../driver.js";
+import { type Corpus, type Leaf } from "./lucene-fields.js";
+import type { hitsByPk } from "./search.js";
+import { type TranscriptTerms } from "./transcript-query.js";
+type Hits = ReturnType<typeof hitsByPk>;
+/**
+ * Which place of each hit holds the words, first match wins in the order of `MatchPlace`; a hit its transcript
+ * holds only through a spelling speech recognition garbled is `corrected`.
+ */
+export declare const placeHits: (database: CacheDatabase, corpus: Corpus, leaves: Leaf[], transcripts: Map<ResolvedPredicate, TranscriptTerms>, found: Hits, pks: number[]) => Hits;
+export {};

package/dist/store/sqlite/hit-places.js

@@ -0,0 +1,76 @@
+import { normalize } from "../normalize.js";
+import { ftsMatch, SPEECH } from "./lucene-fields.js";
+import { spokenTranscripts } from "./transcript-query.js";
+/**
+ * Which place of each hit holds the words, first match wins in the order of `MatchPlace`; a hit its transcript
+ * holds only through a spelling speech recognition garbled is `corrected`.
+ */
+export const placeHits = (database, corpus, leaves, transcripts, found, pks) => {
+    const placeLeaves = leaves.filter(({ node }) => (node.operator === "term" || node.operator === "phrase") &&
+        (node.implicit || node.field === "content" || node.field === "transcript"));
+    if (!placeLeaves.length || !pks.length || found.length !== pks.length)
+        return found;
+    const keys = JSON.stringify(pks);
+    const wordy = placeLeaves.filter(({ node }) => /[\p{L}\p{N}]/u.test(normalize(node.value)));
+    if (!wordy.length)
+        return found;
+    const match = wordy.map(({ node }) => ftsMatch(node)).join(" OR ");
+    const implicit = placeLeaves.some(({ node }) => node.implicit);
+    const inText = new Set(implicit
+        ? database
+            .prepare(`SELECT rowid AS id FROM ${corpus.words} WHERE ${corpus.words} MATCH ? AND rowid IN (SELECT value FROM json_each(?))${placeLeaves.some(({ fragment }) => fragment.stems)
+            ? ` UNION SELECT rowid FROM ${corpus.stems} WHERE ${corpus.stems} MATCH ? AND rowid IN (SELECT value FROM json_each(?))`
+            : ""}`)
+            .all(`normalized_text : (${match})`, keys, ...(placeLeaves.some(({ fragment }) => fragment.stems)
+            ? [
+                `stems : (${placeLeaves.flatMap(({ fragment }) => (fragment.stems ? [`(${fragment.stems})`] : [])).join(" OR ")})`,
+                keys,
+            ]
+            : []))
+            .map(({ id }) => Number(id))
+        : []);
+    const files = database
+        .prepare(`SELECT att.attachable_id AS id, att.text AS text, ${SPEECH} AS speech FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.attachable_id IN (SELECT value FROM json_each(?)) AND att.id IN (SELECT rowid FROM attachment_words WHERE attachment_words MATCH ?) ORDER BY att.position`)
+        .all(keys, match);
+    const fileFields = new Set(placeLeaves.flatMap(({ node }) => (node.implicit ? ["transcript", "content"] : [node.field])));
+    const spoken = spokenTranscripts(database, corpus.item, wordy.flatMap(({ node }) => transcripts.get(node) ?? []), keys);
+    const allNames = implicit
+        ? database
+            .prepare(`SELECT att.attachable_id AS id, att.name AS name FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.attachable_id IN (SELECT value FROM json_each(?)) AND att.name IS NOT NULL ORDER BY att.position`)
+            .all(keys)
+        : [];
+    return found.map((hit, index) => {
+        const pk = pks[index];
+        const transcript = spoken.get(pk);
+        const file = files.find((row) => Number(row.id) === pk && Number(row.speech) !== 1);
+        const name = allNames.find((row) => {
+            if (Number(row.id) !== pk)
+                return false;
+            const words = normalize(String(row.name)).split(/[^\p{L}\p{N}]+/u);
+            return wordy.some(({ node }) => {
+                const phrase = normalize(node.value).match(/[\p{L}\p{N}]+/gu) ?? [];
+                if (node.slop !== undefined)
+                    return phrase.every((word) => words.includes(word));
+                return words.some((_, at) => phrase.every((word, offset) => words[at + offset] === word));
+            });
+        });
+        const place = inText.has(pk)
+            ? ["text", hit.text]
+            : transcript && fileFields.has("transcript")
+                ? ["transcript", String(transcript.text)]
+                : name
+                    ? ["filename", String(name.name)]
+                    : file && fileFields.has("content")
+                        ? ["file", String(file.text)]
+                        : undefined;
+        if (!place)
+            return hit;
+        const fixes = place[0] === "transcript" ? (transcript?.corrections ?? []) : [];
+        return {
+            ...hit,
+            matchedIn: place[0],
+            matchedText: place[1],
+            ...(fixes.length ? { match: "corrected", corrections: fixes } : {}),
+        };
+    });
+};

package/dist/store/sqlite/lucene-fields.d.ts

@@ -1,5 +1,6 @@
 import { type Automaton, type MatchBudget } from "../../search/lucene/automaton.js";
 import type { QueryExecution, ResolvedPredicate } from "../../search/lucene/resolved.js";
+import { type Stemmer } from "../../search/stem.js";
 import type { CacheDatabase, SqlValue } from "../driver.js";
 export interface Fragment {
     sql: string;
@@ -57,6 +58,11 @@ export interface FieldScope {
         sql: string;
         params: SqlValue[];
     };
+    /** The items whose voice-note transcripts a leaf matches: typed, in another form, or garbled. */
+    transcripts: (node: ResolvedPredicate) => {
+        sql: string;
+        params: SqlValue[];
+    };
     everywhere: (node: ResolvedPredicate, fragment: Fragment) => Fragment;
     /** Counts the patterns' expanded words against the query's budget. */
     expand: (count: number) => number;
@@ -67,6 +73,8 @@ type Compiled = {
     test?: Leaf["test"];
 } | Leaf;
 type FieldCompiler = (node: ResolvedPredicate, scope: FieldScope) => Compiled;
+/** A leaf as an FTS5 match over a stem index: phrases of stems, or with `~N` their `NEAR`. */
+export declare const stemMatch: (stemmer: Stemmer, node: ResolvedPredicate) => string | undefined;
 /** One compiler per field of `QUERY_FIELDS`, by its name: a leaf compiles by a lookup, never a branch. */
 export declare const FIELD_COMPILERS: Readonly<Record<string, FieldCompiler>>;
 export {};

package/dist/store/sqlite/lucene-fields.js

@@ -72,10 +72,12 @@ const mentioned = ({ mail }, where, params) => mail
     : bound(`m.id IN (SELECT mn.source_id FROM mentions mn WHERE mn.source_type='message' AND ${where} ` +
         "UNION SELECT a.attachable_id FROM mentions mn JOIN attachments a ON a.id=mn.source_id " +
         `AND a.attachable_type='message' WHERE mn.source_type='attachment' AND ${where})`, ...params, ...params);
-const stemsOf = ({ execution: { stemmer } }, node) => {
+const stemsOf = ({ execution: { stemmer } }, node) => stemmer ? stemMatch(stemmer, node) : undefined;
+/** A leaf as an FTS5 match over a stem index: phrases of stems, or with `~N` their `NEAR`. */
+export const stemMatch = (stemmer, node) => {
     if (node.slop === undefined)
-        return stemmer?.phrases(node.value);
-    const sequences = (stemmer?.stemSequences(node.value) ?? []).filter((sequence) => sequence.length);
+        return stemmer.phrases(node.value);
+    const sequences = stemmer.stemSequences(node.value).filter((sequence) => sequence.length);
     return sequences.length
         ? sequences
             .map((sequence) => (sequence.length > 1 ? nearMatch(sequence, node.slop) : quoted(sequence.join(""))))
@@ -256,7 +258,7 @@ const size = (node, { corpus }) => {
 const attachmentText = (which) => (node, scope) => {
     const text = normalize(node.value);
     // Never `fts`: the ranking ANDs every required word into message_words, where a file's words are not.
-    const set = scope.attachmentWords(ftsMatch(node), which);
+    const set = which === "transcript" ? scope.transcripts(node) : scope.attachmentWords(ftsMatch(node), which);
     return always(/[\p{L}\p{N}]/u.test(text) ? bound(`m.id IN (${set.sql})`, ...set.params) : bound("0"));
 };
 const date = (node) => {