Fix name

bin/install-kwix.js

@@ -146,6 +146,9 @@ function resolveArchiveName() {
 }
 
 async function install() {
+	if (fs.existsSync(BIN_DIR) && (await fs.promises.readdir(BIN_DIR)).some(f => f.startsWith('kiwix-')))
+		return console.log(`Already installed: ${BIN_DIR}`);
+
 	const {archiveName, ext} = resolveArchiveName();
 	const url = `${BASE_URL}/${archiveName}`;
 	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kiwix-install-'));

package-lock.json

@@ -1,19 +1,20 @@
 {
 	"name": "@ztimson/zim-utils",
-	"version": "0.3.6",
+	"version": "0.4.11",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@ztimson/zim-utils",
-			"version": "0.3.6",
+			"version": "0.4.11",
 			"hasInstallScript": true,
 			"license": "MIT",
 			"dependencies": {
-				"@ztimson/utils": "^0.30.8",
-				"adm-zip": "^0.5.16",
+				"@ztimson/utils": "^0.30.9",
+				"adm-zip": "^0.5.18",
 				"lzma1": "^0.3.0",
 				"tar": "^7.4.3",
+				"undici": "^8.11.2",
 				"zstd-codec": "^0.1.5"
 			}
 		},
@@ -30,9 +31,9 @@
 			}
 		},
 		"node_modules/@ztimson/utils": {
-			"version": "0.30.8",
-			"resolved": "https://registry.npmjs.org/@ztimson/utils/-/utils-0.30.8.tgz",
-			"integrity": "sha512-+vBjcinqckqMHkP95xWiQeQz2E7Q1oS0b+Odjp+F9rvQ4z0US4JdodjqhEaqh+RAO/yP77x4Eu0a04yBB4HNdw==",
+			"version": "0.30.9",
+			"resolved": "https://registry.npmjs.org/@ztimson/utils/-/utils-0.30.9.tgz",
+			"integrity": "sha512-th/6qBaRJFnxoQk+01ESXjFqhYzsiXziOzd3gPgFG6XrusA+oHtfgxBKJ77ygPq//0cI85srWgAzvQcAmKUAQw==",
 			"license": "MIT",
 			"dependencies": {
 				"var-persist": "^1.0.1"
@@ -106,6 +107,15 @@
 				"node": ">=18"
 			}
 		},
+		"node_modules/undici": {
+			"version": "8.11.2",
+			"resolved": "https://registry.npmjs.org/undici/-/undici-8.11.2.tgz",
+			"integrity": "sha512-u4UB2/IrKdU6lFxumHmmo1a3fCQO5tzQllRorfoRS63txhrB7xTpSn1PftwC4qEHkOaqP95fCWW4lJzwErwzhQ==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=22.19.0"
+			}
+		},
 		"node_modules/var-persist": {
 			"version": "1.0.1",
 			"resolved": "https://registry.npmjs.org/var-persist/-/var-persist-1.0.1.tgz",

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ztimson/zim-utils",
-	"version": "0.4.1",
+	"version": "0.4.13",
 	"description": "Native, dependency-light ZIM archive reader/searcher and Kiwix catalog downloader for Node.js",
 	"author": "Zak Timson",
 	"license": "MIT",
@@ -15,10 +15,11 @@
 		"postinstall": "node ./bin/install-kwix.js"
 	},
 	"dependencies": {
-		"@ztimson/utils": "^0.30.8",
+		"@ztimson/utils": "^0.30.9",
+		"adm-zip": "^0.5.18",
 		"lzma1": "^0.3.0",
 		"tar": "^7.4.3",
-		"zstd-codec": "^0.1.5",
-		"adm-zip": "^0.5.16"
+		"undici": "^8.11.2",
+		"zstd-codec": "^0.1.5"
 	}
 }

src/catalog.js

@@ -2,19 +2,29 @@ import {fuzzyMatch} from './utils.js';
 import {decodeHtml} from '@ztimson/utils';
 
 export const CATALOG_URL = 'https://library.kiwix.org';
+export const VIEWER_URL = 'https://browse.library.kiwix.org';
 
 const PAGE_SIZE = 100;
 
 export function parseEntries(xml, catalog = CATALOG_URL) {
 	const blocks = xml.match(/<entry>[\s\S]*?<\/entry>/g) || [];
+
 	return blocks.map(b => {
 		const grab = re => (b.match(re) || [])[1] || '';
 		const linkMatch = b.match(/<link[^>]*type=["']application\/x-zim[^"']*["'][^>]*href=["']([^"']+)["']/);
 		const iconMatch = b.match(/<link[^>]*rel=["']http:\/\/opds-spec\.org\/image\/thumbnail["'][^>]*href=["']([^"']+)["']/)
 			|| b.match(/<link[^>]*type=["']image\/[^"']*["'][^>]*href=["']([^"']+)["']/);
+
 		let tags = grab(/<tags>([^<]*)<\/tags>/);
-		if(tags) tags = tags.split(';');
+		if (tags) tags = tags.split(';');
+
 		const name = grab(/<name>([^<]*)<\/name>/);
+		const href = linkMatch ? linkMatch[1] : null;
+		const filename = href
+			? decodeURIComponent(new URL(href).pathname.split('/').pop()).replace(/\.meta4$/i, '')
+			: name;
+		const viewerName = filename.replace(/\.zim$/i, '');
+
 		return {
 			id: grab(/<id>([^<]*)<\/id>/),
 			title: decodeHtml(grab(/<title>([^<]*)<\/title>/)),
@@ -22,25 +32,52 @@ export function parseEntries(xml, catalog = CATALOG_URL) {
 			summary: decodeHtml(grab(/<summary>([^<]*)<\/summary>/)),
 			language: grab(/<language>([^<]*)<\/language>/),
 			name,
+			flavour: grab(/<flavour>([^<]*)<\/flavour>/),
 			category: grab(/<category>([^<]*)<\/category>/),
 			tags,
 			mediaCount: Number(grab(/<mediaCount>([^<]*)<\/mediaCount>/)) || 0,
 			author: grab(/<author>\s*<name>([^<]*)<\/name>\s*<\/author>/m),
 			publisher: grab(/<publisher>\s*<name>([^<]*)<\/name>\s*<\/publisher>/m),
 			articleCount: Number(grab(/<articleCount>([^<]*)<\/articleCount>/)) || 0,
-			sizeMb: linkMatch ? +(Number((b.match(/length=["'](\d+)["']/) || [])[1] || 0) / 1024 / 1024).toFixed(1) : '?',
-			href: linkMatch ? linkMatch[1] : null,
+			sizeMb: href
+				? +(Number((b.match(/length=["'](\d+)["']/) || [])[1] || 0) / 1024 / 1024).toFixed(1)
+				: '?',
+			href,
 			icon: iconMatch ? new URL(iconMatch[1], catalog).href : null,
-			viewer: name ? new URL(`viewer#${name}`, catalog).href : null,
+			viewer: viewerName ? `${VIEWER_URL}/viewer#${viewerName}` : null,
 		};
 	});
 }
 
 async function fetchEntries(term, lang, url = CATALOG_URL) {
-	const params = new URLSearchParams({q: term, count: String(PAGE_SIZE), lang: lang || 'eng'});
+	const entries = [];
+	let start = 0;
+	let total = Infinity;
+
+	while (start < total) {
+		const params = new URLSearchParams({
+			q: term,
+			count: String(PAGE_SIZE),
+			start: String(start),
+			lang: lang || 'eng',
+		});
+
 		const res = await fetch(`${url}/catalog/v2/entries?${params}`);
 		if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
-	return parseEntries(await res.text());
+
+		const xml = await res.text();
+		const page = parseEntries(xml, url);
+		const totalResults = Number((xml.match(/<totalResults>(\d+)<\/totalResults>/) || [])[1]);
+
+		entries.push(...page);
+
+		if (Number.isFinite(totalResults)) total = totalResults;
+		if (!page.length || start + page.length >= total) break;
+
+		start += page.length;
+	}
+
+	return entries;
 }
 
 /** Looks up a single catalog entry by exact `name` (used to check for available updates). */
@@ -48,30 +85,73 @@ export async function zimCatalogInfo(name, url = CATALOG_URL) {
 	const params = new URLSearchParams({name, count: '5'});
 	const res = await fetch(`${url}/catalog/v2/entries?${params}`);
 	if (!res.ok) return null;
-	return parseEntries(await res.text()).find(e => e.name === name) || null;
+
+	return parseEntries(await res.text(), url).find(e => e.name === name) || null;
 }
 
-/** Searches the Kiwix catalog for ZIMs matching `terms` within `category`, ranked by term coverage then fuzzy similarity. */
+/** Searches the Kiwix catalog for ZIMs matching `terms`, ranked by relevance. */
 export async function zimCatalog(terms, opts = {lang: 'eng', count: 20, url: CATALOG_URL}) {
-	opts = Object.assign({lang: 'eng', count: 20, url: CATALOG_URL}, opts)
-	const termList = [...String(terms).split(',')].filter(Boolean).map(t => t.trim().toLowerCase());
-	const results = await Promise.allSettled(termList.map(t => fetchEntries(t, opts.lang, opts.url)));
-	const byName = new Map();
+	opts = Object.assign({lang: 'eng', count: 20, url: CATALOG_URL}, opts);
+
+	const termList = [...String(terms).split(',')]
+		.filter(Boolean)
+		.map(t => t.trim().toLowerCase());
+
+	const results = await Promise.allSettled(
+		termList.map(t => fetchEntries(t, opts.lang, opts.url))
+	);
+
+	const byZim = new Map();
+
 	results.forEach((r, i) => {
 		if (r.status !== 'fulfilled') return;
+
 		const term = termList[i];
+
 		for (const entry of r.value) {
-			if (!entry.name) continue;
-			if (!byName.has(entry.name)) byName.set(entry.name, {entry, hitTerms: new Set()});
-			byName.get(entry.name).hitTerms.add(term);
+			const zimId = entry.href || entry.id || entry.name;
+			if (!zimId) continue;
+
+			if (!byZim.has(zimId)) {
+				byZim.set(zimId, {entry, hitTerms: new Set()});
+			}
+
+			byZim.get(zimId).hitTerms.add(term);
 		}
 	});
-	if (!byName.size) return [];
 
-	return [...byName.values()].map(({entry, hitTerms}) => {
-		const text = `${entry.title} ${entry.summary}`.trim();
-		return {entry, hits: hitTerms.size, fuzzy: fuzzyMatch(text, ...termList).max};
-	}).toSorted((a, b) =>
-		b.hits - a.hits || b.fuzzy - a.fuzzy || b.entry.articleCount - a.entry.articleCount
-	).slice(0, opts.count).map(r => r.entry);
+	if (!byZim.size) return [];
+
+	return [...byZim.values()]
+		.map(({entry, hitTerms}) => {
+			const title = entry.title.toLowerCase();
+			const summary = entry.summary.toLowerCase();
+			const titleWords = title.split(/\W+/).filter(Boolean);
+
+			const exactTitle = termList.some(term => title === term);
+			const exactWord = termList.some(term => titleWords.includes(term));
+			const titleMatch = termList.some(term => title.includes(term));
+			const titleFuzzy = fuzzyMatch(title, ...termList).max;
+			const summaryFuzzy = fuzzyMatch(summary, ...termList).max;
+
+			return {
+				entry,
+				hits: hitTerms.size,
+				exactTitle,
+				exactWord,
+				titleMatch,
+				titleFuzzy,
+				summaryFuzzy,
+			};
+		})
+		.toSorted((a, b) =>
+			Number(b.exactTitle) - Number(a.exactTitle)
+			|| Number(b.exactWord) - Number(a.exactWord)
+			|| Number(b.titleMatch) - Number(a.titleMatch)
+			|| b.titleFuzzy - a.titleFuzzy
+			|| b.summaryFuzzy - a.summaryFuzzy
+			|| b.hits - a.hits
+			|| new Date(b.entry.updated) - new Date(a.entry.updated)
+		)
+		.map(r => r.entry);
 }

src/manager.js

@@ -2,21 +2,27 @@ import fs from 'node:fs';
 import path from 'node:path';
 import {pipeline} from 'node:stream/promises';
 import {Readable} from 'node:stream';
+import {PromiseProgress} from '@ztimson/utils';
 import {KiwixServer} from './server.js';
 import {zimCatalog, zimCatalogInfo, CATALOG_URL} from './catalog.js';
+import {Agent} from 'undici';
+
+const agent = new Agent({headersTimeout: 0, bodyTimeout: 0});
 
 const VISIBLE_TIMEOUT = 5_000;
 const VISIBLE_POLL_INTERVAL = 200;
 
 /** Manages a local directory of ZIM archives: catalog search, downloads, update checks, deletion.
  * Reuses (or owns & lazily starts) a KiwixServer for local listing/search, so `list()` and `catalog()` return the same shape.
- * Doesn't drive library.xml/kiwix-serve reloads itself - the owning KiwixServer watches its directory and
- * reloads automatically whenever .zim files change, no matter which ZimManager (local or remote-attached) wrote them. */
+ * In-flight downloads/updates are tracked by `href` (unique per catalog entry/flavor - unlike `name`, which collides
+ * across flavors) and merged directly into `list()` (as synthetic pending entries) & `catalog()` (overlaid onto the
+ * matching row), so callers never need a separate progress endpoint - just re-poll list()/catalog() like normal. */
 export class ZimManager {
 	#catalogUrl;
 	#dir;
 	#server;
 	#ownsServer;
+	#active = {}; // href -> {entry: catalogEntry, dl: PromiseProgress}
 
 	/** @param {{catalog?: string, server?: KiwixServer, port?: number, host?: string, binDir?: string, url?: string}} [opts]
 	 * server: reuse an existing KiwixServer instance directly.
@@ -41,41 +47,60 @@ export class ZimManager {
 		return this.#server;
 	}
 
-	async #download(url, destPath) {
+	/** Raw local listing, no pending downloads merged in - used internally for matching against real files on disk. */
+	async #rawList() {
+		const server = await this.#ensureServer();
+		return server.list();
+	}
+
+	/** Streams `url` to `destPath`, reporting raw bytes/total via `onBytes(size, total)` as chunks arrive. */
+	async #download(url, destPath, onBytes) {
 		const {res} = await this.#resolveUrl(url);
 		if (!res.ok) throw new Error(`${res.status} ${res.statusText}`);
+		const total = Number(res.headers.get('content-length')) || 0;
 		const tmpPath = `${destPath}.part`;
-		await pipeline(Readable.fromWeb(res.body), fs.createWriteStream(tmpPath));
+		let size = 0;
+		const readable = Readable.fromWeb(res.body);
+		if (onBytes) readable.on('data', chunk => onBytes(size += chunk.length, total));
+		await pipeline(readable, fs.createWriteStream(tmpPath));
 		await fs.promises.rename(tmpPath, destPath);
 	}
 
 	/** Resolves a `.meta4` metalink URL down to the real mirror `.zim` download URL. */
 	async #resolveUrl(url) {
-		const head = await fetch(url);
+		const head = await fetch(url, {dispatcher: agent});
 		const ct = head.headers.get('content-type') || '';
 		if (!ct.includes('metalink') && !url.endsWith('.meta4')) return {res: head, url};
 		const meta = await head.text();
 		const m = meta.match(/<url[^>]*>([^<]+\.zim)<\/url>/);
 		if (!m) throw new Error('Could not resolve metalink mirror');
-		const res = await fetch(m[1]);
+		const res = await fetch(m[1], {dispatcher: agent});
 		return {res, url: m[1]};
 	}
 
-	/** Polls list() until `filename` shows up (or disappears, if `expect: false`), so callers get an accurate
+	/** Polls #rawList() until `filename` shows up (or disappears, if `expect: false`), so callers get an accurate
 	 * status back rather than one that's ahead of what the server has actually picked up yet. The owning
 	 * KiwixServer's directory watcher does the real reload work in the background; this just waits for it. */
 	async #waitUntilVisible(filename, {expect = true, timeout = VISIBLE_TIMEOUT} = {}) {
 		const deadline = Date.now() + timeout;
+		const server = await this.#ensureServer();
 		while (Date.now() < deadline) {
-			const local = await this.list();
-			const present = local.some(l => l.file === filename);
-			if (present === expect) return true;
+			const local = await this.#rawList();
+			const match = local.find(l => l.file === filename);
+			if (!expect) {
+				if (!match) return true;
+			} else if (match?.name) {
+				const probe = await fetch(`${server.baseUrl}/content/${encodeURIComponent(match.name)}/`).catch(() => null);
+				if (probe?.ok) return true;
+			}
 			await new Promise(r => setTimeout(r, VISIBLE_POLL_INTERVAL));
 		}
 		return false;
 	}
 
-	async #update(name, catalogEntry, localMatch, force) {
+	/** Performs the actual download + post-processing for a resolved catalog entry, forwarding byte progress via `onBytes`. */
+	async #update(catalogEntry, localMatch, force, onBytes) {
+		const name = catalogEntry.name;
 		const remoteDate = catalogEntry.updated ? new Date(catalogEntry.updated) : null;
 		const localDate = localMatch?.updated ?? null;
 		if (!force && localMatch && remoteDate && localDate && remoteDate <= localDate)
@@ -84,15 +109,30 @@ export class ZimManager {
 
 		const filename = path.basename(new URL(catalogEntry.href).pathname).replace(/\.meta4$/i, '');
 		const destPath = path.join(this.#dir, filename);
-		await this.#download(catalogEntry.href, destPath);
+		await this.#download(catalogEntry.href, destPath, onBytes);
 		if (localMatch && localMatch.file !== filename) await fs.promises.rm(path.join(this.#dir, localMatch.file), {force: true});
 		await this.#ensureServer();
 		await this.#waitUntilVisible(filename, {expect: true});
 		return {name, status: 'updated', file: filename};
 	}
 
-	catalog(search, opts = {}) {
-		return zimCatalog(search, {url: this.#catalogUrl, ...opts});
+	/** Wraps `#update` in a tracked `PromiseProgress`, registered in `#active` under the catalog entry's `href`. */
+	#trackedUpdate(catalogEntry, localMatch, force) {
+		const dl = new PromiseProgress((resolve, reject, prog) =>
+			this.#update(catalogEntry, localMatch, force, prog).then(resolve, reject));
+		this.#active[catalogEntry.href] = {entry: catalogEntry, dl};
+		dl.catch(() => {}).finally(() => { if (this.#active[catalogEntry.href]?.dl === dl) delete this.#active[catalogEntry.href]; });
+		return dl;
+	}
+
+	/** Remote catalog search - any entry with a matching in-flight download/update gets live progress fields
+	 * (`progress`/`speed`/`eta`/`size`/`total`/`downloading: true`) merged directly onto it by `href`, so distinct
+	 * flavors of the same `name` never cross-light each other. */
+	async catalog(search, opts = {}) {
+		const results = await zimCatalog(search, {url: this.#catalogUrl, ...opts});
+		return results.map(entry => this.#active[entry.href]
+			? {...this.#active[entry.href].dl.meta, ...entry, downloading: true}
+			: entry);
 	}
 
 	/** Stops the internally-owned KiwixServer, if this manager created its own (no-op if one was passed in). */
@@ -101,28 +141,39 @@ export class ZimManager {
 	}
 
 	async delete(nameOrFile) {
-		const local = await this.list();
+		const local = await this.#rawList();
 		const match = local.find(l => l.name === nameOrFile || l.href === nameOrFile);
 		if (!match) throw new Error(`ZIM not found locally: ${nameOrFile}`);
 		const file = match.href + (match.href.endsWith('.zim') ? '' : '.zim');
+		await this.#server.stop();
 		await fs.promises.rm(path.join(this.#dir, file), {force: true});
 		await this.#ensureServer();
 		await this.#waitUntilVisible(file, {expect: false});
 		return {file: match.file, status: 'deleted'};
 	}
 
-	/** Downloads/updates a single ZIM by direct href, matching against any existing local copy by name. */
-	async download(href, {force = false} = {}) {
+	/** Downloads/updates a single ZIM by direct href, matching against any existing local copy by name.
+	 * Returns a `PromiseProgress` with live `.progress`/`.speed`/`.eta`/etc getters & `onProgress` callback;
+	 * also tracked internally under `href` so `list()`/`catalog()` reflect it even if the reference is dropped. */
+	download(href, {force = false} = {}) {
+		let dl;
+		dl = new PromiseProgress(async (resolve, reject, prog) => {
+			try {
 				const {url: finalUrl} = await this.#resolveUrl(href);
 				const filename = path.basename(new URL(finalUrl).pathname).replace(/\.meta4$/i, '');
 				await fs.promises.mkdir(this.#dir, {recursive: true});
-		const local = await this.list();
+				const local = await this.#rawList();
 				const exact = local.find(l => l.file === filename);
-		if (exact && !force) return {name: exact.name ?? this.#stripDate(filename), status: 'skipped', reason: 'already downloaded', file: filename};
+				if (exact && !force) return resolve({name: exact.name ?? this.#stripDate(filename), status: 'skipped', reason: 'already downloaded', file: filename});
 				const name = this.#stripDate(filename);
 				const localMatch = local.find(l => l.name === name) ?? null;
 				const catalogEntry = await zimCatalogInfo(name, this.#catalogUrl) || {name, updated: null, href};
-		return this.#update(name, catalogEntry, localMatch, force);
+				this.#active[href] = {entry: catalogEntry, dl};
+				dl.catch(() => {}).finally(() => { if (this.#active[href]?.dl === dl) delete this.#active[href]; });
+				resolve(await this.#update(catalogEntry, localMatch, force, prog));
+			} catch (e) { reject(e); }
+		});
+		return dl;
 	}
 
 	async link(href) {
@@ -132,7 +183,7 @@ export class ZimManager {
 
 	/** Checks whether a local ZIM has a newer version in the catalog, without downloading. */
 	async isOutdated(nameOrFile) {
-		const local = await this.list();
+		const local = await this.#rawList();
 		const match = local.find(l => l.name === nameOrFile || l.file === nameOrFile);
 		if (!match?.name) return {file: nameOrFile, upToDate: null, reason: 'no metadata'};
 		const catalogEntry = await zimCatalogInfo(match.name, this.#catalogUrl);
@@ -141,10 +192,17 @@ export class ZimManager {
 		return {file: match.file, name: match.name, upToDate: !!(remoteDate && match.updated && remoteDate <= match.updated), localDate: match.updated, remoteDate};
 	}
 
-	/** Lists local ZIMs - same flat shape as `catalog()` (plus `file`), sourced from the KiwixServer's own library.xml. */
+	/** Local ZIMs - same flat shape as `catalog()` (plus `file`) - with any in-flight downloads/updates appended as
+	 * synthetic pending entries (catalog metadata + live progress fields + `downloading: true`) so the UI always has
+	 * a card to render progress against, even before the file exists on disk. Resolves itself: once the real file
+	 * lands, its name matches the local entry and the synthetic one drops out automatically. */
 	async list() {
-		const server = await this.#ensureServer();
-		return server.list();
+		const local = await this.#rawList();
+		const localNames = new Set(local.map(l => l.name));
+		const pending = Object.values(this.#active)
+			.filter(({entry}) => !localNames.has(entry.name))
+			.map(({entry, dl}) => ({...dl.meta, ...entry, downloading: true}));
+		return [...local, ...pending];
 	}
 
 	/** Fetches a single asset's raw bytes. */
@@ -159,16 +217,17 @@ export class ZimManager {
 		return server.search(terms, {limit, sources});
 	}
 
-	/** Checks all local ZIMs against the catalog and updates any that are outdated. */
+	/** Checks all local ZIMs against the catalog and updates any that are outdated.
+	 * Each in-flight update is tracked in `#active` by href - reflected live via `list()`/`catalog()` mid-run. */
 	async updateAll({force = false} = {}) {
-		const local = await this.list();
+		const local = await this.#rawList();
 		const results = [];
 		for (const entry of local) {
 			if (!entry.name) { results.push({file: entry.file, status: 'skipped', reason: 'no metadata'}); continue; }
 			const catalogEntry = await zimCatalogInfo(entry.name, this.#catalogUrl);
 			if (!catalogEntry) { results.push({name: entry.name, status: 'skipped', reason: 'missing from catalog'}); continue; }
 			try {
-				results.push(await this.#update(entry.name, catalogEntry, entry, force));
+				results.push(await this.#trackedUpdate(catalogEntry, entry, force));
 			} catch (e) {
 				results.push({name: entry.name, status: 'error', reason: e.message});
 			}

src/search.js

@@ -101,7 +101,7 @@ export function rerank(hits, termList) {
 		const title = fieldScore(hit.title, termList, {fuzzy: true});
 		const summary = fieldScore(hit.summary, termList);
 		const titleLower = (hit.title || '').toLowerCase();
-		const summaryLower = (hit.summary || '').toLowerCase();
+		const summaryLower = (hit.summary?._text || '').toLowerCase();
 		const phrase = termList.join(' ').toLowerCase();
 
 		const titleExactPhrase = titleLower.includes(phrase) ? 1 : 0;

src/server.js

@@ -32,6 +32,12 @@ function tokenize(terms) {
 	return String(terms).split(/[,\s]+/).map(t => t.trim()).filter(Boolean);
 }
 
+function normalizeSummary(summary) {
+	if(typeof summary === 'string') return summary;
+	if(summary && typeof summary === 'object') return summary._text || '';
+	return '';
+}
+
 export class KiwixServer {
 	static #empty = '<?xml version="1.0" encoding="UTF-8" ?>\n<library version="20110515"></library>\n';
 
@@ -89,20 +95,16 @@ export class KiwixServer {
 
 	async #rebuildLibrary() {
 		if(this.#remote) return;
-
-		await fs.promises.rm(this.#libraryPath, {force: true});
-
 		const files = await this.#zimFiles();
-
-		if(!files.length)
-			return fs.promises.writeFile(this.#libraryPath, KiwixServer.#empty);
-
+		const tmpPath = `${this.#libraryPath}.tmp-${process.pid}`;
+		await fs.promises.rm(tmpPath, {force: true});
+		if(!files.length) {
+			await fs.promises.writeFile(tmpPath, KiwixServer.#empty);
+		} else {
 			for(const file of files)
-			await execFileAsync(this.#bin('kiwix-manage'), [
-				this.#libraryPath,
-				'add',
-				path.join(this.#dir, file),
-			]);
+				await execFileAsync(this.#bin('kiwix-manage'), [tmpPath, 'add', path.join(this.#dir, file)]);
+		}
+		await fs.promises.rename(tmpPath, this.#libraryPath);
 	}
 
 	async #waitUntilReady() {
@@ -212,13 +214,13 @@ export class KiwixServer {
 
 		return makeArray(entries?.library?.book || []).map(e => {
 			const tags = e.tags.split(';');
-			const name = e.path.replace('.zim', '');
+			const name = e.path.replace(/\.zim$/i, '');
 
 			return {
 				id: e.id,
 				title: e.title,
 				updated: new Date(e.date),
-				summary: e.description,
+				summary: normalizeSummary(e.description),
 				language: e.language,
 				name: e.name,
 				category: tags.find(t => t.startsWith('_category'))?.slice(10) || '',
@@ -262,53 +264,43 @@ export class KiwixServer {
 	}
 
 	async #rawSearch(termList, scoped, bookMap, limit) {
-		const groups = new Map();
-
-		for(const book of scoped) {
-			const lang = book.language || '';
-			(groups.get(lang) ?? groups.set(lang, []).get(lang)).push(book);
-		}
-
-		const perGroup = await Promise.all([...groups.values()].map(async group => {
+		const perBook = await Promise.all(scoped.map(async book => {
 			const params = new URLSearchParams({
 				pattern: termList.join(' '),
 				format: 'xml',
 				pageLength: String(limit),
+				'books.name': book.href,
 			});
 
-			for(const book of group)
-				params.append('books.name', book.name);
-
 			const res = await fetch(`${this.baseUrl}/search?${params}`);
 			if(!res.ok) return [];
 
 			const found = fromXml(await res.text())?.rss?.channel?.item || [];
 
-			return found.map(hit => {
-				const book = bookMap.get(hit.book.title);
-				if(!book) return null;
+			return makeArray(found).map(hit => {
+				const resultBook = bookMap.get(hit.book?.title) || book;
 
-				const prefix = `/content/${book.href}/`;
+				const prefix = `/content/${resultBook.href}/`;
 				const page = hit.link.startsWith(prefix)
 					? hit.link.slice(prefix.length)
 					: hit.link.replace(/^\/+/, '');
 
 				return {
-					id: book.id,
+					id: resultBook.id,
 					title: hit.title,
 					page,
-					name: book.name,
-					publisher: book.publisher,
-					href: `${book.href}/${page}`,
-					icon: book.icon,
+					name: resultBook.name,
+					publisher: resultBook.publisher,
+					href: `${resultBook.href}/${page}`,
+					icon: resultBook.icon,
 					viewer: this.baseUrl + hit.link,
-					summary: hit.description,
+					summary: normalizeSummary(hit.description),
 					xapianScore: +hit.score || 0,
 				};
-			}).filter(Boolean).sort((a, b) => b.xapianScore - a.xapianScore);
+			}).filter(Boolean);
 		}));
 
-		return rrfMerge(perGroup);
+		return rrfMerge(perBook);
 	}
 
 	/** Fulltext search across local ZIMs with ranking, diversification and spelling correction. */
@@ -320,6 +312,7 @@ export class KiwixServer {
 
 		const books = await this.list();
 		const bookMap = new Map(books.map(b => [b.title, b]));
+
 		const scoped = sources?.length
 			? books.filter(b => sources.includes(b.name) || sources.includes(b.href))
 			: books;
@@ -360,8 +353,10 @@ export class KiwixServer {
 			}
 		}
 
+		const ranked = rerank(hits, activeTerms);
+
 		return {
-			results: diversify(rerank(hits, activeTerms), limit),
+			results: diversify(ranked, limit),
 			spellcheck,
 		};
 	}