dsh-plugin-term-dictionary 0.0.0-stage → 1.1.0

package/lib/core/stopwords.js

@@ -0,0 +1,147 @@
+"use strict";
+/** Common words the detector must never treat as jargon on their own. */
+const EN = [
+  "a", "ability", "able", "about", "above", "accept", "according", "account",
+  "achieve", "across", "act", "action", "activity", "actually", "add", "address",
+  "admit", "adopt", "advance", "advantage", "affect", "after", "again", "against",
+  "age", "ago", "agree", "ahead", "air", "all", "allow", "almost",
+  "alone", "along", "already", "also", "although", "always", "among", "amount",
+  "analysis", "and", "animal", "another", "answer", "any", "anyone", "anything",
+  "appear", "apply", "approach", "area", "argue", "arm", "around", "arrive",
+  "art", "article", "as", "ask", "assume", "at", "attack", "attempt",
+  "attention", "author", "authority", "available", "avoid", "away", "baby", "back",
+  "bad", "bag", "ball", "bank", "bar", "basic", "basis", "be",
+  "bear", "beat", "beautiful", "because", "become", "bed", "before", "begin",
+  "behavior", "behind", "being", "believe", "below", "best", "better", "between",
+  "beyond", "big", "bill", "bit", "black", "blood", "blue", "board",
+  "body", "book", "born", "both", "box", "boy", "break", "bring",
+  "brother", "build", "building", "business", "but", "buy", "by", "call",
+  "can", "candidate", "capital", "car", "card", "care", "career", "carry",
+  "case", "catch", "cause", "cell", "center", "central", "century", "certain",
+  "certainly", "chair", "challenge", "chance", "change", "character", "charge", "check",
+  "child", "choice", "choose", "city", "claim", "class", "clear", "clearly",
+  "client", "close", "code", "cold", "college", "color", "come", "comment",
+  "commercial", "common", "community", "company", "compare", "computer", "concern", "condition",
+  "consider", "contain", "continue", "control", "conversation", "cost", "could", "country",
+  "couple", "course", "cover", "create", "culture", "current", "customer", "cut",
+  "damage", "dark", "data", "day", "dead", "deal", "death", "debate",
+  "decide", "decision", "deep", "degree", "describe", "design", "desire", "detail",
+  "determine", "develop", "development", "die", "difference", "different", "difficult", "direction",
+  "discover", "discuss", "discussion", "do", "doctor", "dog", "door", "down",
+  "draw", "dream", "drive", "drop", "during", "each", "early", "earn",
+  "earth", "east", "easy", "eat", "economic", "economy", "edge", "education",
+  "effect", "effort", "eight", "either", "else", "employee", "end", "energy",
+  "enjoy", "enough", "enter", "entire", "environment", "error", "especially", "establish",
+  "even", "evening", "event", "ever", "every", "everybody", "everyone", "everything",
+  "evidence", "exactly", "example", "exist", "expect", "experience", "expert", "explain",
+  "eye", "face", "fact", "factor", "fail", "fall", "family", "far",
+  "fast", "father", "fear", "feel", "feeling", "few", "field", "fight",
+  "figure", "file", "fill", "film", "final", "finally", "find", "fine",
+  "finish", "fire", "first", "five", "floor", "fly", "focus", "follow",
+  "food", "foot", "for", "force", "foreign", "forget", "form", "former",
+  "forward", "four", "free", "friend", "from", "front", "full", "fund",
+  "future", "game", "general", "generation", "get", "girl", "give", "glass",
+  "go", "goal", "good", "government", "great", "green", "ground", "group",
+  "grow", "growth", "guess", "guy", "half", "hand", "hang", "happen",
+  "happy", "hard", "have", "he", "head", "health", "hear", "heart",
+  "heat", "heavy", "help", "her", "here", "herself", "high", "him",
+  "himself", "his", "history", "hit", "hold", "home", "hope", "hot",
+  "hour", "house", "how", "however", "huge", "human", "hundred", "i",
+  "idea", "identify", "if", "image", "imagine", "impact", "important", "improve",
+  "in", "include", "including", "increase", "indeed", "indicate", "individual", "industry",
+  "information", "input", "inside", "instead", "interest", "interesting", "international", "into",
+  "investment", "involve", "is", "issue", "it", "item", "its", "itself",
+  "job", "join", "just", "keep", "key", "kid", "kill", "kind",
+  "know", "knowledge", "land", "language", "large", "last", "late", "later",
+  "law", "lead", "leader", "learn", "least", "leave", "left", "legal",
+  "less", "let", "letter", "level", "life", "light", "like", "likely",
+  "line", "list", "listen", "little", "live", "local", "long", "look",
+  "lose", "loss", "lot", "love", "low", "machine", "main", "maintain",
+  "major", "make", "man", "manage", "management", "manager", "many", "market",
+  "matter", "may", "maybe", "me", "mean", "measure", "media", "medical",
+  "meet", "meeting", "member", "memory", "mention", "message", "method", "middle",
+  "might", "million", "mind", "minute", "miss", "model", "modern", "moment",
+  "money", "month", "more", "morning", "most", "mother", "move", "movement",
+  "much", "music", "must", "my", "myself", "name", "nation", "national",
+  "natural", "nature", "near", "nearly", "necessary", "need", "network", "never",
+  "new", "news", "next", "nice", "night", "no", "nobody", "nor",
+  "north", "not", "note", "nothing", "notice", "now", "number", "of",
+  "off", "offer", "office", "official", "often", "oh", "old", "on",
+  "once", "one", "only", "open", "operation", "opportunity", "option", "or",
+  "order", "organization", "other", "others", "our", "ourselves", "out", "output",
+  "outside", "over", "own", "page", "paper", "parent", "part", "particular",
+  "particularly", "partner", "party", "pass", "past", "pattern", "pay", "people",
+  "per", "perform", "performance", "perhaps", "period", "person", "personal", "phone",
+  "physical", "pick", "picture", "piece", "place", "plan", "play", "please",
+  "point", "police", "policy", "political", "politics", "poor", "popular", "population",
+  "position", "possible", "power", "practice", "prepare", "present", "president", "press",
+  "pressure", "pretty", "prevent", "price", "private", "probably", "problem", "process",
+  "produce", "product", "production", "professional", "program", "project", "property", "protect",
+  "prove", "provide", "public", "pull", "purpose", "push", "put", "quality",
+  "question", "quickly", "quite", "radio", "raise", "range", "rate", "rather",
+  "reach", "read", "ready", "real", "reality", "realize", "really", "reason",
+  "receive", "recent", "recently", "recognize", "record", "red", "reduce", "relate",
+  "relationship", "remain", "remember", "remove", "replace", "report", "represent", "require",
+  "research", "resource", "respond", "response", "responsibility", "result", "return", "rich",
+  "right", "rise", "risk", "road", "role", "room", "rule", "run",
+  "safe", "same", "save", "say", "school", "science", "score", "season",
+  "seat", "second", "section", "security", "see", "seek", "seem", "sell",
+  "send", "senior", "sense", "series", "serious", "serve", "server", "service",
+  "set", "seven", "several", "share", "she", "short", "should", "show",
+  "side", "sign", "significant", "similar", "simple", "simply", "since", "single",
+  "sit", "site", "situation", "six", "size", "skill", "small", "so",
+  "social", "society", "some", "somebody", "someone", "something", "sometimes", "soon",
+  "sort", "sound", "source", "south", "space", "speak", "special", "specific",
+  "speech", "spend", "staff", "stage", "stand", "standard", "start", "state",
+  "statement", "stay", "step", "still", "stop", "store", "story", "strategy",
+  "street", "string", "strong", "structure", "student", "study", "stuff", "style",
+  "subject", "success", "successful", "such", "suddenly", "suggest", "summer", "support",
+  "sure", "system", "table", "take", "talk", "task", "teach", "teacher",
+  "team", "technology", "tell", "ten", "term", "test", "than", "thank",
+  "that", "the", "their", "them", "themselves", "then", "theory", "there",
+  "therefore", "these", "they", "thing", "think", "third", "this", "those",
+  "though", "thought", "thousand", "three", "through", "throughout", "thus", "time",
+  "to", "today", "together", "too", "top", "total", "toward", "town",
+  "trade", "traditional", "training", "travel", "treat", "tree", "trouble", "true",
+  "trust", "truth", "try", "turn", "type", "under", "understand", "unit",
+  "until", "up", "upon", "us", "use", "used", "useful", "user",
+  "usually", "value", "various", "very", "view", "visit", "voice", "wait",
+  "walk", "wall", "want", "war", "watch", "water", "way", "we",
+  "wear", "week", "weight", "well", "west", "what", "whatever", "when",
+  "where", "whether", "which", "while", "white", "who", "whole", "whom",
+  "whose", "why", "wide", "will", "win", "window", "with", "within",
+  "without", "woman", "wonder", "word", "work", "worker", "world", "worry",
+  "would", "write", "writer", "wrong", "yeah", "year", "yes", "yet",
+  "you", "young", "your", "yourself", "yourselves"
+];
+const ZH = [
+  "一", "一下", "一个", "一些", "一样", "一点", "一直", "一般",
+  "一起", "上", "上面", "下", "下面", "不", "不同", "不少",
+  "与", "且", "东西", "个", "中", "中间", "为", "为了",
+  "为什么", "主要", "之前", "之后", "之间", "也", "也许", "了",
+  "事情", "些", "产品", "什么", "仅", "今天", "从", "从来",
+  "他", "他们", "代码", "以", "以前", "以及", "以后", "们",
+  "会", "但", "但是", "你", "你们", "使用", "例如", "全部",
+  "公司", "关于", "其中", "其他", "其实", "具体", "内容", "再",
+  "分钟", "列表", "别人", "到", "到底", "前面", "包括", "却",
+  "原因", "又", "及", "只", "可", "可以", "可能", "各",
+  "名称", "后面", "向", "和", "哪里", "因为", "困难", "在",
+  "地方", "基本", "复杂", "外面", "多", "大", "大家", "大概",
+  "大量", "太", "她", "她们", "好", "如果", "孩子", "它",
+  "它们", "客户端", "容易", "对", "对于", "将", "将会", "小",
+  "小时", "少", "尤其", "就", "工作", "差不多", "已", "已经",
+  "市场", "并", "应该", "当", "当然", "很", "很多", "必须",
+  "快速", "怎么", "总是", "情况", "意思", "慢慢", "我", "我们",
+  "或", "所以", "所有", "才", "把", "数据", "整个", "文件",
+  "方便", "方式", "方法", "时候", "时间", "明天", "昨天", "是",
+  "更", "曾", "最", "有", "有时", "朋友", "服务", "服务器",
+  "某", "模型", "正", "正在", "每", "比如", "比较", "然后",
+  "特别", "现在", "生活", "用户", "由于", "的", "目的", "直接",
+  "相同", "真", "究竟", "等等", "简单", "类型", "系统", "经常",
+  "结果", "给", "而", "能", "自己", "至于", "表格", "被",
+  "要", "让", "该", "跟", "输入", "输出", "还", "这",
+  "这个", "这些", "这里", "进行", "通过", "那", "那个", "那些",
+  "那里", "部分", "都", "里面", "重要", "错误", "问题", "间接",
+  "除了", "需要", "非常", "页面"
+];
+module.exports = { EN, ZH };

package/lib/core/store.js

@@ -0,0 +1,397 @@
+"use strict";
+
+/**
+ * The page's view of the dictionary: one subscribable state object plus every
+ * mutation the UI performs.
+ *
+ * All state flows through this class so the panel, the popup and the detector
+ * always read the same generation. It is intentionally React-free: the bundle
+ * converts {@link DictionaryStore#getSnapshot} into hook state with `useSyncExternalStore`,
+ * which is what lets a mutation made by the transcript interaction surface
+ * re-render the sidebar panel.
+ *
+ * Persistence is layered rather than duplicated. The local store is written
+ * first and always, so an edit survives a reload even with no host; the remote
+ * store is written afterwards and a failure is recorded as a sync error instead
+ * of losing the edit.
+ */
+
+const entriesModule = require("./entries.js");
+const dictionary = require("./dictionary.js");
+
+const { isUnexplained } = entriesModule;
+const { emptyState, editEntry, recordSighting, removeEntry, clearAll, listEntries, summarize, mergeState, seal } = dictionary;
+
+/** Longest context the store keeps per entry. */
+const MAX_CONTEXT_CHARS = entriesModule.MAX_CONTEXT_CHARS;
+
+/**
+ * @param options - `local` and `remote` stores, each with `load`/`save` (the
+ *   remote one may be null), `now` for tests, and `logger`.
+ */
+function createDictionaryStore(options) {
+	const local = options.local;
+	const remote = options.remote ?? null;
+	const now = typeof options.now === "function" ? options.now : () => Date.now();
+	const logger = options.logger;
+
+	/** What the host reported about itself: data directory, writability, model. */
+	let hostInfo = null;
+	let state = emptyState({ now: now() });
+	// The first projection runs before the initial hydration read, so it must be
+	// safe to build with no host information yet.
+	let view = buildView();
+	let status = "loading";
+	let syncError = "";
+	const listeners = new Set();
+
+	/** The derived, render-ready projection of the document. */
+	function buildView() {
+		return {
+			state,
+			stats: summarize(state),
+			list: state.entries,
+			hostInfo
+		};
+	}
+
+	/** Publish the current generation to subscribers. */
+	function emit() {
+		view = buildView();
+		for (const listener of [...listeners]) {
+			try {
+				listener();
+			} catch (error) {
+				logger?.warn?.(`term-dictionary: subscriber failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+
+	/** Swap in a new document, persist it locally, and notify. */
+	function commit(next, options) {
+		state = next;
+		emit();
+		const writing = options?.persist === false ? Promise.resolve() : local.save(state);
+		return Promise.resolve(writing).then(() => {
+			if (options?.sync !== false) queueRemoteSync();
+		});
+	}
+
+	let syncTimer = null;
+
+	/**
+	 * Push the whole document to the host shortly after the last mutation.
+	 *
+	 * One debounced full push beats one request per keystroke: the document is
+	 * small, the host merges by term, and a burst of edits costs one round trip.
+	 */
+	function queueRemoteSync() {
+		if (remote === null) return;
+		if (syncTimer !== null) clearTimeout(syncTimer);
+		syncTimer = setTimeout(() => {
+			syncTimer = null;
+			flushRemote();
+		}, 400);
+	}
+
+	/**
+	 * Send the current document to the host and adopt the answer.
+	 *
+	 * The host merges by term and tombstones, so its answer is the converged
+	 * document; adopting it is what keeps the two sides identical and lets the
+	 * host's copy of a deletion survive the page's next write.
+	 */
+	function flushRemote() {
+		if (remote === null) return Promise.resolve();
+		return Promise.resolve(remote.save(state)).then(
+			(answer) => {
+				if (answer !== undefined && answer !== null && answer.ok === false) {
+					syncError = typeof answer.error === "string" && answer.error !== "" ? answer.error : "host rejected the dictionary";
+				} else {
+					syncError = "";
+					if (answer !== null && answer !== undefined && answer.state !== undefined) {
+						// The answer is sealed, so merging it would drop the host's
+						// tombstones; `mergeState` re-derives them from the document it
+						// receives plus the ones this side already holds.
+						const adopted = mergeState(state, answer.state, { now: now() });
+						// Only a real change is worth a repaint, and only a real change may
+						// loop back into another sync.
+						if (JSON.stringify(adopted.entries) !== JSON.stringify(state.entries) || adopted.deletedKeys.length !== state.deletedKeys.length) {
+							state = adopted;
+							void local.save(state);
+						}
+					}
+				}
+				emit();
+			},
+			(error) => {
+				syncError = error instanceof Error ? error.message : String(error);
+				emit();
+			}
+		);
+	}
+
+	return {
+		/** Subscribe to any change. @returns the unsubscribe function. */
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		/** The cached projection; stable between mutations. @returns the view. */
+		getSnapshot() {
+			return view;
+		},
+		/** Lifecycle status for the panel header. @returns `loading`, `ready` or `error`. */
+		getStatus() {
+			return status;
+		},
+		/** The last host sync failure, or an empty string. @returns the message. */
+		getSyncError() {
+			return syncError;
+		},
+		/** The raw document, for the detector and the export action. @returns the document. */
+		getState() {
+			return state;
+		},
+
+		/**
+		 * Load local state, then adopt the host's document when it is reachable and
+		 * newer. A host that has never seen this profile returns nothing, and the
+		 * local document survives untouched.
+		 * @returns a promise settling when hydration finishes.
+		 */
+		async hydrate() {
+			status = "loading";
+			emit();
+			try {
+				state = local.load();
+			} catch (error) {
+				logger?.warn?.(`term-dictionary: local load failed: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			if (remote !== null) {
+				try {
+					const answer = await remote.load();
+					if (answer !== null && answer !== undefined && answer.ok === true && answer.state !== undefined) {
+						state = mergeState(state, answer.state, { now: now() });
+						hostInfo = answer.state.location ?? null;
+						await local.save(state);
+						syncError = "";
+					} else if (answer !== null && answer !== undefined && answer.ok === false) {
+						syncError = typeof answer.error === "string" && answer.error !== "" ? answer.error : "host read failed";
+					}
+				} catch (error) {
+					syncError = error instanceof Error ? error.message : String(error);
+				}
+			}
+			status = "ready";
+			emit();
+			if (remote !== null && syncError === "") queueRemoteSync();
+		},
+
+		/**
+		 * Create or update an entry from an explicit user action. The user's text is
+		 * authoritative, so this always records `source: "user"`.
+		 * @param term - the term being explained.
+		 * @param patch - `definition`, `domain`, `aliases`, `pinned`.
+		 * @returns a promise resolving to the stored entry.
+		 */
+		async saveEntry(term, patch) {
+			const result = editEntry(state, term, patch, { now: now() });
+			await commit(result.state);
+			return result.entry;
+		},
+
+		/**
+		 * Bring a deleted term back, as an explicit act.
+		 *
+		 * See `restoreEntry` in the core: a restoration is a decision with its own evidence and it
+		 * withdraws the tombstone, rather than an edit that has to win a comparison on the way to the host.
+		 * @param idOrTerm - the entry id, term or alias.
+		 * @param patch - the text to restore it with, if any.
+		 * @returns a promise resolving to `{ entry, restored }`.
+		 */
+		async restoreEntry(idOrTerm, patch) {
+			const result = dictionary.restoreEntry(state, idOrTerm, patch, { now: now() });
+			if (result.restored) await commit(result.state);
+			return { entry: result.entry, restored: result.restored };
+		},
+
+		/**
+		 * Record that a term appeared in a message, without overwriting a definition
+		 * the user wrote.
+		 *
+		 * `deleted` is passed through because the caller needs it: a sighting of a term
+		 * the user deleted is refused, and the collector must not announce it as newly
+		 * collected. Dropping the flag here made the refusal invisible to the UI.
+		 *
+		 * @param sighting - `term`, `context`, `sessionId`, optional glossary fields.
+		 * @returns a promise resolving to what happened, including `deleted`.
+		 */
+		async noteSighting(sighting) {
+			const result = recordSighting(
+				state,
+				{ ...sighting, context: typeof sighting.context === "string" ? sighting.context.slice(0, MAX_CONTEXT_CHARS) : "" },
+				{ now: now() }
+			);
+			if (!result.changed) return { created: false, deleted: result.deleted === true, entry: result.entry ?? null };
+			await commit(result.state);
+			return { created: result.created, deleted: result.deleted === true, entry: result.entry };
+		},
+
+		/**
+		 * Delete one entry.
+		 * @param idOrTerm - the entry id, or its term.
+		 * @returns a promise resolving to whether anything was deleted.
+		 */
+		async deleteEntry(idOrTerm) {
+			const result = removeEntry(state, idOrTerm, { now: now() });
+			if (result.removed) await commit(result.state);
+			return result.removed;
+		},
+
+		/**
+		 * Delete several entries, committing once.
+		 *
+		 * The panel's batch delete must not commit per row: every commit persists the
+		 * whole document and pushes it to the host, so deleting twenty rows one call at a
+		 * time would mean twenty full round trips and twenty merges. Each removal still
+		 * leaves its own tombstone — that is what stops a union merge from restoring the
+		 * rows from the host's copy — but the document is written once.
+		 *
+		 * @param idOrTerms - the entry ids, terms or aliases to remove.
+		 * @returns a promise resolving to how many were actually removed.
+		 */
+		async deleteEntries(idOrTerms) {
+			const list = Array.isArray(idOrTerms) ? idOrTerms : [];
+			let next = state;
+			let removed = 0;
+			for (const key of list) {
+				// Each removal needs the document the previous one produced: the tombstones
+				// accumulate, and a removal reads the record it is about to kill.
+				const result = removeEntry(next, key, { now: now() });
+				if (!result.removed) continue;
+				next = result.state;
+				removed++;
+			}
+			if (removed > 0) await commit(next);
+			return removed;
+		},
+
+		/**
+		 * Toggle an entry's pinned flag.
+		 * @param idOrTerm - the entry id, or its term.
+		 * @returns a promise resolving to the updated entry.
+		 */
+		async togglePinned(idOrTerm) {
+			const found = dictionary.findEntry(state, idOrTerm);
+			if (found === undefined) return null;
+			return this.saveEntry(found.term, { definition: found.definition, domain: found.domain, aliases: found.aliases, pinned: !found.pinned });
+		},
+
+		/**
+		 * Forget every entry. The user asked for it explicitly, so no confirmation
+		 * lives here; the panel owns that.
+		 *
+		 * Each removed entry leaves a tombstone, exactly like a single deletion: a
+		 * bare empty document would be merged back together with the host's copy and
+		 * the whole dictionary would return.
+		 *
+		 * @returns a promise settling when the clear is persisted.
+		 */
+		async clearAll() {
+			const result = clearAll(state, { now: now() });
+			await commit(result.state);
+			return result.removed;
+		},
+
+		/**
+		 * Bring a deleted entry back, as an explicit user action.
+		 *
+		 * The one-click counterpart to {@link DictionaryStore#deleteEntry}: retracting a deletion is
+		 * not an edit, so it carries no patch — the entry comes back as it was, rather than back with
+		 * the definition the editor happened to be seeded with. The revival itself is the dictionary's,
+		 * where the merge rules it has to satisfy live.
+		 *
+		 * @param idOrTerm - the entry id, its term, or an alias.
+		 * @returns a promise resolving to the revived entry, or null when there was nothing to revive.
+		 */
+		async reviveEntry(idOrTerm) {
+			const result = dictionary.reviveEntry(state, idOrTerm, { now: now() });
+			if (result.revived !== true) return null;
+			await commit(result.state);
+			return result.entry;
+		},
+
+		/**
+		 * Say something about an entry, or take it back.
+		 *
+		 * One method for both decisions the panel can make, because they travel together in the UI and
+		 * each call persists the whole document: `{ feedback: { kind, note } }` records a remark,
+		 * `{ feedback: null }` retracts it, and `{ untrusted: true|false }` is the verdict the automatic
+		 * explainer obeys. A field the patch leaves out is left alone, stamp included.
+		 *
+		 * @param idOrTerm - the entry id, or its term.
+		 * @param patch - `feedback` and/or `untrusted`.
+		 * @returns a promise resolving to the updated entry, or null when there is no such entry.
+		 */
+		async markEntry(idOrTerm, patch) {
+			const found = dictionary.findEntry(state, idOrTerm);
+			if (found === undefined) return null;
+			// Through `saveEntry`, so a remark is recorded with the same provenance and the same revival
+			// authority as anything else the user asked for.
+			return this.saveEntry(found.term, patch);
+		},
+
+		/**
+		 * The groups directly inside one path, each with how many entries it holds.
+		 * @param prefix - the path to look inside, `""` for the top level.
+		 * @returns `[{ group, name, count }]`.
+		 */
+		groups(prefix) {
+			return dictionary.groupsIn(state.entries, prefix);
+		},
+
+		/**
+		 * The visible list for the panel.
+		 * @param query - search text.
+		 * @param filter - `all`, `unexplained`, `pinned`, `deleted` or `flagged`.
+		 * @param group - the group path to look inside, `""` for the top level.
+		 * @returns the ordered entries. For `deleted`, the tombstones.
+		 */
+		list(query, filter, group) {
+			const at = group === undefined || group === null ? "" : String(group);
+			// The deleted view is a different LIST rather than a different filter: tombstones live in
+			// `backing`, not in `entries`, so no predicate over the live list could ever show one. The group
+			// still applies — standing in a folder and asking what was deleted there means that folder.
+			if (filter === "deleted") return dictionary.listDeleted(state, query).filter((entry) => (typeof entry.group === "string" ? entry.group : "") === at);
+			return listEntries(state, query, filter, at);
+		},
+
+		/**
+		 * Look one entry up by term text or alias.
+		 * @param idOrTerm - the entry id, or its term.
+		 * @returns the entry, or null.
+		 */
+		find(idOrTerm) {
+			return dictionary.findEntry(state, idOrTerm) ?? null;
+		},
+
+		/** Force an immediate host sync, used by the panel's retry action. */
+		retrySync() {
+			if (syncTimer !== null) {
+				clearTimeout(syncTimer);
+				syncTimer = null;
+			}
+			return flushRemote().then(() => this.hydrate());
+		},
+
+		/** Release timers. @returns nothing. */
+		dispose() {
+			if (syncTimer !== null) clearTimeout(syncTimer);
+			syncTimer = null;
+			listeners.clear();
+		}
+	};
+}
+
+module.exports = { createDictionaryStore, isUnexplained };