@wirecat/cli-core 0.395.0 → 0.397.0

package/dist/store/sqlite/lucene.js

@@ -2,11 +2,12 @@ import { CliError } from "@wirecat/cli-base";
 import { compileAutomaton } from "../../search/lucene/automaton.js";
 import { isStemmed } from "../../search/lucene/resolved.js";
 import { exhausted, QUERY_LIMITS, searchError } from "../../search/lucene/types.js";
-import { normalize } from "../normalize.js";
 import { emailHitsByPk } from "./emails.js";
+import { placeHits } from "./hit-places.js";
 import { combine, FIELD_COMPILERS, ftsMatch, SPEECH, } from "./lucene-fields.js";
 import { hitsByPk } from "./search.js";
 import { read } from "./transaction.js";
+import { transcriptItems, transcriptTerms } from "./transcript-query.js";
 export { prefixOf } from "./lucene-fields.js";
 const MESSAGES = {
     rows: "messages",
@@ -82,13 +83,19 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
         sql: `SELECT att.attachable_id FROM attachments att WHERE att.attachable_type='${corpus.item}'${which === "any" ? "" : ` AND ${which === "file" ? "NOT " : ""}${SPEECH}`} AND att.id IN (SELECT rowid FROM attachment_words WHERE attachment_words MATCH ?)`,
         params: [match],
     });
+    const transcripts = transcriptTerms(database, execution.root, corpus.item);
+    const said = (node, part) => transcriptItems(corpus.item, transcripts.get(node) ?? { match: ftsMatch(node), widened: [], from: node.value }, part);
     /** A bare word also matches a transcript, a file's text and a word of a file's name. */
     const everywhere = (node, fragment) => {
         if (!node.implicit || fragment.sql === "0")
             return fragment;
         const match = ftsMatch(node);
-        const files = attachmentWords(match, "any");
-        const elsewhere = { sql: `${files.sql} UNION ${namedSql}`, params: [...files.params, match] };
+        const files = attachmentWords(match, "file");
+        const spoken = said(node);
+        const elsewhere = {
+            sql: `${files.sql} UNION ${spoken.sql} UNION ${namedSql}`,
+            params: [...files.params, ...spoken.params, match],
+        };
         return {
             ...fragment,
             sql: `(${fragment.sql} OR m.id IN (${elsewhere.sql}))`,
@@ -107,6 +114,7 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
         patternOf,
         expanded,
         attachmentWords,
+        transcripts: (node) => said(node),
         everywhere,
         expand: (count) => {
             expansions += count;
@@ -284,14 +292,21 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
         ranked.sql.push(`f(id, rank) AS MATERIALIZED (SELECT rowid, bm25(${rankIndex.table}, 1.0, 0.0) FROM ${rankIndex.table} WHERE ${rankIndex.table} MATCH ?)`);
         ranked.params.push(`${rankIndex.column} : (${ranking})`);
     }
-    // Among hits the message text does not hold: a transcript, then a file's name, then a file's text. bm25 scores
-    // of different indexes do not compare, and a long spreadsheet must not crowd out what was said.
-    const places = [...fragments.values()].flatMap(({ node, fragment }) => fragment.elsewhere && fragment.fts ? [ftsMatch(node)] : []);
+    // Among hits the message text does not hold: a transcript as typed, in another form, then a file's name, a file's
+    // text, and last a garbled spelling. bm25 scores of different indexes do not compare, and a long spreadsheet must
+    // not crowd out what was said.
+    const placeNodes = [...fragments.values()].flatMap(({ node, fragment }) => fragment.elsewhere && fragment.fts ? [node] : []);
+    const places = placeNodes.map(ftsMatch);
     if (places.length && !execution.newest) {
-        ranked.sql.push(`s(id, tier) AS MATERIALIZED (SELECT att.attachable_id, min(CASE WHEN ${SPEECH} THEN 1 ELSE 3 END) FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.id IN (SELECT rowid FROM attachment_words WHERE attachment_words MATCH ?) GROUP BY att.attachable_id UNION ALL SELECT attachable_id, 2 FROM (${namedSql}))`);
-        ranked.params.push(places.join(" OR "), places.join(" OR "));
+        const spoken = (part, tier) => placeNodes.map((node) => {
+            const one = said(node, part);
+            return { sql: `SELECT attachable_id, ${tier} FROM (${one.sql})`, params: one.params };
+        });
+        const parts = [...spoken("forms", 2), ...spoken("widened", 5)];
+        ranked.sql.push(`s(id, tier) AS MATERIALIZED (SELECT att.attachable_id, min(CASE WHEN ${SPEECH} THEN 1 ELSE 4 END) FROM attachments att WHERE att.attachable_type='${corpus.item}' AND att.id IN (SELECT rowid FROM attachment_words WHERE attachment_words MATCH ?) GROUP BY att.attachable_id UNION ALL SELECT attachable_id, 3 FROM (${namedSql})${parts.map(({ sql }) => ` UNION ALL ${sql}`).join("")})`);
+        ranked.params.push(places.join(" OR "), places.join(" OR "), ...parts.flatMap(({ params }) => params));
     }
-    const placeTier = places.length && !execution.newest ? "coalesce((SELECT min(tier) FROM s WHERE s.id=m.id), 4)," : "";
+    const placeTier = places.length && !execution.newest ? "coalesce((SELECT min(tier) FROM s WHERE s.id=m.id), 6)," : "";
     if (exactTier) {
         ranked.sql.push(`x(id) AS MATERIALIZED (SELECT rowid FROM ${corpus.words} WHERE ${corpus.words} MATCH ?)`);
         ranked.params.push(`normalized_text : (${exactTier})`);
@@ -336,67 +351,7 @@ const compileQuery = (context, execution, boundedAttachments = false) => {
             count: Number(row.count),
         }));
     };
-    const placeLeaves = [...fragments.values()].filter(({ node }) => (node.operator === "term" || node.operator === "phrase") &&
-        (node.implicit || node.field === "content" || node.field === "transcript"));
-    /** Which place of each hit holds the words, first match wins in the order of `MatchPlace`. */
-    const placed = (found, pks) => {
-        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 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 = files.find((row) => Number(row.id) === pk && Number(row.speech) === 1);
-            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;
-            return place ? { ...hit, matchedIn: place[0], matchedText: place[1] } : hit;
-        });
-    };
+    const placed = (found, pks) => placeHits(database, corpus, [...fragments.values()], transcripts, found, pks);
     const hits = (pks) => placed(mail ? emailHitsByPk(database, pks) : hitsByPk(context, pks), pks);
     return {
         corpus,

package/dist/store/sqlite/manifest.js

@@ -34,6 +34,8 @@ export const MANIFEST = [
     { name: "20261021214318_version-26-message-reactions", version: 26, minCompatible: 1 },
     { name: "20261021221808_version-27-message-delivery", version: 27, minCompatible: 1 },
     { name: "20261021224625_version-28-chat-state", version: 28, minCompatible: 1 },
+    { name: "20261023105057_version-29-transcript-words", version: 29, minCompatible: 1 },
+    { name: "20261023105101_version-29-transcript-words-triggers", version: 29, minCompatible: 1 },
 ];
 export const generatedMigrations = (manifest = MANIFEST, generated = GENERATED) => {
     const migrations = [];

package/dist/store/sqlite/migrations.generated.js

@@ -577,5 +577,24 @@ export const GENERATED = [
             "ALTER TABLE `chats` ADD `marked_unread` integer;",
             "ALTER TABLE `chats` ADD `unread_counted_at` integer;"
         ]
+    },
+    {
+        "name": "20261023105057_version-29-transcript-words",
+        "statements": [
+            "CREATE TABLE `transcript_index_pending` (\n\t`id` integer NOT NULL,\n\t`indexable_type` text NOT NULL,\n\tCONSTRAINT `transcript_index_pending_pk` PRIMARY KEY(`indexable_type`, `id`)\n);"
+        ]
+    },
+    {
+        "name": "20261023105101_version-29-transcript-words-triggers",
+        "statements": [
+            "-- Words and stems of a voice note's transcript, rowid = attachment id. The words are the vocabulary garbled\n-- spellings are read from; the typed form is still found in attachment_words. Stemming needs JS, so the\n-- triggers only queue the attachment and the next search indexes it, as tasks do.\nCREATE VIRTUAL TABLE transcript_words USING fts5(\n  normalized_text, scope,\n  content = '', contentless_delete = 1,\n  tokenize = 'unicode61 remove_diacritics 2', prefix = '3');",
+            "CREATE VIRTUAL TABLE transcript_words_vocab USING fts5vocab(transcript_words, 'col');",
+            "CREATE VIRTUAL TABLE transcript_stems USING fts5(\n  stems, scope,\n  content = '', contentless_delete = 1,\n  tokenize = 'unicode61 remove_diacritics 2');",
+            "-- A transcript is the text of a message's voice attachment, whoever wrote it, as `speech()` in lucene-fields.ts.\nCREATE TRIGGER transcript_index_ai AFTER INSERT ON attachments\n  WHEN new.attachable_type = 'message' AND (coalesce(new.extractor, '') LIKE 'speech:%'\n    OR new.kind IN ('voice', 'video_note') OR coalesce(new.mime, '') = 'audio/ogg') BEGIN\n  INSERT OR IGNORE INTO transcript_index_pending (indexable_type, id) VALUES ('attachment', new.id);\nEND;",
+            "-- Queued whether it became a transcript or stopped being one: the drain drops what is no longer live.\nCREATE TRIGGER transcript_index_au AFTER UPDATE OF text, kind, mime, extractor, attachable_type ON attachments\n  WHEN (old.text IS NOT new.text OR old.kind IS NOT new.kind OR old.mime IS NOT new.mime\n    OR old.extractor IS NOT new.extractor OR old.attachable_type IS NOT new.attachable_type)\n    AND ((new.attachable_type = 'message' AND (coalesce(new.extractor, '') LIKE 'speech:%'\n      OR new.kind IN ('voice', 'video_note') OR coalesce(new.mime, '') = 'audio/ogg'))\n    OR (old.attachable_type = 'message' AND (coalesce(old.extractor, '') LIKE 'speech:%'\n      OR old.kind IN ('voice', 'video_note') OR coalesce(old.mime, '') = 'audio/ogg'))) BEGIN\n  INSERT OR IGNORE INTO transcript_index_pending (indexable_type, id) VALUES ('attachment', new.id);\nEND;",
+            "CREATE TRIGGER transcript_index_ad AFTER DELETE ON attachments BEGIN\n  DELETE FROM transcript_words WHERE rowid = old.id;\n  DELETE FROM transcript_stems WHERE rowid = old.id;\n  DELETE FROM transcript_index_pending WHERE indexable_type = 'attachment' AND id = old.id;\nEND;",
+            "INSERT OR IGNORE INTO search_index_state (name, watermark, filled_through, terms_through, normalizer_version, built_at, analyzer)\n  VALUES ('transcript_index', 0, 0, 0, 1, NULL, NULL);",
+            "INSERT OR IGNORE INTO transcript_index_pending (indexable_type, id)\n  SELECT 'attachment', id FROM attachments WHERE attachable_type = 'message' AND coalesce(text, '') <> ''\n    AND (coalesce(extractor, '') LIKE 'speech:%' OR kind IN ('voice', 'video_note') OR coalesce(mime, '') = 'audio/ogg');"
+        ]
     }
 ];

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

@@ -15,12 +15,14 @@ export interface NoteIndexState {
  */
 export interface Corpus {
     /** The singular table name: `indexable_type` in the queue, `chunkable_type` in chunks. */
-    type: "document" | "note" | "memory" | "email" | "task";
+    type: "document" | "note" | "memory" | "email" | "task" | "transcript";
     /** Its row in `search_index_state`. */
     index: string;
     table: string;
     /** Title and body as `title`/`body`, whether it is live, and its scope, for one row by `id`. */
     read: string;
+    /** `indexable_type` in the queue when it is not `type`: the table a queued id points into. */
+    queued?: "attachment";
     /** False when the corpus cuts its own pieces for search by meaning, as mail does by thread. */
     pieces?: false;
     /** The words and stems rows, when the corpus cleans its text its own way; `normalize` and `indexText` otherwise. */
@@ -66,6 +68,14 @@ export declare const CORPORA: {
             stems: string;
         };
     };
+    readonly transcript: {
+        readonly type: "transcript";
+        readonly queued: "attachment";
+        readonly index: "transcript_index";
+        readonly table: `(SELECT a.id FROM attachments a WHERE a.attachable_type = 'message' AND ${string})`;
+        readonly read: string;
+        readonly pieces: false;
+    };
 };
 /** What a row is indexed as: its title, then its text. Chunk offsets point into this. */
 export declare const noteIndexText: (title: string | null, text: string) => string;

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

@@ -5,6 +5,7 @@ import { normalize } from "../normalize.js";
 import { dropDocumentPicture } from "./document-pictures.js";
 import { int } from "./events.js";
 import { indexRow } from "./index-state.js";
+import { speech } from "./lucene-fields.js";
 import { savedStemmers } from "./stems.js";
 import { write } from "./transaction.js";
 export const CORPORA = {
@@ -45,13 +46,24 @@ export const CORPORA = {
         pieces: false,
         terms: (text, stemmer) => ({ words: taskWordsOf(text), stems: [...taskStemsOf(text, stemmer)].join(" ") }),
     },
+    transcript: {
+        type: "transcript",
+        queued: "attachment",
+        index: "transcript_index",
+        table: `(SELECT a.id FROM attachments a WHERE a.attachable_type = 'message' AND ${speech("a")})`,
+        read: `SELECT NULL AS title, coalesce(a.text, '') AS body, a.attachable_type = 'message' AND ${speech("a")} AS live, ` +
+            "'personal' AS scope FROM attachments a WHERE a.id = ?",
+        pieces: false,
+    },
 };
 /** What a row is indexed as: its title, then its text. Chunk offsets point into this. */
 export const noteIndexText = (title, text) => (title ? `${title}\n\n${text}` : text);
+const queuedAs = (corpus) => corpus.queued ?? corpus.type;
 export const corpusIndexState = (database, corpus) => {
     const row = indexRow(database, corpus.index);
-    const pending = Number(database.prepare(`SELECT count(*) AS n FROM ${corpus.type}_index_pending WHERE indexable_type = ?`).get(corpus.type)
-        ?.n);
+    const pending = Number(database
+        .prepare(`SELECT count(*) AS n FROM ${corpus.type}_index_pending WHERE indexable_type = ?`)
+        .get(queuedAs(corpus))?.n);
     const saved = savedStemmers(database);
     const wanted = saved === null ? null : analyzerIdentity(saved ?? DEFAULT_STEMMERS);
     const built = row.analyzer === null ? null : String(row.analyzer);
@@ -126,7 +138,7 @@ const writer = (database, corpus, stemmer) => {
                 statements.purge.run(hash, hash);
         if (!live && corpus.type === "document")
             dropDocumentPicture(database, id);
-        statements.dequeue.run(corpus.type, id);
+        statements.dequeue.run(queuedAs(corpus), id);
     };
 };
 /**
@@ -154,7 +166,7 @@ export const drainCorpus = (database, corpus, stemmerFor, { batch = 200, until =
             if (state.built !== null)
                 database
                     .prepare(`INSERT OR IGNORE INTO ${queue} (indexable_type, id) SELECT ?, id FROM ${corpus.table}`)
-                    .run(corpus.type);
+                    .run(queuedAs(corpus));
             database.prepare("UPDATE search_index_state SET analyzer = ? WHERE name = ?").run(stemmer.identity, corpus.index);
         });
     }
@@ -167,7 +179,7 @@ export const drainCorpus = (database, corpus, stemmerFor, { batch = 200, until =
         if (until())
             break;
         const count = write(database, () => {
-            const ids = next.all(corpus.type, batch).map((row) => Number(row.id));
+            const ids = next.all(queuedAs(corpus), batch).map((row) => Number(row.id));
             for (const id of ids)
                 index(id);
             return ids.length;
@@ -187,7 +199,7 @@ export const resetNoteIndex = (database) => {
         for (const corpus of Object.values(CORPORA))
             database
                 .prepare(`INSERT OR IGNORE INTO ${corpus.type}_index_pending (indexable_type, id) SELECT ?, id FROM ${corpus.table}`)
-                .run(corpus.type);
+                .run(queuedAs(corpus));
     });
     return true;
 };

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

@@ -6497,6 +6497,45 @@ export declare const attachments: import("drizzle-orm/sqlite-core").SQLiteTableW
     };
     dialect: 'sqlite';
 }>;
+export declare const transcriptIndexPending: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "transcript_index_pending";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "transcript_index_pending";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        indexableType: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: string;
+            tableName: "transcript_index_pending";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: 'sqlite';
+}>;
 export { documentAnnotationTransfers } from "./schema/document-transfers.js";
 export declare const documents: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
     name: "documents";

package/dist/store/sqlite/schema.js

@@ -715,6 +715,10 @@ export const attachments = sqliteTable("attachments", {
         .on(table.id)
         .where(sql `local_path IS NOT NULL AND local_path_folded IS NULL`),
 ]);
+export const transcriptIndexPending = sqliteTable("transcript_index_pending", {
+    id: integer("id").notNull(),
+    indexableType: text("indexable_type").notNull(),
+}, (table) => [primaryKey({ columns: [table.indexableType, table.id] })]);
 export { documentAnnotationTransfers } from "./schema/document-transfers.js";
 export const documents = sqliteTable("documents", {
     id: integer("id").primaryKey(),

package/dist/store/sqlite/transcript-query.d.ts

@@ -0,0 +1,40 @@
+import type { ResolvedNode, ResolvedPredicate } from "../../search/lucene/resolved.js";
+import type { CacheDatabase, SqlValue } from "../driver.js";
+/** How one leaf reaches voice-note transcripts: its typed form, other forms by stem, and garbled spellings. */
+export interface TranscriptTerms {
+    /** The leaf's words as typed, matched in `attachment_words`. */
+    match: string;
+    /** Any form of them, matched in `transcript_stems`; none under `exact:`. */
+    stems?: string;
+    /** Stored spellings speech recognition may have made of a single word; matched in `attachment_words`. */
+    widened: string[];
+    from: string;
+}
+/**
+ * Each leaf that reads transcripts, with what it matches there. A transcript always widens, not only when nothing
+ * matched as typed text does: a correct and a garbled spelling sit in one chat. Only a single word widens —
+ * FTS5 `NEAR` and phrases take no alternatives — and never under `exact:`, as meetings do.
+ */
+export declare const transcriptTerms: (database: CacheDatabase, root: ResolvedNode, item: string) => Map<ResolvedPredicate, TranscriptTerms>;
+export type TranscriptPart = "all" | "typed" | "forms" | "widened";
+/** The attachment ids a leaf's transcripts match, as a condition on `att.id`; `part` keeps one of them. */
+export declare const transcriptCondition: (terms: TranscriptTerms, part?: TranscriptPart) => {
+    sql: string;
+    params: SqlValue[];
+};
+/** The items whose transcripts a leaf matches. */
+export declare const transcriptItems: (item: string, terms: TranscriptTerms, part?: TranscriptPart) => {
+    sql: string;
+    params: SqlValue[];
+};
+/**
+ * Of the items `keys` names, the transcript the leaves match — one they match as typed or in another form first —
+ * and, when only a spelling recognition garbled matched it, which: as meetings say it.
+ */
+export declare const spokenTranscripts: (database: CacheDatabase, item: string, speaking: TranscriptTerms[], keys: string) => Map<number, {
+    text: string;
+    corrections: {
+        from: string;
+        to: string[];
+    }[];
+}>;

package/dist/store/sqlite/transcript-query.js

@@ -0,0 +1,108 @@
+import { isNumberWord, widenWords } from "../../search/garbled.js";
+import { knownRussianWord } from "../../search/russian-dictionary.js";
+import { createStemmer, DEFAULT_STEMMERS, STEM_SEPARATOR } from "../../search/stem.js";
+import { normalize } from "../normalize.js";
+import { ftsMatch, quoted, SPEECH, stemMatch } from "./lucene-fields.js";
+import { savedStemmers } from "./stems.js";
+const predicates = (node) => node.kind === "predicate" ? [node] : node.clauses.flatMap(({ node }) => predicates(node));
+/** A bare word and `transcript:` read transcripts; `text:` is only what was written. */
+const readsTranscripts = (node) => (node.operator === "term" || node.operator === "phrase") &&
+    /[\p{L}\p{N}]/u.test(normalize(node.value)) &&
+    (node.field === "transcript" || (node.implicit === true && (node.field === "text" || node.field === "exact")));
+/**
+ * Each leaf that reads transcripts, with what it matches there. A transcript always widens, not only when nothing
+ * matched as typed text does: a correct and a garbled spelling sit in one chat. Only a single word widens —
+ * FTS5 `NEAR` and phrases take no alternatives — and never under `exact:`, as meetings do.
+ */
+export const transcriptTerms = (database, root, item) => {
+    const leaves = predicates(root).filter(readsTranscripts);
+    const terms = new Map(leaves.map((node) => [node, { match: ftsMatch(node), widened: [], from: node.value }]));
+    const saved = savedStemmers(database);
+    if (item !== "message" || !leaves.length || saved === null)
+        return terms;
+    const stemmer = createStemmer(saved ?? DEFAULT_STEMMERS);
+    const stemsOf = (word) => [...new Set(stemmer.explain(word).map((part) => part.stem))];
+    const widening = [];
+    for (const [node, one] of terms) {
+        if (node.field === "exact")
+            continue;
+        const stems = stemMatch(stemmer, node);
+        // `NEAR` over the stems can bridge the separator between a text's Latin readings; those rows are left out.
+        if (stems)
+            Object.assign(one, { stems: node.slop === undefined ? stems : `(${stems}) NOT ${quoted(STEM_SEPARATOR)}` });
+        const words = normalize(node.value).match(/[\p{L}\p{N}]+/gu) ?? [];
+        if (node.operator === "term" && words.length === 1 && !isNumberWord(words[0]))
+            widening.push({ node, literal: words[0], stems: stemsOf(node.value) });
+    }
+    if (!widening.length)
+        return terms;
+    const vocabulary = database
+        .prepare("SELECT term, doc FROM transcript_words_vocab WHERE col = 'normalized_text'")
+        .all()
+        .map((row) => ({ term: String(row.term), docs: Number(row.doc) }));
+    widenWords(widening, vocabulary, stemsOf, knownRussianWord).forEach((words, at) => {
+        const leaf = widening[at];
+        if (leaf)
+            Object.assign(terms.get(leaf.node), { widened: words });
+    });
+    return terms;
+};
+/** The attachment ids a leaf's transcripts match, as a condition on `att.id`; `part` keeps one of them. */
+export const transcriptCondition = (terms, part = "all") => {
+    const parts = [];
+    const words = (match) => ({
+        sql: "att.id IN (SELECT rowid FROM attachment_words WHERE attachment_words MATCH ?)",
+        params: [match],
+    });
+    if (part === "all" || part === "typed")
+        parts.push(words(terms.match));
+    if ((part === "all" || part === "forms") && terms.stems)
+        parts.push({
+            sql: "att.id IN (SELECT rowid FROM transcript_stems WHERE transcript_stems MATCH ?)",
+            params: [`stems : (${terms.stems})`],
+        });
+    if ((part === "all" || part === "widened") && terms.widened.length)
+        parts.push(words(terms.widened.map(quoted).join(" OR ")));
+    return parts.length
+        ? { sql: `(${parts.map(({ sql }) => sql).join(" OR ")})`, params: parts.flatMap(({ params }) => params) }
+        : { sql: "0", params: [] };
+};
+/** The items whose transcripts a leaf matches. */
+export const transcriptItems = (item, terms, part) => {
+    const condition = transcriptCondition(terms, part);
+    return {
+        sql: `SELECT att.attachable_id FROM attachments att WHERE att.attachable_type='${item}' AND ${SPEECH} AND ${condition.sql}`,
+        params: condition.params,
+    };
+};
+/**
+ * Of the items `keys` names, the transcript the leaves match — one they match as typed or in another form first —
+ * and, when only a spelling recognition garbled matched it, which: as meetings say it.
+ */
+export const spokenTranscripts = (database, item, speaking, keys) => {
+    const any = speaking.map((terms) => transcriptCondition(terms));
+    if (!any.length)
+        return new Map();
+    const plain = speaking
+        .flatMap((terms) => [transcriptCondition(terms, "typed"), transcriptCondition(terms, "forms")])
+        .filter(({ sql }) => sql !== "0");
+    const rows = database
+        .prepare(`SELECT att.attachable_id AS id, att.text AS text, ${plain.length ? plain.map(({ sql }) => sql).join(" OR ") : "0"} AS plain FROM attachments att WHERE att.attachable_type='${item}' AND ${SPEECH} AND att.attachable_id IN (SELECT value FROM json_each(?)) AND (${any.map(({ sql }) => sql).join(" OR ")}) ORDER BY plain DESC, att.position`)
+        .all(...plain.flatMap(({ params }) => params), keys, ...any.flatMap(({ params }) => params));
+    const found = new Map();
+    for (const row of rows) {
+        const id = Number(row.id);
+        if (found.has(id))
+            continue;
+        const text = String(row.text);
+        const tokens = new Set(normalize(text).match(/[\p{L}\p{N}]+/gu) ?? []);
+        const corrections = Number(row.plain) === 1
+            ? []
+            : speaking.flatMap(({ from, widened }) => {
+                const to = widened.filter((word) => tokens.has(word));
+                return to.length ? [{ from, to }] : [];
+            });
+        found.set(id, { text, corrections });
+    }
+    return found;
+};

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

@@ -9,6 +9,12 @@ export type ScoredHit = StoredHit & {
     matchedIn?: MatchPlace;
     /** The text of that place, for the excerpt; never part of an answer. */
     matchedText?: string;
+    /** `corrected`: found only through a spelling speech recognition garbled, in a voice note's transcript. */
+    match?: "words" | "beginnings" | "corrected";
+    corrections?: {
+        from: string;
+        to: string[];
+    }[];
 };
 export type MatchPlace = "text" | "transcript" | "filename" | "file";
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wirecat/cli-core",
-  "version": "0.395.0",
+  "version": "0.397.0",
   "description": "The messenger-neutral half of a messaging CLI: domain model, message locators, rendering, name resolution, the SQLite seam, the command skeleton and shared read commands, the send guard, run records and the message store",
   "license": "Apache-2.0",
   "author": "Viacheslav Ptsarev",
@@ -207,7 +207,7 @@
     "@types/node": "^22.20.4",
     "@types/pngjs": "6.0.5",
     "@vitest/coverage-v8": "^5.0.2",
-    "@wirecat/cli-base": "0.50.0",
+    "@wirecat/cli-base": "0.50.1",
     "commander": "15.0.0",
     "cspell": "10.3.6",
     "drizzle-kit": "1.0.0-rc.4",
@@ -227,7 +227,7 @@
   },
   "peerDependencies": {
     "@napi-rs/canvas": ">=0.1.69 <2",
-    "@wirecat/cli-base": ">=0.49.0 <0.51.0",
+    "@wirecat/cli-base": ">=0.50.1 <0.51.0",
     "commander": ">=15"
   },
   "bin": {

package/parity.json

@@ -121,6 +121,10 @@
       "value": "<n>",
       "meaning": "how many messages before it"
     },
+    "--before-time": {
+      "value": "<time>",
+      "meaning": "read what came before this time"
+    },
     "--block": {
       "value": "<value>",
       "meaning": "Set to `true` if user should be blocked in chat."
@@ -1287,12 +1291,26 @@
         "--description": "all",
         "--first-name": "all",
         "--last-name": "all",
-        "--photo": "all"
+        "--photo": {
+          "in": "all",
+          "wording": "WhatsApp accepts JPEG (.jpg or .jpeg) profile photos; help names each messenger's accepted image formats (WC-CMD-25)."
+        }
       }
     },
     "attachments": {
       "in": "all"
     },
+    "attachments check": {
+      "in": "all"
+    },
+    "attachments download": {
+      "in": "all",
+      "options": {
+        "--chat": "all",
+        "--pause": "all",
+        "--since-time": "all"
+      }
+    },
     "attachments extract": {
       "in": "all",
       "options": {
@@ -1318,6 +1336,30 @@
         }
       }
     },
+    "attachments jobs": {
+      "in": "all"
+    },
+    "attachments jobs install": {
+      "in": "all",
+      "options": {
+        "--at": "all",
+        "--chat": "all",
+        "--since-time": "all",
+        "--timezone": "all"
+      }
+    },
+    "attachments jobs start": {
+      "in": "all"
+    },
+    "attachments jobs status": {
+      "in": "all"
+    },
+    "attachments jobs stop": {
+      "in": "all"
+    },
+    "attachments jobs uninstall": {
+      "in": "all"
+    },
     "attachments list": {
       "in": "all",
       "options": {
@@ -1332,6 +1374,13 @@
         }
       }
     },
+    "attachments move": {
+      "in": "all",
+      "options": {
+        "--before-time": "all",
+        "--dry-run": "all"
+      }
+    },
     "attachments show": {
       "in": "all",
       "options": {