@rikaidev/yomi 0.2.6

package/dist/mcp/ui/login-app.js

@@ -0,0 +1,72 @@
+/**
+ * KNOWN CEILING — read before touching anything that depends on this view
+ * actually rendering: this implementation follows the 2026-01-26 MCP Apps
+ * spec (specification/2026-01-26/apps.mdx) and is spec-correct per
+ * ext-apps#615 (renders fine under MCP Inspector). In production, the host
+ * fetches this resource successfully and then NEVER completes the
+ * `ui/initialize` handshake — no iframe is created, no response to this
+ * view's `ui/initialize` request ever arrives. This is an open, unfixed,
+ * upstream host bug, not something fixable from the server side:
+ * anthropics/claude-ai-mcp#165 (stdio transport: resources/read succeeds,
+ * tool calls succeed, `ui/initialize` hangs, no iframe) and #236 (Claude
+ * Cowork with third-party inference renders plain text, no iframe, despite
+ * identical protocol negotiation). Measured on the operator's real machine:
+ * `resources.list` reports `supportsUi=true`, `resources.read` succeeds —
+ * and still nothing renders.
+ *
+ * Consequence for every other file in ./ui and ../handlers-login.ts: THIS
+ * VIEW HAS NEVER BEEN OBSERVED TO RENDER on any deployed client. Nothing in
+ * this codebase may put it on the critical path of any flow — the plain
+ * tool-result text the model sees must always be fully actionable on its
+ * own, with or without this view. Do not remove the view; it costs nothing,
+ * is spec-correct, and will start working the moment the host does.
+ *
+ * MCP Apps UI for the `login` tool — served as the `ui://yomi/login`
+ * resource (see ../server.ts). Self-contained document: no external
+ * requests, no CDN, no fonts. The composed document performs the MCP Apps
+ * lifecycle handshake (`ui/initialize` -> `ui/notifications/initialized`,
+ * see ./login-app-protocol.ts) as soon as it loads, then renders off
+ * `ui/notifications/tool-result` — and it is no longer strictly read-only:
+ * a submitted login form still calls `tools/call login` itself (a
+ * HUMAN-initiated action). It no longer calls `login_complete` on its own —
+ * that is the model's job, always (see ./login-app-view.ts).
+ *
+ * Composed from three sibling modules, split out purely to keep every
+ * individual file under the project's 500-scc-line module cap as this view
+ * grew from a read-only display into a form-driving client:
+ *   - ./login-app-styles.ts   — the `<style>` block.
+ *   - ./login-app-protocol.ts — JSON-RPC transport + lifecycle handshake.
+ *   - ./login-app-view.ts     — stage rendering + tool-call orchestration.
+ *
+ * The PIN is remote data — rendered with `textContent`, never `innerHTML`;
+ * same for any error message. All timing numbers (the 3-minute PIN code
+ * lifetime, the client's poll-ceiling minutes) are read from
+ * `structuredContent` at render time — none are written into this
+ * HTML/JS source, so there is exactly one place (../handlers-login.ts,
+ * sourced from ../../line/auth/pwless/index.ts) that owns each number.
+ */
+import { YOMI_VERSION } from '../../version.js';
+import { buildLoginAppProtocolJs } from './login-app-protocol.js';
+import { LOGIN_APP_CSS } from './login-app-styles.js';
+import { LOGIN_APP_VIEW_JS } from './login-app-view.js';
+export const LOGIN_APP_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>LINE Login</title>
+<style>
+${LOGIN_APP_CSS}
+</style>
+</head>
+<body>
+<main id="app"></main>
+<script>
+(function () {
+  'use strict';
+${buildLoginAppProtocolJs(YOMI_VERSION)}
+${LOGIN_APP_VIEW_JS}
+})();
+</script>
+</body>
+</html>
+`;

package/dist/mcp/ui/login-structured-content.js

@@ -0,0 +1 @@
+export {};

package/dist/mcp/ui/resource.js

@@ -0,0 +1,35 @@
+/**
+ * The single MCP Apps UI resource this server exposes: the login view.
+ * Registered by ../server.ts's `resources/list` and `resources/read`
+ * handlers, gated on client capability (see ./capability.ts) so a client
+ * without MCP Apps support sees an empty resource list, unchanged from
+ * before this feature existed.
+ *
+ * The `csp` key within `_meta.ui` is deliberately omitted: the login view
+ * makes no outbound connections and loads nothing external, so the host's
+ * most restrictive default (no external connections at all) is exactly right.
+ * The `_meta.ui` block itself (containing `prefersBorder`) is present in both
+ * the `resources/list` entry and the `resources/read` contents, matching the
+ * MCP Apps spec.
+ */
+import { MCP_APPS_MIME_TYPE } from './capability.js';
+import { LOGIN_APP_HTML } from './login-app.js';
+/** The `ui://` resource URI for the login view. */
+export const LOGIN_UI_RESOURCE_URI = 'ui://yomi/login';
+/** UI metadata shared by both resources/list and resources/read entries. */
+const LOGIN_UI_META = { ui: { prefersBorder: true } };
+/** `resources/list` entry for the login view. */
+export const LOGIN_UI_RESOURCE_LISTING = {
+    uri: LOGIN_UI_RESOURCE_URI,
+    name: 'login_view',
+    description: 'Interactive LINE login view — shows the PIN or device-approval step with a live countdown.',
+    mimeType: MCP_APPS_MIME_TYPE,
+    _meta: LOGIN_UI_META,
+};
+/** `resources/read` contents entry for the login view. */
+export const LOGIN_UI_RESOURCE_CONTENTS = {
+    uri: LOGIN_UI_RESOURCE_URI,
+    mimeType: MCP_APPS_MIME_TYPE,
+    text: LOGIN_APP_HTML,
+    _meta: LOGIN_UI_META,
+};

package/dist/mcp/ui/tools-with-ui.js

@@ -0,0 +1,40 @@
+/**
+ * Attaches the MCP Apps `_meta.ui` linkage to the `login` tool definition,
+ * but only for clients that negotiated MCP Apps support (see
+ * ./capability.ts) — on a client without it, the tool list served must stay
+ * byte-for-byte what it always was. Kept separate from ../tools.ts (a flat,
+ * static schema registry) because this step is per-connection, not static.
+ */
+import { LOGIN_UI_RESOURCE_URI } from './resource.js';
+/**
+ * Return `tools` as-is for a client without MCP Apps support, or a copy with
+ * the `login` entry augmented with `_meta.ui.resourceUri` for one that has
+ * it. Never mutates the input array/objects. Generic over the caller's
+ * exact tool type (rather than a loosened `Record<string, unknown>`) so the
+ * SDK's stricter `Tool[]` return type still checks at the call site in
+ * ../server.ts.
+ *
+ * @param tools - The static tool list (../tools.ts's TOOLS).
+ * @param supportsMcpApps - Result of ./capability.ts's `supportsMcpApps`.
+ * @returns The tool list to serve for this client.
+ */
+export function toolsForClient(tools, supportsMcpApps) {
+    if (!supportsMcpApps) {
+        return tools;
+    }
+    return tools.map((tool) => {
+        if (tool.name !== 'login') {
+            return tool;
+        }
+        return {
+            ...tool,
+            _meta: {
+                ...(typeof tool._meta === 'object' && tool._meta ? tool._meta : {}),
+                ui: {
+                    resourceUri: LOGIN_UI_RESOURCE_URI,
+                    visibility: ['model', 'app'],
+                },
+            },
+        };
+    });
+}

package/dist/search/bigram.js

@@ -0,0 +1,86 @@
+/**
+ * CJK-aware bigram preprocessing for FTS5 indexing/querying.
+ *
+ * The FTS5 `unicode61` tokenizer has no Chinese/Japanese/Korean word
+ * segmentation: a whole CJK run collapses into a single opaque token, so a
+ * substring like "會議" inside "會議通知" never matches. Yomi has no ICU
+ * tokenizer available and takes on no new dependency to get one, so instead
+ * both the indexed text and the search query are rewritten into overlapping
+ * character bigrams for CJK runs before ever reaching FTS5. Overlapping
+ * bigrams turn "會議通知" into "會議 議通 通知" — searching for "會議"
+ * (itself a single bigram once transformed) becomes a plain token match.
+ * This covers the common case of 2+ character CJK words; single-character
+ * CJK terms still match via the emitted unigram.
+ *
+ * Non-CJK runs (Latin, digits, punctuation) are left untouched and keep
+ * relying on unicode61's normal whitespace/punctuation tokenization.
+ */
+/**
+ * CJK ranges covered: CJK Unified Ideographs + Extension A, CJK
+ * Compatibility Ideographs, Hiragana/Katakana, and Hangul Syllables.
+ */
+const CJK_PATTERN = /[㐀-鿿豈-﫿぀-ヿ가-퟿]/;
+/**
+ * Determine whether a single character falls in a CJK range that needs
+ * bigram splitting rather than unicode61's default tokenization.
+ *
+ * @param ch - A single character to classify.
+ * @returns True when the character is CJK (ideograph, kana, or Hangul).
+ */
+function isCjkChar(ch) {
+    return CJK_PATTERN.test(ch);
+}
+/**
+ * Convert a run of CJK characters into space-separated overlapping
+ * bigrams (or the single character itself, for a length-1 run).
+ *
+ * @param run - A maximal run of CJK characters.
+ * @returns Space-separated bigrams (or the lone character).
+ */
+function bigramsForRun(run) {
+    const chars = Array.from(run);
+    if (chars.length <= 1) {
+        return chars.join('');
+    }
+    const grams = [];
+    for (let i = 0; i < chars.length - 1; i++) {
+        grams.push(chars[i] + chars[i + 1]);
+    }
+    return grams.join(' ');
+}
+/**
+ * Rewrite raw text into its FTS5-searchable form: CJK runs become
+ * space-separated overlapping bigrams, non-CJK runs pass through
+ * unchanged. Apply this identically at index time (to the stored
+ * `search_text`) and at query time (to the user's search string) so the
+ * same substring produces matching tokens on both sides.
+ *
+ * @param raw - Raw display text (message body or user query).
+ * @returns Bigram-preprocessed text suitable for an FTS5 MATCH/index.
+ */
+export function toSearchText(raw) {
+    if (!raw) {
+        return '';
+    }
+    const chars = Array.from(raw);
+    const pieces = [];
+    let runStart = 0;
+    let runIsCjk = chars.length > 0 ? isCjkChar(chars[0]) : false;
+    const flush = (end) => {
+        if (end <= runStart) {
+            return;
+        }
+        const run = chars.slice(runStart, end).join('');
+        pieces.push(runIsCjk ? bigramsForRun(run) : run);
+    };
+    for (let i = 1; i < chars.length; i++) {
+        const cjk = isCjkChar(chars[i]);
+        if (cjk !== runIsCjk) {
+            flush(i);
+            runStart = i;
+            runIsCjk = cjk;
+        }
+    }
+    flush(chars.length);
+    return pieces.join(' ').replace(/\s+/g, ' ').trim();
+}

package/dist/search/capture.js

@@ -0,0 +1,140 @@
+/**
+ * Yomi continuous capture — the in-process, silent, denylist-gated sync loop.
+ *
+ * Unlike collect_messages (explicit, one-shot, caller-invoked), this runs for
+ * the life of the MCP process: LINE's stdio MCP server is spawned once by the
+ * client and lives as long as that client, so a background loop here keeps the
+ * local search index current while the user is actually using the app.
+ *
+ * Two mechanisms:
+ *   - Startup catch-up: one collectMessages() over all conversations, to fill
+ *     the gap for anything that arrived while the process was down. Idempotent
+ *     (upsert), and denylist-gated inside collectMessages.
+ *   - Live loop: LINE's startPolling long-polls SYNC4; on each new message we
+ *     index just the affected chat via collectMessages({ chatIds }).
+ *
+ * This is SILENT: SYNC4 sync never sends a read receipt, so capture never marks
+ * anything read. Excluded (denylisted) chats are dropped inside collectMessages,
+ * so they are never fetched or indexed. Sending/read-receipts are never
+ * triggered here.
+ */
+import { createCliLogger } from '../util/log.js';
+import { collectMessages } from './collector.js';
+import { SqliteUnavailableError } from './sqlite.js';
+import { saveCaptureState } from './store.js';
+const log = createCliLogger('Yomi');
+/** Milliseconds to batch new-message signals before indexing affected chats. */
+const FLUSH_DEBOUNCE_MS = 2000;
+/** Recent messages to (re)index per affected chat on a live flush. */
+const LIVE_PER_CHAT = 30;
+/**
+ * Resolve the chat MID a parsed LINE message belongs to. Group/room messages
+ * are keyed by their `to`; 1:1 (toType 0) messages are keyed by the peer (the
+ * party that is not the authenticated user).
+ *
+ * @param message - Parsed LINE message from the poll loop.
+ * @param myMid - Authenticated user's MID, or null.
+ * @returns Chat MID, or null when it cannot be resolved.
+ */
+function resolveChatId(message, myMid) {
+    if (!message) {
+        return null;
+    }
+    if (message.toType === 0) {
+        return message.from === myMid ? message.to : message.from;
+    }
+    return message.to ?? null;
+}
+/**
+ * Start continuous capture for a resumed LINE session: run a one-time startup
+ * catch-up, then keep the local index current from the live poll loop. Silent
+ * and denylist-gated. Fire-and-forget: safe to call without awaiting.
+ *
+ * @param service - Resumed LineProtocolService (must have a live client).
+ * @param embedder - Embedder used to keep semantic vectors current.
+ * @returns Promise resolving once startup catch-up completes and polling starts.
+ */
+export async function startCapture(service, embedder) {
+    try {
+        const summary = await collectMessages(service, { embedder });
+        log.info('capture.catchup', {
+            chatsScanned: summary.chatsScanned,
+            messagesIndexed: summary.messagesIndexed,
+        });
+    }
+    catch (error) {
+        // A runtime with no SQLite is not a hiccup this loop recovers from — the
+        // index will stay empty for the life of the process and every later flush
+        // fails the same way. Log it once, at error, and stop: a WARN here let a
+        // Node 20 install poll silently for hours while capturing nothing.
+        if (error instanceof SqliteUnavailableError) {
+            log.error('capture.unavailable', {
+                action: 'capture_disabled_for_this_process',
+                error: error.message,
+            });
+            return;
+        }
+        log.warn('capture.catchup_failed', {
+            error: error?.message ?? String(error),
+        });
+    }
+    const pending = new Set();
+    let flushTimer = null;
+    const flush = async () => {
+        flushTimer = null;
+        const chatIds = [...pending];
+        pending.clear();
+        if (chatIds.length === 0) {
+            return;
+        }
+        try {
+            await collectMessages(service, {
+                chatIds,
+                perChat: LIVE_PER_CHAT,
+                embedder,
+            });
+        }
+        catch (error) {
+            log.warn('capture.index_failed', {
+                chats: chatIds.length,
+                error: error?.message ?? String(error),
+            });
+        }
+        persistCursor(service);
+    };
+    service.client.on('message', (message) => {
+        const chatId = resolveChatId(message, service.profile?.mid ?? null);
+        if (chatId) {
+            pending.add(chatId);
+        }
+        if (!flushTimer) {
+            flushTimer = setTimeout(() => {
+                void flush();
+            }, FLUSH_DEBOUNCE_MS);
+        }
+    });
+    log.info('capture.started', {});
+    service.client.startPolling().catch((error) => {
+        log.error('capture.polling_stopped', {
+            error: error?.message ?? String(error),
+        });
+    });
+}
+/**
+ * Persist the current LINE sync cursor for observability and future resume.
+ *
+ * @param service - Resumed LineProtocolService.
+ */
+function persistCursor(service) {
+    try {
+        saveCaptureState({
+            revision: Number(service.client.revision ?? 0),
+            globalRevision: Number(service.client.globalRevision ?? 0),
+            individualRevision: Number(service.client.individualRevision ?? 0),
+            updatedAt: Date.now(),
+        });
+    }
+    catch {
+        // Cursor persistence is best-effort observability; never let it break capture.
+    }
+}

package/dist/search/collector.js

@@ -0,0 +1,176 @@
+/**
+ * Yomi cross-conversation message collector.
+ *
+ * LINE only exposes per-conversation reads; there is no "search all my
+ * chats" primitive server-side. This module is the explicit, caller-
+ * invoked bulk fetch that pulls recent messages from one or more LINE
+ * conversations and upserts them into the local FTS5 search index (see
+ * ./store.ts) so search_messages has something to query.
+ *
+ * This is the ONLY place in Yomi allowed to bulk-fetch across chats, and
+ * only because it is explicit: it runs exactly once per collect_messages
+ * tool call, never on a timer, never in the background. The pure-query MCP
+ * tools (list_conversations, get_chat_messages, ...) never call this and
+ * remain unaffected.
+ *
+ * Reuses the existing read+decrypt path (LineProtocolService.
+ * getRecentMessages, which already runs messages through E2EE decrypt) —
+ * message fetching and decryption are not reimplemented here.
+ *
+ * Also batch-embeds each chat's collected messages (when an Embedder is
+ * supplied) so semantic search has vectors to rank over. The embedder is
+ * always caller-injected — never imported directly here — so the MCP
+ * server can pass its DefaultEmbedder while a host app (e.g. inboxd) can
+ * pass its own local model instead. Embedding failure (model unavailable,
+ * offline first run, etc.) is caught per-chat and never aborts collection:
+ * messages + bigram search_text are always stored regardless of whether
+ * embedding succeeded, so keyword search keeps working either way.
+ */
+import { resolveConversationNames, resolveSenderNames } from '../mcp/names.js';
+import { createCliLogger } from '../util/log.js';
+import { getExcludedChatIds } from './scope.js';
+import { getMessagesMissingEmbedding, upsertEmbeddings, upsertMessages, } from './store.js';
+const log = createCliLogger('Yomi');
+const EMBED_BATCH = 64;
+const DEFAULT_PER_CHAT = 100;
+const DEFAULT_CHAT_LIMIT = 200;
+/**
+ * Resolve the target chat ids for a collection run, along with a
+ * best-effort display name for each.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param chatIds - Caller-supplied chat ids; when omitted, all conversations are used.
+ * @returns Map of chat MID to resolved name (null when unresolvable).
+ */
+async function resolveTargetChats(service, chatIds) {
+    if (chatIds && chatIds.length > 0) {
+        return resolveConversationNames(service, chatIds);
+    }
+    const result = await service.client.getMessageBoxes({
+        lastMessagesPerMessageBoxCount: 1,
+        messageBoxCountLimit: DEFAULT_CHAT_LIMIT,
+        withUnreadCount: false,
+    });
+    const boxes = result.messageBoxes || [];
+    const ids = boxes.map((box) => box.id).filter(Boolean);
+    return resolveConversationNames(service, ids);
+}
+/**
+ * Collect recent messages from one or more LINE conversations and upsert
+ * them into the local search index. Explicit operation — runs only when a
+ * caller invokes the `collect_messages` MCP tool.
+ *
+ * Messages without decrypted/plaintext text (media-only, or E2EE-locked)
+ * are skipped rather than indexed as empty rows — nothing fabricated.
+ * Chats on the exclusion denylist (see ../search/scope.ts) are dropped
+ * before the fetch loop, so they are never fetched from LINE or indexed.
+ *
+ * @param service - Resumed LineProtocolService.
+ * @param options - Collection options.
+ * @returns Summary of chats scanned and messages indexed.
+ */
+export async function collectMessages(service, options = {}) {
+    const perChat = options.perChat ?? DEFAULT_PER_CHAT;
+    const chatNames = await resolveTargetChats(service, options.chatIds);
+    // Scoping is a denylist: excluded chats are removed here, before the
+    // fetch loop below, so they are never fetched from LINE or indexed —
+    // not just filtered out of the results afterward. See ../search/scope.ts.
+    const excluded = getExcludedChatIds();
+    for (const chatId of excluded) {
+        chatNames.delete(chatId);
+    }
+    let messagesIndexed = 0;
+    let messagesEmbedded = 0;
+    for (const [chatId, chatName] of chatNames) {
+        const messages = await service.getRecentMessages(chatId, perChat);
+        const withText = messages.filter((message) => typeof message.text === 'string' && message.text.length > 0);
+        if (withText.length === 0) {
+            continue;
+        }
+        const senderNames = await resolveSenderNames(service, withText.map((message) => message.from).filter(Boolean));
+        const rows = withText.map((message) => ({
+            chatId,
+            chatName: chatName ?? null,
+            messageId: String(message.id),
+            fromMid: message.from ?? null,
+            fromName: senderNames.get(message.from) ?? null,
+            text: message.text,
+            createdTime: message.createdTime ?? message.deliveredTime ?? null,
+        }));
+        messagesIndexed += upsertMessages(rows);
+        messagesEmbedded += await embedAndStore(rows, options.embedder);
+    }
+    // Self-heal embedding coverage: embed anything already in the index that
+    // still lacks a vector for this model — legacy keyword-only rows, or rows
+    // from a run where the model wasn't loaded. This is why re-running
+    // collect_messages repairs a partially-embedded index without re-fetching
+    // from LINE. The rows just embedded above are no longer "missing", so they
+    // are not embedded twice.
+    if (options.embedder) {
+        messagesEmbedded += await backfillMissingEmbeddings(options.embedder);
+    }
+    return { chatsScanned: chatNames.size, messagesIndexed, messagesEmbedded };
+}
+/**
+ * Embed every indexed message that still lacks a vector for the given
+ * model, in batches, from stored text alone (no LINE round-trip). Best-
+ * effort like embedAndStore: if the model fails mid-sweep it stops and
+ * returns what it managed, leaving the rest keyword-only rather than
+ * aborting. Idempotent — a fully-embedded index makes this a no-op.
+ *
+ * @param embedder - Injected embedder to embed missing rows with.
+ * @returns Number of messages newly embedded and stored.
+ */
+export async function backfillMissingEmbeddings(embedder) {
+    const missing = getMessagesMissingEmbedding(embedder.modelLabel);
+    if (missing.length === 0) {
+        return 0;
+    }
+    let embedded = 0;
+    for (let i = 0; i < missing.length; i += EMBED_BATCH) {
+        const batch = missing.slice(i, i + EMBED_BATCH);
+        try {
+            const vectors = await embedder.embed(batch.map((row) => row.text));
+            embedded += upsertEmbeddings(batch.map((row, j) => ({
+                messageId: row.messageId,
+                vector: vectors[j],
+            })), embedder.modelLabel);
+        }
+        catch (error) {
+            log.warn('backfill.failed', {
+                error: error?.message ?? String(error),
+                remaining: missing.length - embedded,
+            });
+            break;
+        }
+    }
+    return embedded;
+}
+/**
+ * Batch-embed a chat's collected messages and store the resulting vectors,
+ * when an Embedder was supplied. Embedding is best-effort: any failure
+ * (model unavailable, offline, OOM, etc.) is caught and logged, never
+ * thrown — messages are already durably stored via upsertMessages by the
+ * time this runs, so a failed embed only means that batch stays
+ * keyword-only, not that collection itself failed.
+ *
+ * @param rows - Messages already upserted this batch.
+ * @param embedder - Injected embedder, or undefined to skip embedding.
+ * @returns Number of messages successfully embedded and stored.
+ */
+async function embedAndStore(rows, embedder) {
+    if (!embedder || rows.length === 0) {
+        return 0;
+    }
+    try {
+        const vectors = await embedder.embed(rows.map((row) => row.text));
+        return upsertEmbeddings(rows.map((row, i) => ({ messageId: row.messageId, vector: vectors[i] })), embedder.modelLabel);
+    }
+    catch (error) {
+        log.warn('embed.failed', {
+            error: error?.message ?? String(error),
+            count: rows.length,
+        });
+        return 0;
+    }
+}

package/dist/search/default-embedder.js

@@ -0,0 +1,101 @@
+/**
+ * Yomi's default semantic-search embedder — a local, offline ONNX model
+ * via transformers.js (@huggingface/transformers), used when no host app
+ * injects its own Embedder (see ./embedder.ts).
+ *
+ * Model: Xenova/bge-small-zh-v1.5 (BAAI general embedding, small, Chinese-
+ * primary but multilingual-capable; 512-dim). Chosen because Yomi's data
+ * is LINE messages, which for this project are predominantly Chinese.
+ *
+ * bun compatibility note: transformers.js picks a Node-flavored backend
+ * under bun (it detects a Node-like `process`), which only accepts device
+ * "cpu" | "coreml" | "webgpu" — "wasm" throws "Unsupported device". "cpu"
+ * routes through onnxruntime-node, and it works under bun WITHOUT running
+ * onnxruntime-node's postinstall script (bun blocks postinstalls by
+ * default; the packaged binary still loads fine here) — verified: model
+ * loads, embeds Chinese text, returns 512-dim unit-normalized vectors.
+ * If bge-small-zh-v1.5 ever fails to load in some environment, fall back to
+ * Xenova/multilingual-e5-small (384-dim, e5 prefix convention: query
+ * embeds get `query: `, document embeds get `passage: `).
+ *
+ * Retrieval convention: bge models are asymmetric — the QUERY gets an
+ * instruction prefix, stored documents do not. Using the model's official
+ * recommended instruction for retrieval tasks.
+ */
+const MODEL_ID = 'Xenova/bge-small-zh-v1.5';
+const BGE_QUERY_INSTRUCTION = '为这个句子生成表示以用于检索相关文章：';
+let pipelinePromise = null;
+/**
+ * Lazily load (and memoize) the transformers.js feature-extraction
+ * pipeline for MODEL_ID. First call downloads/caches the ONNX model;
+ * subsequent calls reuse the same pipeline instance.
+ *
+ * @returns Promise resolving to the feature-extraction pipeline.
+ */
+function getPipeline() {
+    if (!pipelinePromise) {
+        pipelinePromise = import('@huggingface/transformers')
+            .then(({ pipeline }) => pipeline('feature-extraction', MODEL_ID, {
+            device: 'cpu',
+        }))
+            .catch((error) => {
+            // Reset the memo on failure so a later call can retry (e.g. the
+            // first attempt failed offline, network comes back later) instead
+            // of permanently caching a rejected promise.
+            pipelinePromise = null;
+            throw error;
+        });
+    }
+    return pipelinePromise;
+}
+/**
+ * Split a pipeline output tensor (flat data + dims [batch, hidden]) into
+ * one number[] vector per input row.
+ *
+ * @param output - Raw pipeline output.
+ * @returns One vector array per row.
+ */
+function splitRows(output) {
+    const [rows, hidden] = output.dims;
+    const data = output.data;
+    const vectors = [];
+    for (let i = 0; i < rows; i++) {
+        vectors.push(Array.from(data.slice(i * hidden, (i + 1) * hidden)));
+    }
+    return vectors;
+}
+/**
+ * Default Yomi embedder backed by transformers.js/ONNX, running fully
+ * local and offline after the first model download. Model load happens on
+ * first embed() or embedQuery() call, not at construction, so importing
+ * this module never triggers a download by itself.
+ */
+export class DefaultEmbedder {
+    modelLabel = MODEL_ID;
+    async embed(texts) {
+        if (texts.length === 0) {
+            return [];
+        }
+        const extractor = await getPipeline();
+        const output = await extractor(texts, { pooling: 'mean', normalize: true });
+        return splitRows(output);
+    }
+    async embedQuery(query) {
+        const [vector] = await this.embed([`${BGE_QUERY_INSTRUCTION}${query}`]);
+        return vector;
+    }
+}
+let defaultEmbedder = null;
+/**
+ * Get the process-wide singleton DefaultEmbedder instance. Constructing it
+ * is cheap (no model load); the underlying pipeline only loads lazily on
+ * first use.
+ *
+ * @returns Shared DefaultEmbedder instance.
+ */
+export function getDefaultEmbedder() {
+    if (!defaultEmbedder) {
+        defaultEmbedder = new DefaultEmbedder();
+    }
+    return defaultEmbedder;
+}

package/dist/search/embedder.js

@@ -0,0 +1,13 @@
+/**
+ * Semantic-search embedder seam for Yomi's search index.
+ *
+ * This interface is the injection point between the local search index
+ * (store.ts, collector.ts) and whatever produces dense vectors. Yomi ships
+ * a default implementation (./default-embedder.ts, transformers.js/ONNX) so
+ * the MCP server works standalone, but nothing in store.ts/collector.ts
+ * imports that default directly — they only depend on this interface, so a
+ * host app (e.g. inboxd) can inject its own embedder (its local MLX
+ * `generateEmbedding`) instead. See ./default-embedder.ts's doc comment for
+ * the exact adapter shape.
+ */
+export {};