@rikaidev/yomi 0.2.6 → 0.3.1

package/README.md

@@ -6,22 +6,32 @@
   </picture>
 </p>
 
-# Yomi (読み)
+# Yomi (読み) — the personal LINE MCP server
 
-**Read your LINE from an AI agent — and reply, send images, and search across every conversation — without a browser and without LINE's own client.**
+**Yomi is an open-source LINE MCP server for your personal account. Read, reply,
+send images, and search every conversation from Claude or any local AI agent —
+without a browser, bot account, or LINE's own client.**
 
 *The name reads more than one way. **読み** (yomi) — a reading: not just parsing
 your messages, but reading the situation, the way you do. **詠み** (yomi) — to
-recite: it doesn't read in silence, it reads things back to you. And **黄泉** (yomi)
-— the realm of what's buried and out of reach; the very yomi in **黄泉帰り**
-(yomigaeri), "the return from it," the root of the Japanese word for revival. Yomi
-reaches into what is sealed or forgotten and brings it back to light.*
+recite: it doesn't read in silence, it reads things back to you. And **黄泉**
+(yomi) — the unreachable realm; the very yomi in **黄泉帰り** (*yomigaeri*),
+"returning from Yomi." Like a messenger moving between two realms, Yomi passes
+through sealing and silence to bring messages still readable deep inside your
+conversations back into the light. It does not summon history already lost; it
+helps what has not disappeared be seen again.*
+
+Unlike LINE's official Bot MCP server, which connects AI agents to a LINE
+Official Account through the Messaging API, Yomi connects to your existing
+personal LINE account and conversations as a secondary device.
 
 Yomi speaks LINE's TCompact-over-HTTPS protocol directly, decrypts Letter-Sealing
 (E2EE) messages and media, and exposes the result to any AI agent through a small
 stdio [MCP](https://modelcontextprotocol.io) server. Point Claude Desktop (or any
 MCP client) at it and the agent can catch up on your LINE the way you do — read,
-reply, send an image, mention someone, and search your whole history locally.
+reply, send an image, mention someone, and search your whole history locally — and,
+with `get_insight`, read the *situation*: which conversations are waiting on your
+reply, who ties your world together, and what has gone overdue.
 
 No official API, no bot account, no webhook. Yomi logs in as a secondary device
 on your own account.
@@ -403,9 +413,13 @@ Approve the device on your phone (see [Logging in](#logging-in)), and:
 
 ## What you can do
 
-Yomi exposes **19 tools** over MCP. All return JSON. "Honest error" below means an
-explicit failure naming the problem (e.g. `missing_decrypt_material`) — Yomi never
-fabricates a fallback, a placeholder, or a fake success.
+Yomi exposes **20 tools** over MCP (the ones worth naming; see the tables). Large
+read results use token-efficient [TOON](https://github.com/toon-format/toon);
+small status and write results use compact JSON. Errors remain plain text and media
+uses native MCP image/audio/resource content.
+"Honest error" below means an explicit failure naming the problem (e.g.
+`missing_decrypt_material`) — Yomi never fabricates a fallback, a placeholder, or a
+fake success.
 
 ### Reading
 
@@ -418,6 +432,12 @@ fabricates a fallback, a placeholder, or a fake success.
 | `find_contact` / `list_contacts` | Friend-list lookup by name substring, or the full list. Raw LINE data — no fuzzy scoring, no affinity ranking. |
 | `get_group_members` | Members of a persistent group. Ad-hoc rooms without a group record fail honestly rather than returning a fake empty list. |
 
+### Insight (read the situation, not just the messages)
+
+| Tool | Does |
+| --- | --- |
+| `get_insight` | A compact *context network* over your local index — structure the agent reasons over, not a message dump. Returns `connectors` (people who appear across ≥2 of your chats, with the structural **bridges** whose removal would split your contact graph), `relationships` (per-conversation engagement and your typical reply **rhythm** there), and `open` (conversations whose latest message isn't yours, ranked by how **overdue** they are *relative to that rhythm*, each with a preview). It computes only structure and statistics: it deliberately does **not** decide who a message is addressed to, whether it's an open request or a closing acknowledgement, or a nickname's real identity — that is language the agent reads from each preview, dereferencing `get_chat_messages` only when a thread is worth judging. Encoded as [TOON](https://github.com/toon-format/toon), ≈¼ the tokens of the equivalent JSON. |
+
 ### Writing (these really send — not drafts)
 
 | Tool | Does |
@@ -430,7 +450,7 @@ fabricates a fallback, a placeholder, or a fake success.
 
 | Tool | Does |
 | --- | --- |
-| `search_messages` | Hybrid search across all indexed conversations. Auto-collects on first use. Returns `mode` (`hybrid`/`semantic`/`keyword`) so nothing is hidden. |
+| `search_messages` | Hybrid search across all indexed conversations. Auto-collects on first use, diversifies results across chats, and returns a small context window around each hit. Returns `mode` (`hybrid`/`semantic`/`keyword`) so nothing is hidden. |
 | `collect_messages` | Explicit bulk-index into the local DB + embed for semantic search. The only tool allowed to bulk-fetch; runs once per call, never on a timer. |
 
 ### Scope & privacy (all work offline, no LINE session needed)
@@ -530,6 +550,13 @@ live in un-embedded messages; pure keyword misses paraphrases; fusing both surfa
 an exact term and a meaning-match together. The response's `mode` field always
 reports which methods contributed.
 
+Semantic ranking keeps each message as its own vector. Testing against real indexed
+LINE conversations found that embedding overlapping conversation windows diluted the
+center message and reduced retrieval quality. Context is therefore added only after
+ranking: Yomi limits one chat from flooding the top results and expands each winner
+with two messages on either side so the agent sees the exchange that gave the hit
+meaning without weakening the embedding itself.
+
 Semantic ranking uses **`Xenova/bge-small-zh-v1.5`** (BAAI general embedding, small,
 Chinese-primary but multilingual) via **transformers.js**. Embedding **inference runs
 fully in-process on CPU — your message text is never sent anywhere.**

package/dist/auth/credential-store.js

@@ -54,40 +54,6 @@ function parseCredentialBlob(blob) {
         return {};
     }
 }
-/** In-memory credential store for testing and non-persistent scenarios. */
-export class InMemoryStore {
-    store;
-    constructor() {
-        this.store = new Map();
-    }
-    /**
-     * Gets a credential value.
-     * @param key - Credential key.
-     * @returns Stored value or null.
-     */
-    async get(key) {
-        return this.store.get(key) ?? null;
-    }
-    /**
-     * Sets a credential value.
-     * @param key - Credential key.
-     * @param value - Value to store.
-     */
-    async set(key, value) {
-        this.store.set(key, value);
-    }
-    /**
-     * Deletes a credential.
-     * @param key - Credential key to delete.
-     */
-    async delete(key) {
-        this.store.delete(key);
-    }
-    /** Wipes all credentials. */
-    async clearAll() {
-        this.store.clear();
-    }
-}
 /**
  * Key prefixes for VOLATILE, recomputable E2EE cache — peer public keys and
  * group shared keys. These are written on nearly every message decrypt, so

package/dist/insight/graph.js

@@ -0,0 +1,90 @@
+/**
+ * Graph primitives for the relationship layer.
+ *
+ * "Who bridges your conversations?" is a classical graph question: build the
+ * person co-occurrence graph (people are nodes, an edge joins two people who
+ * share a chat) and find its articulation points. A node whose removal raises
+ * the connected-component count is a cut vertex — a person the structure of your
+ * contact network depends on, the bridge between otherwise-separate groups —
+ * defined structurally rather than by counting.
+ *
+ * Undirected graph, adjacency list, iterative traversal (recursion would risk a
+ * stack overflow on a long chain). Personal-scale, plain arrays.
+ */
+/** Build an adjacency list for `n` nodes from an edge list. */
+function adjacency(n, edges) {
+    const adj = Array.from({ length: n }, () => []);
+    for (const { a, b } of edges) {
+        if (a === b) {
+            continue;
+        }
+        adj[a].push(b);
+        adj[b].push(a);
+    }
+    return adj;
+}
+/**
+ * Articulation points (cut vertices) of the graph, by iterative Tarjan DFS.
+ * A node is an articulation point if removing it increases the number of
+ * connected components.
+ *
+ * @param n - Number of nodes.
+ * @param edges - Undirected edges.
+ * @returns Set of node indices that are articulation points.
+ */
+export function articulationPoints(n, edges) {
+    const adj = adjacency(n, edges);
+    const disc = new Array(n).fill(-1);
+    const low = new Array(n).fill(0);
+    const isArt = new Set();
+    let timer = 0;
+    for (let s = 0; s < n; s++) {
+        if (disc[s] !== -1) {
+            continue;
+        }
+        // Iterative DFS: frame carries the node, its parent, and an index into its
+        // adjacency list (the resume point after visiting a child).
+        const stack = [
+            { u: s, parent: -1, i: 0 },
+        ];
+        let rootChildren = 0;
+        while (stack.length > 0) {
+            const frame = stack[stack.length - 1];
+            const { u, parent } = frame;
+            if (frame.i === 0) {
+                disc[u] = low[u] = timer++;
+            }
+            if (frame.i < adj[u].length) {
+                const v = adj[u][frame.i];
+                frame.i++;
+                if (v === parent) {
+                    continue;
+                }
+                if (disc[v] === -1) {
+                    if (u === s) {
+                        rootChildren++;
+                    }
+                    stack.push({ u: v, parent: u, i: 0 });
+                }
+                else {
+                    low[u] = Math.min(low[u], disc[v]);
+                }
+            }
+            else {
+                stack.pop();
+                if (parent !== -1) {
+                    low[parent] = Math.min(low[parent], low[u]);
+                    // A non-root parent is a cut vertex if a child cannot reach above it.
+                    if (parent !== s && low[u] >= disc[parent]) {
+                        isArt.add(parent);
+                    }
+                }
+            }
+        }
+        // The root is a cut vertex iff it has more than one DFS child.
+        if (rootChildren > 1) {
+            isArt.add(s);
+        }
+    }
+    return isArt;
+}

package/dist/insight/index.js

@@ -0,0 +1,61 @@
+/**
+ * The insight layer's first stage: build structured, unsupervised context for
+ * an agent to reason over — it does not decide what needs attention itself.
+ *
+ * The division of labour is deliberate. Determining whether a message is an
+ * open request or a closing acknowledgement is illocutionary force, which topic
+ * embeddings provably do not encode (see ./pending), so no amount of clustering
+ * or scoring here can decide "needs attention" without guessing. Instead this
+ * stage assembles what CAN be computed without content understanding — the
+ * relationship graph (./relationships), reply rhythm (./rhythm), and the
+ * candidate pending items with their thread context (./pending) — and returns
+ * it as a package. The agent consuming the tool makes the final call, grounded
+ * in that context rather than in a raw message dump.
+ */
+import { getEmbeddingCount, getMessagesWithVectors } from '../search/store.js';
+import { findPending } from './pending.js';
+import { buildRelationships, findConnectors, } from './relationships.js';
+const DEFAULT_LOOKBACK_MS = 21 * 24 * 60 * 60 * 1000;
+const EMPTY = {
+    window: { fromMs: 0, toMs: 0, messages: 0 },
+    relationships: [],
+    connectors: [],
+    open: [],
+};
+/**
+ * Assemble the insight context package over the local index.
+ *
+ * @param opts - Focus, window, self identity, and embedder model selection.
+ * @returns The relationship graph, connectors, and pending candidates.
+ */
+export function computeInsights(opts) {
+    const model = opts.embedder.modelLabel;
+    if (getEmbeddingCount(model) === 0) {
+        return EMPTY;
+    }
+    const all = getMessagesWithVectors(model);
+    if (all.length === 0) {
+        return EMPTY;
+    }
+    // Window anchors to the newest captured message, not wall-clock: capture can
+    // lag, and the analysis should look back from the data's own edge.
+    const newest = all[all.length - 1].createdTime;
+    const lookback = opts.sinceHours
+        ? opts.sinceHours * 60 * 60 * 1000
+        : DEFAULT_LOOKBACK_MS;
+    const since = newest - lookback;
+    const rows = all.filter((r) => r.createdTime >= since);
+    let relationships = buildRelationships(rows, opts.selfMid);
+    const connectors = findConnectors(rows, opts.selfMid);
+    let open = findPending(rows, opts.selfMid, newest);
+    if (opts.focusChatId) {
+        relationships = relationships.filter((r) => r.chatId === opts.focusChatId);
+        open = open.filter((o) => o.chatId === opts.focusChatId);
+    }
+    return {
+        window: { fromMs: since, toMs: newest, messages: rows.length },
+        relationships,
+        connectors,
+        open,
+    };
+}

package/dist/insight/pending.js

@@ -0,0 +1,92 @@
+/**
+ * Open threads — conversations whose latest message is not yours — as compact
+ * directed edges for a network the agent reads cheaply, not raw thread dumps.
+ *
+ * The tool's job stops at structure and statistics: which conversation, whether
+ * it is 1:1, who spoke last, how long it has waited, and how that compares to
+ * the relationship's own reply rhythm. It does NOT parse who a message is
+ * addressed to, resolve nicknames, or judge open-request vs closing-ack — those
+ * are language understanding (addressing conventions, illocutionary force,
+ * identity) that hand-written heuristics only overfit to one corpus. The agent
+ * reads the `preview` (and fetches the thread when needed) and does all of that
+ * itself, in any language, with no brittle rules here. `typicality` (embedding
+ * density) is a boilerplate-shape hint only — it also buries polite requests,
+ * so it must not be used as a filter.
+ */
+import { replyRhythmHours } from './rhythm.js';
+const HOUR = 3_600_000;
+function dot(a, b) {
+    const n = Math.min(a.length, b.length);
+    let s = 0;
+    for (let i = 0; i < n; i++) {
+        s += a[i] * b[i];
+    }
+    return s;
+}
+/** Mean of the top-K cosine similarities to all other messages (typicality). */
+function typicality(vec, all, k) {
+    const scores = [];
+    for (const v of all) {
+        if (v !== vec) {
+            scores.push(dot(vec, v));
+        }
+    }
+    scores.sort((a, b) => b - a);
+    const top = scores.slice(0, k);
+    return top.length ? top.reduce((s, x) => s + x, 0) / top.length : 0;
+}
+/**
+ * Find open threads across all conversations you participate in.
+ *
+ * @param rows - All windowed messages with vectors.
+ * @param selfMid - The account owner's MID.
+ * @param nowMs - Reference "now" (typically the newest captured message time).
+ * @param opts - Density-K and preview length.
+ * @returns Open threads, most overdue first.
+ */
+export function findPending(rows, selfMid, nowMs, opts = {}) {
+    const k = opts.densityK ?? 15;
+    const previewChars = opts.previewChars ?? 80;
+    const allVecs = rows.map((r) => r.vector);
+    const byChat = new Map();
+    for (const r of rows) {
+        const list = byChat.get(r.chatId);
+        if (list) {
+            list.push(r);
+        }
+        else {
+            byChat.set(r.chatId, [r]);
+        }
+    }
+    const items = [];
+    for (const [, msgs] of byChat) {
+        const senders = new Set(msgs.map((m) => m.fromMid).filter(Boolean));
+        if (selfMid == null || !senders.has(selfMid)) {
+            continue;
+        }
+        const sorted = [...msgs].sort((a, b) => a.createdTime - b.createdTime);
+        const last = sorted[sorted.length - 1];
+        if (last.fromMid === selfMid) {
+            continue; // ball is in their court
+        }
+        const rhythmHours = replyRhythmHours(sorted, selfMid);
+        const waitHours = (nowMs - last.createdTime) / HOUR;
+        items.push({
+            chatId: last.chatId,
+            chatName: last.chatName,
+            isDM: senders.size <= 2,
+            fromName: last.fromName,
+            waitHours,
+            rhythmHours,
+            overdueRatio: rhythmHours
+                ? waitHours / Math.max(rhythmHours, 0.25)
+                : waitHours / 24,
+            typicality: typicality(last.vector, allVecs, k),
+            preview: last.text.replace(/\s+/g, ' ').slice(0, previewChars),
+            lastMessageId: last.messageId,
+            lastTimeMs: last.createdTime,
+        });
+    }
+    items.sort((a, b) => b.overdueRatio - a.overdueRatio);
+    return items;
+}

package/dist/insight/relationships.js

@@ -0,0 +1,125 @@
+/**
+ * The relationship layer: who you talk to, how, and how often — the 對象/關係
+ * axis of the analysis, built purely from interaction structure (no message
+ * content). This is unsupervised context for the agent's final judgement, not a
+ * judgement itself.
+ *
+ * Two views:
+ *   - per-conversation engagement (reciprocity, rhythm, recency), so a pending
+ *     item can be weighed by how much the relationship actually matters;
+ *   - cross-conversation connectors: people who appear in more than one of your
+ *     chats, with the structural bridges among them found as articulation
+ *     points of the person co-occurrence graph (see ./graph).
+ */
+import { articulationPoints } from './graph.js';
+import { replyRhythmHours } from './rhythm.js';
+/**
+ * Build per-conversation engagement stats for every chat you have spoken in.
+ *
+ * @param rows - All windowed messages.
+ * @param selfMid - The account owner's MID.
+ * @returns One Relationship per chat you participate in, most recent first.
+ */
+export function buildRelationships(rows, selfMid) {
+    const byChat = new Map();
+    for (const r of rows) {
+        const list = byChat.get(r.chatId);
+        if (list) {
+            list.push(r);
+        }
+        else {
+            byChat.set(r.chatId, [r]);
+        }
+    }
+    const out = [];
+    for (const [chatId, msgs] of byChat) {
+        const senders = new Set(msgs.map((m) => m.fromMid).filter(Boolean));
+        if (selfMid == null || !senders.has(selfMid)) {
+            continue;
+        }
+        const yourMessages = msgs.filter((m) => m.fromMid === selfMid).length;
+        out.push({
+            chatId,
+            chatName: msgs[msgs.length - 1].chatName,
+            isDM: senders.size <= 2,
+            participantCount: senders.size,
+            totalMessages: msgs.length,
+            yourMessages,
+            reciprocity: yourMessages / msgs.length,
+            rhythmHours: replyRhythmHours(msgs, selfMid),
+            lastActivityMs: Math.max(...msgs.map((m) => m.createdTime)),
+        });
+    }
+    out.sort((a, b) => b.lastActivityMs - a.lastActivityMs);
+    return out;
+}
+/**
+ * Find people who appear across two or more of your conversations, and mark
+ * those that are structural bridges (articulation points) of the person
+ * co-occurrence graph — nodes whose removal would disconnect your network.
+ *
+ * @param rows - All windowed messages.
+ * @param selfMid - The account owner's MID (excluded — you connect everything).
+ * @returns Cross-conversation connectors, most-chats first.
+ */
+export function findConnectors(rows, selfMid) {
+    // person → chats they speak in, and their display name.
+    const chatsOf = new Map();
+    const nameOf = new Map();
+    // chat → the set of people in it, to build co-occurrence edges.
+    const peopleIn = new Map();
+    const addTo = (map, key, value) => {
+        const set = map.get(key);
+        if (set) {
+            set.add(value);
+        }
+        else {
+            map.set(key, new Set([value]));
+        }
+    };
+    for (const r of rows) {
+        const mid = r.fromMid;
+        if (!mid || mid === selfMid) {
+            continue;
+        }
+        addTo(chatsOf, mid, r.chatId);
+        addTo(peopleIn, r.chatId, mid);
+        if (!nameOf.has(mid)) {
+            nameOf.set(mid, r.fromName);
+        }
+    }
+    const people = [...chatsOf.keys()];
+    const index = new Map(people.map((mid, i) => [mid, i]));
+    const seenEdge = new Set();
+    const edges = [];
+    for (const members of peopleIn.values()) {
+        const list = [...members];
+        for (let i = 0; i < list.length; i++) {
+            for (let j = i + 1; j < list.length; j++) {
+                const a = index.get(list[i]);
+                const b = index.get(list[j]);
+                const key = a < b ? `${a}-${b}` : `${b}-${a}`;
+                if (!seenEdge.has(key)) {
+                    seenEdge.add(key);
+                    edges.push({ a, b });
+                }
+            }
+        }
+    }
+    const bridges = articulationPoints(people.length, edges);
+    const out = [];
+    for (const mid of people) {
+        const chatCount = chatsOf.get(mid)?.size ?? 0;
+        if (chatCount < 2) {
+            continue;
+        }
+        out.push({
+            mid,
+            name: nameOf.get(mid) ?? null,
+            chatCount,
+            isBridge: bridges.has(index.get(mid)),
+        });
+    }
+    out.sort((a, b) => b.chatCount - a.chatCount);
+    return out;
+}

package/dist/insight/rhythm.js

@@ -0,0 +1,50 @@
+/**
+ * Reply rhythm of a conversation, at the level of turns rather than messages.
+ *
+ * "How long you normally take to reply to someone" is what makes a wait
+ * *overdue* — a fixed hour threshold is wrong, because some threads run in
+ * seconds and others in days. The naive estimate (median gap between every
+ * incoming→your-message pair) is corrupted by bursts: inside a rapid exchange
+ * the gaps are near-zero, dragging the median to zero.
+ *
+ * So messages are first collapsed into turns (maximal runs by the same side,
+ * you vs. the other party), and a reply latency is measured only across a real
+ * turn hand-off: from the end of the other side's turn to the start of yours.
+ * The median of those latencies is the relationship's rhythm.
+ */
+/**
+ * Median turn hand-off latency (in hours) from the other party to you — the
+ * relationship's reply rhythm. Null when the conversation contains no such
+ * hand-off (e.g. you never replied, or only you have spoken).
+ *
+ * @param messages - The conversation's messages, any order.
+ * @param selfMid - The account owner's MID.
+ * @returns Median reply latency in hours, or null if not estimable.
+ */
+export function replyRhythmHours(messages, selfMid) {
+    const sorted = [...messages].sort((a, b) => a.createdTime - b.createdTime);
+    // Collapse into turns keyed by self vs. other.
+    const turns = [];
+    for (const m of sorted) {
+        const self = m.fromMid === selfMid;
+        const top = turns[turns.length - 1];
+        if (!top || top.self !== self) {
+            turns.push({ self, first: m.createdTime, last: m.createdTime });
+        }
+        else {
+            top.last = m.createdTime;
+        }
+    }
+    const HOUR = 3_600_000;
+    const latencies = [];
+    for (let i = 1; i < turns.length; i++) {
+        if (turns[i].self && !turns[i - 1].self) {
+            latencies.push((turns[i].first - turns[i - 1].last) / HOUR);
+        }
+    }
+    if (latencies.length === 0) {
+        return null;
+    }
+    latencies.sort((a, b) => a - b);
+    return latencies[Math.floor(latencies.length / 2)];
+}

package/dist/line/auth/protocol/index.js

@@ -1,3 +1 @@
-export { initE2EE } from './e2ee-bootstrap.js';
-export { extractE2EEInfo } from './login-metadata.js';
 export { performPwlessLogin } from './pwless-login-flow.js';

package/dist/line/auth/pwless/index.js

@@ -25,7 +25,7 @@ import { checkPaakAuthenticated, checkPinCodeVerified, createSession, getE2eeKey
  * each step is this value multiplied by that step's attempt count — see
  * `PIN_VERIFY_CLIENT_CEILING_MS` / `PAAK_AUTH_CLIENT_CEILING_MS` below.
  */
-export const PWLESS_POLL_TIMEOUT_MS = 65000;
+const PWLESS_POLL_TIMEOUT_MS = 65000;
 /**
  * Real client-side ceiling for the PIN-verification long-poll loop: how long
  * yomi keeps waiting for the human to enter the PIN before giving up.

package/dist/line/client/index.js

@@ -38,7 +38,7 @@ const LINE_AUTH_INVALIDATED_PATTERN = /V3_TOKEN_CLIENT_LOGGED_OUT|LOGGED_OUT|DIV
  * @param message - Human-readable diagnostic message
  * @param data - Structured exception payload
  */
-export class LineRequestError extends Error {
+class LineRequestError extends Error {
     data;
     type;
     constructor(type, message, data = {}) {

package/dist/line/client/talk-service/chat-query.js

@@ -20,7 +20,7 @@ function normalizeNumericValue(value) {
  * @param responseRoot - Root response payload.
  * @returns Raw chat array or null.
  */
-export function findChatArray(responseRoot) {
+function findChatArray(responseRoot) {
     if (!responseRoot) {
         return null;
     }
@@ -52,7 +52,7 @@ export function findChatArray(responseRoot) {
  * @param chat - Raw chat thrift struct.
  * @returns Normalized chat or null.
  */
-export function mapChatStruct(chat) {
+function mapChatStruct(chat) {
     if (!chat || typeof chat !== 'object') {
         return null;
     }
@@ -73,7 +73,7 @@ export function mapChatStruct(chat) {
  * @param chats - Raw chat list.
  * @returns Normalized chat list.
  */
-export function mapChatList(chats) {
+function mapChatList(chats) {
     return Array.isArray(chats)
         ? chats
             .map((chat) => mapChatStruct(chat))

package/dist/line/client/talk-service/contact-query.js

@@ -47,7 +47,7 @@ function mapContactCapabilityFields(contact) {
  * @param contact - Raw contact thrift struct.
  * @returns Normalized contact or null.
  */
-export function mapContactStruct(contact) {
+function mapContactStruct(contact) {
     if (!contact || typeof contact !== 'object') {
         return null;
     }

package/dist/line/client/talk-service/requests.js

@@ -39,7 +39,7 @@ export function normalizeSendMessageOptions(to, text) {
  * @param options - Normalized send-message options.
  * @returns Thrift struct fields.
  */
-export function buildSendMessagePayload(options) {
+function buildSendMessagePayload(options) {
     const fields = [stringField(2, options.to), i32Field(15, options.contentType)];
     if (options.text != null) {
         fields.push(stringField(10, options.text));

package/dist/line/core/e2ee/crypto/crypto-primitives.js

@@ -9,7 +9,7 @@ import { sharedKey as curve25519SharedKey } from 'curve25519-js';
  * @param args - Data to hash (strings or Uint8Array)
  * @returns Hash digest as Buffer
  */
-export function sha256(...args) {
+function sha256(...args) {
     const h = crypto.createHash('sha256');
     for (const a of args) {
         const buf = Buffer.from(a);
@@ -22,7 +22,7 @@ export function sha256(...args) {
  * @param buf - Buffer to XOR
  * @returns Resulting buffer with half the length
  */
-export function xorHalves(buf) {
+function xorHalves(buf) {
     const half = Math.floor(buf.length / 2);
     const out = Buffer.alloc(half);
     for (let i = 0; i < half; i++) {
@@ -41,19 +41,6 @@ export function aesDecrypt(data, key, iv) {
     const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
     return Buffer.concat([decipher.update(data), decipher.final()]);
 }
-/**
- * Generate X25519 key pair for E2EE
- * @returns Key pair object
- */
-export function generateKeyPair() {
-    const { publicKey, privateKey } = crypto.generateKeyPairSync('x25519');
-    const pub = publicKey.export({ type: 'spki', format: 'der' }).slice(-32);
-    const priv = privateKey.export({ type: 'pkcs8', format: 'der' }).slice(-32);
-    return {
-        publicKey: pub,
-        privateKey: priv,
-    };
-}
 /**
  * Compute X25519 shared secret from raw 32-byte keys.
  *

package/dist/line/core/e2ee/index.js

@@ -2,5 +2,4 @@
  * LINE E2EE - exports
  */
 export { decryptKeyChain } from './bootstrap/keychain.js';
-export { aesDecrypt, generateKeyPair, sha256, xorHalves, } from './crypto/crypto-primitives.js';
 export { KeyManager as E2EEKeyManager } from './keys/key-manager.js';